Adding ability to simulate EWOULDBLOCK/SignalReadyToSend.

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 12 matching lines @@
 namespace rtc {
 
 class Packet;
 class VirtualSocket;
 class SocketAddressPair;
 
 // Simulates a network in the same manner as a loopback interface.  The
 // interface can create as many addresses as you want.  All of the sockets
 // created by this network will be able to communicate with one another, unless
 // they are bound to addresses from incompatible families.
 class VirtualSocketServer : public SocketServer, public sigslot::has_slots<> {

[skvlad, 2016/08/26 22:39:04]

Not related to the code review, more like a general question: do we have some
convention to indicate that this is test code? Otherwise it is hard for someone
who's new to the codebase to understand if the class is being used in production
or only in tests.

[Taylor Brandstetter, 2016/08/26 23:01:03]

The current convention seems to be to put test code in a "test" subdirectory.
There's one in "base", but it only has one file, dated 2016. We should move the
rest of the test code into there at some point.

  public:
   // TODO: Add "owned" parameter.
   // If "owned" is set, the supplied socketserver will be deleted later.
   explicit VirtualSocketServer(SocketServer* ss);
   ~VirtualSocketServer() override;
 
   SocketServer* socketserver() { return server_; }
 
   // The default route indicates which local address to use when a socket is
   // bound to the 'any' address, e.g. 0.0.0.0.
@@ skipping 39 matching lines @@
   void UpdateDelayDistribution();
 
   // 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
+  // returned, with the socket error set to EWOULDBLOCK.
+  //
+  // If this method is later called with |blocked| set to false, any sockets
+  // that previously failed to send with EWOULDBLOCK will emit SignalWriteEvent.
+  //
+  // This can be used to simulate the send buffer on a network interface being
+  // full, and test functionality related to EWOULDBLOCK/SignalWriteEvent.
+  void SetSendingBlocked(bool blocked);
+
   // SocketFactory:
   Socket* CreateSocket(int type) override;
   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;
@@ skipping 113 matching lines @@
   // This applies even if the IPv4 address is 0.0.0.0.
   // The socket arguments are optional; the sockets are checked to see if they
   // were explicitly bound to IPv6-any ('::'), and if so communication is
   // permitted.
   // NB: This scheme doesn't permit non-dualstack IPv6 sockets.
   static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
 
  private:
   friend class VirtualSocket;
 
+  // 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_;
   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, public MessageHandler {
+class VirtualSocket : public AsyncSocket,
+                      public MessageHandler,
+                      public sigslot::has_slots<> {
  public:
   VirtualSocket(VirtualSocketServer* server, int family, int type, bool async);
   ~VirtualSocket() override;
 
   SocketAddress GetLocalAddress() const override;
   SocketAddress GetRemoteAddress() const override;
 
   // Used by TurnPortTest to mimic a case where proxy returns local host address
   // instead of the original one TurnPort was bound against. Please see WebRTC
   // issue 3927 for more detail.
@@ skipping 39 matching lines @@
   typedef std::map<Option, int> OptionsMap;
 
   int InitiateConnect(const SocketAddress& addr, bool use_delay);
   void CompleteConnect(const SocketAddress& addr, bool notify);
   int SendUdp(const void* pv, size_t cb, const SocketAddress& addr);
   int SendTcp(const void* pv, size_t cb);
 
   // Used by server sockets to set the local address without binding.
   void SetLocalAddress(const SocketAddress& addr);
 
+  void OnSocketServerReadyToSend();
+
   VirtualSocketServer* server_;
   int type_;
   bool async_;
   ConnState state_;
   int error_;
   SocketAddress local_addr_;
   SocketAddress alternative_local_addr_;
   SocketAddress remote_addr_;
 
   // Pending sockets which can be Accepted
   ListenQueue* listen_queue_;
 
   // Data which tcp has buffered for sending
   SendBuffer send_buffer_;
-  bool write_enabled_;
+  // 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_;
 
   // Data which has been received from the network
   RecvBuffer recv_buffer_;
@@ skipping 11 matching lines @@
 
   // Store the options that are set
   OptionsMap options_map_;
 
   friend class VirtualSocketServer;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_VIRTUALSOCKETSERVER_H_