Signal to remove remote candidates if ports are pruned.

webrtc/base/virtualsocketserver.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 510 matching lines @@
     // SignalWriteEvent if successful.
     server_->SendTcp(this);
   }
 }
 
 VirtualSocketServer::VirtualSocketServer(SocketServer* ss)
     : server_(ss),
       server_owned_(false),
       msg_queue_(NULL),
       stop_on_idle_(false),
-      network_delay_(0),
       next_ipv4_(kInitialNextIPv4),
       next_ipv6_(kInitialNextIPv6),
       next_port_(kFirstEphemeralPort),
       bindings_(new AddressMap()),
       connections_(new ConnectionMap()),
       bandwidth_(0),
       network_capacity_(kDefaultNetworkCapacity),
       send_buffer_capacity_(kDefaultTcpBufferSize),
       recv_buffer_capacity_(kDefaultTcpBufferSize),
       delay_mean_(0),
       delay_stddev_(0),
       delay_samples_(NUM_SAMPLES),
-      delay_dist_(NULL),
       drop_prob_(0.0) {
   if (!server_) {
     server_ = new PhysicalSocketServer();
     server_owned_ = true;
   }
   UpdateDelayDistribution();
 }
 
 VirtualSocketServer::~VirtualSocketServer() {
   delete bindings_;
   delete connections_;
-  delete delay_dist_;
   if (server_owned_) {
     delete server_;
   }
 }
 
 IPAddress VirtualSocketServer::GetNextIP(int family) {
   if (family == AF_INET) {
     IPAddress next_ip(next_ipv4_);
     next_ipv4_.s_addr =
         HostToNetwork32(NetworkToHost32(next_ipv4_.s_addr) + 1);
@@ skipping 207 matching lines @@
   connections_->erase(address_pair);
 }
 
 static double Random() {
   return static_cast<double>(rand()) / RAND_MAX;
 }
 
 int VirtualSocketServer::Connect(VirtualSocket* socket,
                                  const SocketAddress& remote_addr,
                                  bool use_delay) {
-  uint32_t delay = use_delay ? GetRandomTransitDelay() : 0;
+  uint32_t delay = use_delay ? GetTransitDelay(socket) : 0;
   VirtualSocket* remote = LookupBinding(remote_addr);
   if (!CanInteractWith(socket, remote)) {
     LOG(LS_INFO) << "Address family mismatch between "
                  << socket->GetLocalAddress() << " and " << remote_addr;
     return -1;
   }
   if (remote != NULL) {
     SocketAddress addr = socket->GetLocalAddress();
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, remote, MSG_ID_CONNECT,
                             new MessageAddress(addr));
   } else {
     LOG(LS_INFO) << "No one listening at " << remote_addr;
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, socket, MSG_ID_DISCONNECT);
   }
   return 0;
 }
 
 bool VirtualSocketServer::Disconnect(VirtualSocket* socket) {
   if (socket) {
     // If we simulate packets being delayed, we should simulate the
     // equivalent of a FIN being delayed as well.
-    uint32_t delay = GetRandomTransitDelay();
+    uint32_t delay = GetTransitDelay(socket);
     // Remove the mapping.
     msg_queue_->PostDelayed(RTC_FROM_HERE, delay, socket, MSG_ID_DISCONNECT);
     return true;
   }
   return false;
 }
 
 int VirtualSocketServer::SendUdp(VirtualSocket* socket,
                                  const char* data, size_t data_size,
                                  const SocketAddress& remote_addr) {
@@ skipping 123 matching lines @@
                                              bool ordered) {
   VirtualSocket::NetworkEntry entry;
   entry.size = data_size + header_size;
 
   sender->network_size_ += entry.size;
   uint32_t send_delay = SendDelay(static_cast<uint32_t>(sender->network_size_));
   entry.done_time = cur_time + send_delay;
   sender->network_.push_back(entry);
 
   // Find the delay for crossing the many virtual hops of the network.
-  uint32_t transit_delay = GetRandomTransitDelay();
+  uint32_t transit_delay = GetTransitDelay(sender);
 
   // When the incoming packet is from a binding of the any address, translate it
   // to the default route here such that the recipient will see the default
   // route.
   SocketAddress sender_addr = sender->local_addr_;
   IPAddress default_ip = GetDefaultRoute(sender_addr.ipaddr().family());
   if (sender_addr.IsAnyIP() && !IPIsUnspec(default_ip)) {
     sender_addr.SetIP(default_ip);
   }
 
   // Post the packet as a message to be delivered (on our own thread)
   Packet* p = new Packet(data, data_size, sender_addr);
 
   int64_t ts = TimeAfter(send_delay + transit_delay);
   if (ordered) {
     // Ensure that new packets arrive after previous ones
-    // TODO: consider ordering on a per-socket basis, since this
-    // introduces artificial delay.
-    ts = std::max(ts, network_delay_);
+    ts = std::max(ts, sender->last_delivery_time_);
+    // A socket should not have both ordered and unordered delivery, so its last
+    // delivery time only needs to be updated when it has ordered delivery.
+    sender->last_delivery_time_ = ts;
   }
   msg_queue_->PostAt(RTC_FROM_HERE, ts, recipient, MSG_ID_PACKET, p);
-  network_delay_ = std::max(ts, network_delay_);
 }
 
 void VirtualSocketServer::PurgeNetworkPackets(VirtualSocket* socket,
                                               int64_t cur_time) {
   while (!socket->network_.empty() &&
          (socket->network_.front().done_time <= cur_time)) {
     RTC_DCHECK(socket->network_size_ >= socket->network_.front().size);
     socket->network_size_ -= socket->network_.front().size;
     socket->network_.pop_front();
   }
@@ skipping 26 matching lines @@
   }
 }
 #endif  // <unused>
 
 void VirtualSocketServer::UpdateDelayDistribution() {
   Function* dist = CreateDistribution(delay_mean_, delay_stddev_,
                                       delay_samples_);
   // We take a lock just to make sure we don't leak memory.
   {
     CritScope cs(&delay_crit_);
-    delete delay_dist_;
-    delay_dist_ = dist;
+    delay_dist_.reset(dist);
   }
 }
 
 static double PI = 4 * atan(1.0);
 
 static double Normal(double x, double mean, double stddev) {
   double a = (x - mean) * (x - mean) / (2 * stddev * stddev);
   return exp(-a) / (stddev * sqrt(2 * PI));
 }
 
@@ skipping 22 matching lines @@
 
     for (uint32_t i = 0; i < samples; i++) {
       double x = start + (end - start) * i / (samples - 1);
       double y = Normal(x, mean, stddev);
       f->push_back(Point(x, y));
     }
   }
   return Resample(Invert(Accumulate(f)), 0, 1, samples);
 }
 
-uint32_t VirtualSocketServer::GetRandomTransitDelay() {
+uint32_t VirtualSocketServer::GetTransitDelay(Socket* socket) {
+  // Use the delay based on the address if it is set.
+  auto iter = delay_by_ip_.find(socket->GetLocalAddress().ipaddr());
+  if (iter != delay_by_ip_.end()) {
+    return static_cast<uint32_t>(iter->second);
+  }
+  // Otherwise, use the delay from the distribution distribution.
   size_t index = rand() % delay_dist_->size();
   double delay = (*delay_dist_)[index].second;
-  //LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
+  // LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
   return static_cast<uint32_t>(delay);
 }
 
 struct FunctionDomainCmp {
   bool operator()(const VirtualSocketServer::Point& p1,
                    const VirtualSocketServer::Point& p2) {
     return p1.first < p2.first;
   }
   bool operator()(double v1, const VirtualSocketServer::Point& p2) {
     return v1 < p2.first;
@@ skipping 112 matching lines @@
 void VirtualSocketServer::SetDefaultRoute(const IPAddress& from_addr) {
   RTC_DCHECK(!IPIsAny(from_addr));
   if (from_addr.family() == AF_INET) {
     default_route_v4_ = from_addr;
   } else if (from_addr.family() == AF_INET6) {
     default_route_v6_ = from_addr;
   }
 }
 
 }  // namespace rtc