Adding IceConfig option to assume TURN/TURN candidate pairs will work.

webrtc/p2p/base/port.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 807 matching lines @@
  private:
   Connection* connection_;
 };
 
 //
 // Connection
 //
 
 Connection::Connection(Port* port,
                        size_t index,
-                       const Candidate& remote_candidate)
+                       const Candidate& remote_candidate,
+                       const IceConfig& config)
     : port_(port),
       local_candidate_index_(index),
       remote_candidate_(remote_candidate),
-      write_state_(STATE_WRITE_INIT),
       receiving_(false),
       connected_(true),
       pruned_(false),
       use_candidate_attr_(false),
       nominated_(false),
       remote_ice_mode_(ICEMODE_FULL),
       requests_(port->thread()),
       rtt_(DEFAULT_RTT),
       last_ping_sent_(0),
       last_ping_received_(0),
       last_data_received_(0),
       last_ping_response_received_(0),
       recv_rate_tracker_(100, 10u),
       send_rate_tracker_(100, 10u),
       reported_(false),
       state_(STATE_WAITING),
       receiving_timeout_(WEAK_CONNECTION_RECEIVE_TIMEOUT),
-      time_created_ms_(rtc::TimeMillis()) {
+      time_created_ms_(rtc::TimeMillis()),
+      presume_writable_when_fully_relayed_(
+          config.presume_writable_when_fully_relayed) {
   // All of our connections start in WAITING state.
   // TODO(mallinath) - Start connections from STATE_FROZEN.
+  write_state_ = InitialWriteState();
   // Wire up to send stun packets
   requests_.SignalSendPacket.connect(this, &Connection::OnSendStunPacket);
   LOG_J(LS_INFO, this) << "Connection created";
 }
 
 Connection::~Connection() {
 }
 
 const Candidate& Connection::local_candidate() const {
   ASSERT(local_candidate_index_ < port_->Candidates().size());
@@ skipping 88 matching lines @@
   if (!port_->GetStunMessage(data, size, addr, &msg, &remote_ufrag)) {
     // The packet did not parse as a valid STUN message
     // This is a data packet, pass it along.
     set_receiving(true);
     last_data_received_ = rtc::TimeMillis();
     recv_rate_tracker_.AddSamples(size);
     SignalReadPacket(this, data, size, packet_time);
 
     // If timed out sending writability checks, start up again
     if (!pruned_ && (write_state_ == STATE_WRITE_TIMEOUT)) {
+      set_write_state(InitialWriteState());
       LOG(LS_WARNING) << "Received a data packet on a timed-out Connection. "
-                      << "Resetting state to STATE_WRITE_INIT.";
-      set_write_state(STATE_WRITE_INIT);
+                      << "Reset state to " << write_state_ << ".";
     }
   } else if (!msg) {
     // The packet was STUN, but failed a check and was handled internally.
   } else {
     // The packet is STUN and passed the Port checks.
     // Perform our own checks to ensure this packet is valid.
     // If this is a STUN request, then update the receiving bit and respond.
     // If this is a STUN response, then update the writable bit.
     // Log at LS_INFO if we receive a ping on an unwritable connection.
     rtc::LoggingSeverity sev = (!writable() ? rtc::LS_INFO : rtc::LS_VERBOSE);
@@ skipping 56 matching lines @@
     return;
   }
 
   stats_.recv_ping_requests++;
 
   // This is a validated stun request from remote peer.
   port_->SendBindingResponse(msg, remote_addr);
 
   // If it timed out on writing check, start up again
   if (!pruned_ && write_state_ == STATE_WRITE_TIMEOUT) {
-    set_write_state(STATE_WRITE_INIT);
+    set_write_state(InitialWriteState());
   }
 
   if (port_->GetIceRole() == ICEROLE_CONTROLLED) {
     const StunByteStringAttribute* use_candidate_attr =
         msg->GetByteString(STUN_ATTR_USE_CANDIDATE);
     if (use_candidate_attr) {
       set_nominated(true);
       SignalNominated(this);
     }
   }
   // Set the remote cost if the network_info attribute is available.
   // Note: If packets are re-ordered, we may get incorrect network cost
   // temporarily, but it should get the correct value shortly after that.
   const StunUInt32Attribute* network_attr =
       msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
   if (network_attr) {
     uint32_t network_info = network_attr->value();
     uint16_t network_cost = static_cast<uint16_t>(network_info);
     if (network_cost != remote_candidate_.network_cost()) {
       remote_candidate_.set_network_cost(network_cost);
       // Network cost change will affect the connection ranking, so signal
       // state change to force a re-sort in P2PTransportChannel.
       SignalStateChange(this);
     }
   }
 }
 
 void Connection::OnReadyToSend() {
-  if (write_state_ == STATE_WRITABLE) {
+  if (presumed_writable()) {
     SignalReadyToSend(this);
   }
 }
 
 void Connection::Prune() {
   if (!pruned_ || active()) {
     LOG_J(LS_INFO, this) << "Connection pruned";
     pruned_ = true;
     requests_.Clear();
     set_write_state(STATE_WRITE_TIMEOUT);
@@ skipping 44 matching lines @@
 
   // Check the writable state.  (The order of these checks is important.)
   //
   // Before becoming unwritable, we allow for a fixed number of pings to fail
   // (i.e., receive no response).  We also have to give the response time to
   // get back, so we include a conservative estimate of this.
   //
   // Before timing out writability, we give a fixed amount of time.  This is to
   // allow for changes in network conditions.
 
-  if ((write_state_ == STATE_WRITABLE) &&
+  if (presumed_writable() &&
       TooManyFailures(pings_since_last_response_,
-                      CONNECTION_WRITE_CONNECT_FAILURES,
-                      rtt,
-                      now) &&
+                      CONNECTION_WRITE_CONNECT_FAILURES, rtt, now) &&
       TooLongWithoutResponse(pings_since_last_response_,
-                             CONNECTION_WRITE_CONNECT_TIMEOUT,
-                             now)) {
+                             CONNECTION_WRITE_CONNECT_TIMEOUT, now)) {
     uint32_t max_pings = CONNECTION_WRITE_CONNECT_FAILURES;
     LOG_J(LS_INFO, this) << "Unwritable after " << max_pings
                          << " ping failures and "
                          << now - pings_since_last_response_[0].sent_time
                          << " ms without a response,"
                          << " ms since last received ping="
                          << now - last_ping_received_
                          << " ms since last received data="
                          << now - last_data_received_
                          << " rtt=" << rtt;
@@ skipping 87 matching lines @@
 
 std::string Connection::ToString() const {
   const char CONNECT_STATE_ABBREV[2] = {
     '-',  // not connected (false)
     'C',  // connected (true)
   };
   const char RECEIVE_STATE_ABBREV[2] = {
     '-',  // not receiving (false)
     'R',  // receiving (true)
   };
-  const char WRITE_STATE_ABBREV[4] = {
-    'W',  // STATE_WRITABLE
-    'w',  // STATE_WRITE_UNRELIABLE
-    '-',  // STATE_WRITE_INIT
-    'x',  // STATE_WRITE_TIMEOUT
+  const char WRITE_STATE_ABBREV[5] = {
+      'W',  // STATE_WRITABLE
+      'P',  // STATE_PRESUMED_WRITABLE
+      'w',  // STATE_WRITE_UNRELIABLE
+      '-',  // STATE_WRITE_INIT
+      'x',  // STATE_WRITE_TIMEOUT
   };
   const std::string ICESTATE[4] = {
     "W",  // STATE_WAITING
     "I",  // STATE_INPROGRESS
     "S",  // STATE_SUCCEEDED
     "F"   // STATE_FAILED
   };
   const Candidate& local = local_candidate();
   const Candidate& remote = remote_candidate();
   std::stringstream ss;
@@ skipping 96 matching lines @@
   bool use_candidate = use_candidate_attr();
   LOG_JV(sev, this) << "Sent STUN ping"
                     << ", id=" << rtc::hex_encode(request->id())
                     << ", use_candidate=" << use_candidate;
   stats_.sent_ping_requests_total++;
   if (stats_.recv_ping_responses == 0) {
     stats_.sent_ping_requests_before_first_response++;
   }
 }
 
+Connection::WriteState Connection::InitialWriteState() const {
+  if (presume_writable_when_fully_relayed_ &&
+      local_candidate().type() == RELAY_PORT_TYPE &&
+      (remote_candidate().type() == RELAY_PORT_TYPE ||
+       remote_candidate().type() == PRFLX_PORT_TYPE)) {
+    return STATE_PRESUMED_WRITABLE;
+  }
+  return STATE_WRITE_INIT;
+}
+
 void Connection::HandleRoleConflictFromPeer() {
   port_->SignalRoleConflict(port_);
 }
 
 void Connection::MaybeSetRemoteIceCredentialsAndGeneration(
     const std::string& ice_ufrag,
     const std::string& ice_pwd,
     int generation) {
   if (remote_candidate_.username() == ice_ufrag &&
       remote_candidate_.password().empty()) {
@@ skipping 12 matching lines @@
 void Connection::MaybeUpdatePeerReflexiveCandidate(
     const Candidate& new_candidate) {
   if (remote_candidate_.type() == PRFLX_PORT_TYPE &&
       new_candidate.type() != PRFLX_PORT_TYPE &&
       remote_candidate_.protocol() == new_candidate.protocol() &&
       remote_candidate_.address() == new_candidate.address() &&
       remote_candidate_.username() == new_candidate.username() &&
       remote_candidate_.password() == new_candidate.password() &&
       remote_candidate_.generation() == new_candidate.generation()) {
     remote_candidate_ = new_candidate;
+    // If it turns out that the peer reflexive candidate was a TURN candidate,
+    // we may need to change the state to STATE_PRESUMED_WRITABLE.
+    if (write_state() == STATE_WRITE_INIT) {
+      set_write_state(InitialWriteState());
+    }
   }
 }
 
 void Connection::OnMessage(rtc::Message *pmsg) {
   ASSERT(pmsg->message_id == MSG_DELETE);
   LOG(LS_INFO) << "Connection deleted with number of pings sent: "
                << num_pings_sent_;
   SignalDestroyed(this);
   delete this;
 }
@@ skipping 73 matching lines @@
   // Change the local candidate of this Connection to the new prflx candidate.
   local_candidate_index_ = port_->AddPrflxCandidate(new_local_candidate);
 
   // SignalStateChange to force a re-sort in P2PTransportChannel as this
   // Connection's local candidate has changed.
   SignalStateChange(this);
 }
 
 ProxyConnection::ProxyConnection(Port* port,
                                  size_t index,
-                                 const Candidate& remote_candidate)
-    : Connection(port, index, remote_candidate) {}
+                                 const Candidate& remote_candidate,
+                                 const IceConfig& config)
+    : Connection(port, index, remote_candidate, config) {}
 
 int ProxyConnection::Send(const void* data, size_t size,
                           const rtc::PacketOptions& options) {
   if (write_state_ == STATE_WRITE_INIT || write_state_ == STATE_WRITE_TIMEOUT) {
     error_ = EWOULDBLOCK;
     return SOCKET_ERROR;
   }
   stats_.sent_total_packets++;
   int sent = port_->SendTo(data, size, remote_candidate_.address(),
                            options, true);
   if (sent <= 0) {
     ASSERT(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket