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 523 matching lines @@
       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 ? GetRandomTransitDelay(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 = GetRandomTransitDelay(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 = GetRandomTransitDelay(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);
   }
 
@@ skipping 48 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);
   }
 }
 
+void VirtualSocketServer::UpdateDelayDistributionForIPv6() {
+  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_);
+    delay_dist_ipv6_.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));
 }
 
 #if 0  // static unused gives a warning
 static double Pareto(double x, double min, double k) {
   if (x < min)
@@ skipping 19 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() {
-  size_t index = rand() % delay_dist_->size();
-  double delay = (*delay_dist_)[index].second;
-  //LOG_F(LS_INFO) << "random[" << index << "] = " << delay;
+uint32_t VirtualSocketServer::GetRandomTransitDelay(Socket* socket) {
+  Function* delay_dist = delay_dist_.get();
+  if (socket->GetLocalAddress().family() == AF_INET6 && delay_dist_ipv6_) {
+    delay_dist = delay_dist_ipv6_.get();
+  }
+
+  size_t index = rand() % delay_dist->size();
+  double delay = (*delay_dist)[index].second;
+  // 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