TcpPort Reconnect should inform upper layer to start sending again

webrtc/p2p/base/tcpport.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 316 matching lines @@
   // to spend a few seconds attempting a reconnect before saying we're
   // unwritable.
   if (!connected()) {
     MaybeReconnect();
     return SOCKET_ERROR;
   }
 
   // Note that this is important to put this after the previous check to give
   // the connection a chance to reconnect.
   if (pretending_to_be_writable_ || write_state() != STATE_WRITABLE) {
     // TODO: Should STATE_WRITE_TIMEOUT return a non-blocking error?

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

Would this be a better way to address it?  Not use EWOULDBLOCK?

     error_ = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
   sent_packets_total_++;
   int sent = socket_->Send(data, size, options);
   if (sent < 0) {
     sent_packets_discarded_++;
     error_ = socket_->GetError();
   } else {
     send_rate_tracker_.Update(sent);
   }
   return sent;
 }
 
 int TCPConnection::GetError() {
   return error_;
 }
 
 void TCPConnection::OnConnectionRequestResponse(ConnectionRequest* req,
                                                 StunMessage* response) {
-  // Once we receive a binding response, we are really writable, and not just
-  // pretending to be writable.
+  // If we're in the state of pretending to be writeable, we should inform the
+  // upper layer it's ready to send again as previous EWOULDLBLOCK from socket
+  // would have stopped the outgoing stream.
+  if (pretending_to_be_writable_) {
+    Connection::OnReadyToSend();

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

If we fire OnReadyToSend() when we go from pretending to not pretending, should
we have a "not ready to send" signal that fires when we do the opposite (inside
of OnClose)?

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

That is driven by EWOULDBLOCK being returned from Send().

But do we want to do this before letting Connection process the STUN response?
We might get called back with packets immediately.

[guoweis_webrtc, 2015/08/21 05:05:50]

Yes, this is possible. Moved this down

+  }
   pretending_to_be_writable_ = false;
   Connection::OnConnectionRequestResponse(req, response);
   ASSERT(write_state() == STATE_WRITABLE);
 }
 
 void TCPConnection::OnConnect(rtc::AsyncPacketSocket* socket) {
   ASSERT(socket == socket_);
   // Do not use this connection if the socket bound to a different address than
   // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
   // given a binding address, and the platform is expected to pick the
@@ skipping 98 matching lines @@
 void TCPConnection::ConnectSocketSignals(rtc::AsyncPacketSocket* socket) {
   if (outgoing_) {
     socket->SignalConnect.connect(this, &TCPConnection::OnConnect);
   }
   socket->SignalReadPacket.connect(this, &TCPConnection::OnReadPacket);
   socket->SignalReadyToSend.connect(this, &TCPConnection::OnReadyToSend);
   socket->SignalClose.connect(this, &TCPConnection::OnClose);
 }
 
 }  // namespace cricket