Signal to remove remote candidates if ports are pruned.

webrtc/base/virtualsocketserver.h

 /*
  *  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 61 matching lines @@
   uint32_t delay_mean() const { return delay_mean_; }
   uint32_t delay_stddev() const { return delay_stddev_; }
   uint32_t delay_samples() const { return delay_samples_; }
   void set_delay_mean(uint32_t delay_mean) { delay_mean_ = delay_mean; }
   void set_delay_stddev(uint32_t delay_stddev) { delay_stddev_ = delay_stddev; }
   void set_delay_samples(uint32_t delay_samples) {
     delay_samples_ = delay_samples;
   }
 
   // If the (transit) delay parameters are modified, this method should be
-  // called to recompute the new distribution.
+  // called to recompute the new distribution for the transit delay.
+  // If |delay_dist_ipv6_| is set, that will be used for the delay distribution

[Taylor Brandstetter, 2016/09/15 00:43:17]

nit: Since delay_dist_ is an implementation detail, I don't think it should be
mentioned in these comments.

It may be more clear to just have UpdateDelayDistribution,
UpdateDelayDistributionForIPv4 and UpdateDelayDistributionForIPv6, where the
first method updates both.

[honghaiz3, 2016/09/16 01:41:29]

This change has been reverted. 

+  // of IPv6 sockets.
   void UpdateDelayDistribution();
+  // Computes a new delay distribution for IPv6 sockets using the current
+  // delay parameters. If this was not called to create a delay distribution
+  // for IPv6 sockets, IPv6 sockets use the same delay distribution as
+  // |delay_dist_| set by UpdateDelayDistribution().
+  void UpdateDelayDistributionForIPv6();

[Taylor Brandstetter, 2016/09/15 00:43:17]

I think this is good, but another idea would to have a method to set the delay
for a specific 5-tuple. Then we could set the delay for one TURN server to be
larger than another, even with all other things equal. It would also avoid
having to keep track of 4 delay_dist variables when we start differentiating UDP
vs. TCP delay.

[honghaiz3, 2016/09/16 01:41:29]

I changed to set the delay for source socket address only. It is sufficient for
most test cases I can think of. 
It would be more complicated to make it based on 5-tuple and I don't see an
immediate use case yet.

[Taylor Brandstetter, 2016/09/16 17:21:17]

Sounds good; after thinking about it a bit I agree.

 
   // Controls the (uniform) probability that any sent packet is dropped.  This
   // is separate from calculations to drop based on queue size.
   double drop_probability() { return drop_prob_; }
   void set_drop_probability(double drop_prob) {
     assert((0 <= drop_prob) && (drop_prob <= 1));
     drop_prob_ = drop_prob;
   }
 
   // If |blocked| is true, subsequent attempts to send will result in -1 being
@@ skipping 94 matching lines @@
                           size_t header_size,
                           bool ordered);
 
   // Removes stale packets from the network
   void PurgeNetworkPackets(VirtualSocket* socket, int64_t cur_time);
 
   // Computes the number of milliseconds required to send a packet of this size.
   uint32_t SendDelay(uint32_t size);
 
   // Returns a random transit delay chosen from the appropriate distribution.
-  uint32_t GetRandomTransitDelay();
+  uint32_t GetRandomTransitDelay(Socket* socket);
 
   // Basic operations on functions.  Those that return a function also take
   // ownership of the function given (and hence, may modify or delete it).
   static Function* Accumulate(Function* f);
   static Function* Invert(Function* f);
   static Function* Resample(Function* f,
                             double x1,
                             double x2,
                             uint32_t samples);
   static double Evaluate(Function* f, double x);
@@ skipping 44 matching lines @@
   IPAddress default_route_v4_;
   IPAddress default_route_v6_;
 
   uint32_t bandwidth_;
   uint32_t network_capacity_;
   uint32_t send_buffer_capacity_;
   uint32_t recv_buffer_capacity_;
   uint32_t delay_mean_;
   uint32_t delay_stddev_;
   uint32_t delay_samples_;
-  Function* delay_dist_;
+  std::unique_ptr<Function> delay_dist_;
+  std::unique_ptr<Function> delay_dist_ipv6_;
+
   CriticalSection delay_crit_;
 
   double drop_prob_;
   bool sending_blocked_ = false;
   RTC_DISALLOW_COPY_AND_ASSIGN(VirtualSocketServer);
 };
 
 // Implements the socket interface using the virtual network.  Packets are
 // passed as messages using the message queue of the socket server.
 class VirtualSocket : public AsyncSocket,
@@ skipping 101 matching lines @@
 
   // Store the options that are set
   OptionsMap options_map_;
 
   friend class VirtualSocketServer;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_VIRTUALSOCKETSERVER_H_