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 94 matching lines @@
   Socket* CreateSocket(int family, int type) override;
 
   AsyncSocket* CreateAsyncSocket(int type) override;
   AsyncSocket* CreateAsyncSocket(int family, int type) override;
 
   // SocketServer:
   void SetMessageQueue(MessageQueue* queue) override;
   bool Wait(int cms, bool process_io) override;
   void WakeUp() override;
 
+  void SetDelayOnAddress(const rtc::SocketAddress& address, int delay_ms) {
+    delay_by_ip_[address.ipaddr()] = delay_ms;
+  }
+
   typedef std::pair<double, double> Point;
   typedef std::vector<Point> Function;
 
   static Function* CreateDistribution(uint32_t mean,
                                       uint32_t stddev,
                                       uint32_t samples);
 
   // Similar to Thread::ProcessMessages, but it only processes messages until
   // there are no immediate messages or pending network traffic.  Returns false
   // if Thread::Stop() was called.
@@ skipping 62 matching lines @@
                           size_t data_size,
                           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();
+  // If the delay has been set for the address of the socket, returns the set
+  // delay. Otherwise, returns a random transit delay chosen from the
+  // appropriate distribution.
+  uint32_t GetTransitDelay(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 27 matching lines @@
   // Sending was previously blocked, but now isn't.
   sigslot::signal0<> SignalReadyToSend;
 
   typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
   typedef std::map<SocketAddressPair, VirtualSocket*> ConnectionMap;
 
   SocketServer* server_;
   bool server_owned_;
   MessageQueue* msg_queue_;
   bool stop_on_idle_;
-  int64_t network_delay_;
   in_addr next_ipv4_;
   in6_addr next_ipv6_;
   uint16_t next_port_;
   AddressMap* bindings_;
   ConnectionMap* connections_;
 
   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::map<rtc::IPAddress, int> delay_by_ip_;
+  std::unique_ptr<Function> delay_dist_;
+
   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 77 matching lines @@
   // Set to false if the last attempt to send resulted in EWOULDBLOCK.
   // Set back to true when the socket can send again.
   bool ready_to_send_ = true;
 
   // Critical section to protect the recv_buffer and queue_
   CriticalSection crit_;
 
   // Network model that enforces bandwidth and capacity constraints
   NetworkQueue network_;
   size_t network_size_;
+  // The scheduled delivery time of the last packet sent on this socket.
+  // It is used to ensure ordered delivery of packets sent on this socket.
+  int64_t last_delivery_time_ = 0;
 
   // Data which has been received from the network
   RecvBuffer recv_buffer_;
   // The amount of data which is in flight or in recv_buffer_
   size_t recv_buffer_size_;
 
   // Is this socket bound?
   bool bound_;
 
   // When we bind a socket to Any, VSS's Bind gives it another address. For
   // dual-stack sockets, we want to distinguish between sockets that were
   // explicitly given a particular address and sockets that had one picked
   // for them by VSS.
   bool was_any_;
 
   // Store the options that are set
   OptionsMap options_map_;
 
   friend class VirtualSocketServer;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_VIRTUALSOCKETSERVER_H_