TcpPort Reconnect should inform upper layer to start sending again

webrtc/p2p/base/port_unittest.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 214 matching lines @@
   }
   void CreateConnection() {
     conn_ = src_->CreateConnection(GetCandidate(dst_), Port::ORIGIN_MESSAGE);
     IceMode remote_ice_mode =
         (ice_mode_ == ICEMODE_FULL) ? ICEMODE_LITE : ICEMODE_FULL;
     conn_->set_remote_ice_mode(remote_ice_mode);
     conn_->set_use_candidate_attr(remote_ice_mode == ICEMODE_FULL);
     conn_->SignalStateChange.connect(
         this, &TestChannel::OnConnectionStateChange);
     conn_->SignalDestroyed.connect(this, &TestChannel::OnDestroyed);
+    conn_->SignalReadyToSend.connect(this,
+                                     &TestChannel::OnConnectionReadyToSend);
+    is_recovered_from_ewouldblock_ = false;

[pthatcher1, 2015/08/20 03:47:27]

Would it make sense to call this connection_ready_to_send_ ?

[juberti1, 2015/08/20 05:33:00]

+1

   }
   void OnConnectionStateChange(Connection* conn) {
     if (conn->write_state() == Connection::STATE_WRITABLE) {
       conn->set_use_candidate_attr(true);
       nominated_ = true;
     }
   }
   void AcceptConnection() {
     ASSERT_TRUE(remote_request_.get() != NULL);
     Candidate c = GetCandidate(dst_);
@@ skipping 69 matching lines @@
 
   void OnSrcPortDestroyed(PortInterface* port) {
     Port* destroyed_src = src_.release();
     ASSERT_EQ(destroyed_src, port);
   }
 
   Port* src_port() { return src_.get(); }
 
   bool nominated() const { return nominated_; }
 
+  void set_is_recovered_from_ewouldblock(bool ready) {
+    is_recovered_from_ewouldblock_ = ready;
+  }
+  bool is_recovered_from_ewouldblock() const {
+    return is_recovered_from_ewouldblock_;
+  }
+
  private:
+  // ReadyToSend will only issue after a Connection recovers from EWOULDBLOCK.
+  void OnConnectionReadyToSend(Connection* conn) {
+    ASSERT_EQ(conn, conn_);
+    is_recovered_from_ewouldblock_ = true;
+  }
+
   IceMode ice_mode_;
   rtc::scoped_ptr<Port> src_;
   Port* dst_;
 
   int complete_count_;
   Connection* conn_;
   SocketAddress remote_address_;
   rtc::scoped_ptr<StunMessage> remote_request_;
   std::string remote_frag_;
   bool nominated_;
+  bool is_recovered_from_ewouldblock_ = false;
 };
 
 class PortTest : public testing::Test, public sigslot::has_slots<> {
  public:
   PortTest()
       : main_(rtc::Thread::Current()),
         pss_(new rtc::PhysicalSocketServer),
         ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()),
         network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
@@ skipping 272 matching lines @@
     ch1.CreateConnection();
     ConnectStartedChannels(&ch1, &ch2);
 
     // Shorten the timeout period.
     const int kTcpReconnectTimeout = kTimeout;
     static_cast<TCPConnection*>(ch1.conn())
         ->set_reconnection_timeout(kTcpReconnectTimeout);
     static_cast<TCPConnection*>(ch2.conn())
         ->set_reconnection_timeout(kTcpReconnectTimeout);
 
+    EXPECT_FALSE(ch1.is_recovered_from_ewouldblock());
+    EXPECT_FALSE(ch2.is_recovered_from_ewouldblock());
+
     // Once connected, disconnect them.
     DisconnectTcpTestChannels(&ch1, &ch2);
 
     if (send_after_disconnected || ping_after_disconnected) {
       if (send_after_disconnected) {
         // First SendData after disconnect should fail but will trigger
         // reconnect.
         EXPECT_EQ(-1, ch1.SendData(data, static_cast<int>(strlen(data))));
       }
 
       if (ping_after_disconnected) {
         // Ping should trigger reconnect.
         ch1.Ping();
       }
 
       // Wait for channel's outgoing TCPConnection connected.
       EXPECT_TRUE_WAIT(ch1.conn()->connected(), kTimeout);
 
       // Verify that we could still connect channels.
       ConnectStartedChannels(&ch1, &ch2);
+      EXPECT_TRUE_WAIT(ch1.is_recovered_from_ewouldblock(),
+                       kTcpReconnectTimeout);
+      // Channel2 is the passive one so a new connection is created during
+      // reconnect. This new connection should never have issued EWOULDBLOCK
+      // hence the is_recovered_from_ewouldblock() should be false.
+      EXPECT_FALSE(ch2.is_recovered_from_ewouldblock());
     } else {
       EXPECT_EQ(ch1.conn()->write_state(), Connection::STATE_WRITABLE);
       EXPECT_TRUE_WAIT(
           ch1.conn()->write_state() == Connection::STATE_WRITE_TIMEOUT,
           kTcpReconnectTimeout + kTimeout);
+      EXPECT_FALSE(ch1.is_recovered_from_ewouldblock());
+      EXPECT_FALSE(ch2.is_recovered_from_ewouldblock());
     }
 
     // Tear down and ensure that goes smoothly.
     ch1.Stop();
     ch2.Stop();
     EXPECT_TRUE_WAIT(ch1.conn() == NULL, kTimeout);
     EXPECT_TRUE_WAIT(ch2.conn() == NULL, kTimeout);
   }
 
   void SetIceProtocolType(cricket::IceProtocolType protocol) {
@@ skipping 1979 matching lines @@
   // Set up channels and ensure both ports will be deleted.
   TestChannel ch1(port1, port2);
   TestChannel ch2(port2, port1);
 
   // Simulate a connection that succeeds, and then is destroyed.
   StartConnectAndStopChannels(&ch1, &ch2);
 
   // The controlled port should be destroyed after 10 milliseconds.
   EXPECT_TRUE_WAIT(destroyed(), kTimeout);
 }