TransportController refactoring.

webrtc/p2p/base/p2ptransportchannel.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.
  */
 
 #include "webrtc/p2p/base/p2ptransportchannel.h"
 
 #include <set>
+#include <algorithm>
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/relayport.h"  // For RELAY_PORT_TYPE.
 #include "webrtc/p2p/base/stunport.h"  // For STUN_PORT_TYPE.
 #include "webrtc/base/common.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 
 namespace {
 
@@ skipping 138 matching lines @@
   if (prefs_cmp > 0)
     return false;
 
   return b_conn->rtt() <= a_conn->rtt() + kMinImprovement;
 }
 
 }  // unnamed namespace
 
 namespace cricket {
 
-P2PTransportChannel::P2PTransportChannel(const std::string& content_name,
+P2PTransportChannel::P2PTransportChannel(const std::string& transport_name,
                                          int component,
                                          P2PTransport* transport,
-                                         PortAllocator *allocator) :
-    TransportChannelImpl(content_name, component),
-    transport_(transport),
-    allocator_(allocator),
-    worker_thread_(rtc::Thread::Current()),
-    incoming_only_(false),
-    waiting_for_signaling_(false),
-    error_(0),
-    best_connection_(NULL),
-    pending_best_connection_(NULL),
-    sort_dirty_(false),
-    was_writable_(false),
-    remote_ice_mode_(ICEMODE_FULL),
-    ice_role_(ICEROLE_UNKNOWN),
-    tiebreaker_(0),
-    remote_candidate_generation_(0),
-    check_receiving_delay_(MIN_CHECK_RECEIVING_DELAY * 5),
-    receiving_timeout_(MIN_CHECK_RECEIVING_DELAY * 50) {
-}
+                                         PortAllocator* allocator)
+    : TransportChannelImpl(transport_name, component),
+      transport_(transport),
+      allocator_(allocator),
+      worker_thread_(rtc::Thread::Current()),
+      incoming_only_(false),
+      error_(0),
+      best_connection_(NULL),
+      pending_best_connection_(NULL),
+      sort_dirty_(false),
+      was_writable_(false),
+      remote_ice_mode_(ICEMODE_FULL),
+      ice_role_(ICEROLE_UNKNOWN),
+      tiebreaker_(0),
+      remote_candidate_generation_(0),
+      gathering_state_(kIceGatheringNew),
+      check_receiving_delay_(MIN_CHECK_RECEIVING_DELAY * 5),
+      receiving_timeout_(MIN_CHECK_RECEIVING_DELAY * 50) {}
 
 P2PTransportChannel::~P2PTransportChannel() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   for (uint32 i = 0; i < allocator_sessions_.size(); ++i)
     delete allocator_sessions_[i];
 }
 
 // Add the allocator session to our list so that we know which sessions
 // are still active.
@@ skipping 19 matching lines @@
   connection->set_remote_ice_mode(remote_ice_mode_);
   connection->SignalReadPacket.connect(
       this, &P2PTransportChannel::OnReadPacket);
   connection->SignalReadyToSend.connect(
       this, &P2PTransportChannel::OnReadyToSend);
   connection->SignalStateChange.connect(
       this, &P2PTransportChannel::OnConnectionStateChange);
   connection->SignalDestroyed.connect(
       this, &P2PTransportChannel::OnConnectionDestroyed);
   connection->SignalNominated.connect(this, &P2PTransportChannel::OnNominated);
+  had_connection_ = true;
 }
 
 void P2PTransportChannel::SetIceRole(IceRole ice_role) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (ice_role_ != ice_role) {
     ice_role_ = ice_role;
     for (std::vector<PortInterface *>::iterator it = ports_.begin();
          it != ports_.end(); ++it) {
       (*it)->SetIceRole(ice_role);
     }
@@ skipping 14 matching lines @@
 // Currently a channel is considered ICE completed once there is no
 // more than one connection per Network. This works for a single NIC
 // with both IPv4 and IPv6 enabled. However, this condition won't
 // happen when there are multiple NICs and all of them have
 // connectivity.
 // TODO(guoweis): Change Completion to be driven by a channel level
 // timer.
 TransportChannelState P2PTransportChannel::GetState() const {
   std::set<rtc::Network*> networks;
 
-  if (connections_.size() == 0) {
-    return TransportChannelState::STATE_FAILED;
+  if (connections_.empty()) {
+    return had_connection_ ? TransportChannelState::STATE_FAILED
+                           : TransportChannelState::STATE_INIT;
   }
 
   for (uint32 i = 0; i < connections_.size(); ++i) {
     rtc::Network* network = connections_[i]->port()->Network();
     if (networks.find(network) == networks.end()) {
       networks.insert(network);
     } else {
       LOG_J(LS_VERBOSE, this) << "Ice not completed yet for this channel as "
                               << network->ToString()
                               << " has more than 1 connection.";
@@ skipping 13 matching lines @@
     // Restart candidate allocation if there is any change in either
     // ice ufrag or password.
     ice_restart =
         IceCredentialsChanged(ice_ufrag_, ice_pwd_, ice_ufrag, ice_pwd);
   }
 
   ice_ufrag_ = ice_ufrag;
   ice_pwd_ = ice_pwd;
 
   if (ice_restart) {
-    // Restart candidate gathering.
-    Allocate();
+    // Need to restart candidate gathering.
+    // Someone should call MaybeStartGathering in the near future to do this.
+    need_to_gather_candidates_ = true;

[pthatcher1, 2015/09/19 00:08:05]

What if we use "gathering_state_ = new;" instead?

   }
 }
 
 void P2PTransportChannel::SetRemoteIceCredentials(const std::string& ice_ufrag,
                                                   const std::string& ice_pwd) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   bool ice_restart = false;
   if (!remote_ice_ufrag_.empty() && !remote_ice_pwd_.empty()) {
     ice_restart = (remote_ice_ufrag_ != ice_ufrag) ||
                   (remote_ice_pwd_!= ice_pwd);
@@ skipping 33 matching lines @@
 // Go into the state of processing candidates, and running in general
 void P2PTransportChannel::Connect() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (ice_ufrag_.empty() || ice_pwd_.empty()) {
     ASSERT(false);
     LOG(LS_ERROR) << "P2PTransportChannel::Connect: The ice_ufrag_ and the "
                   << "ice_pwd_ are not set.";
     return;
   }
 
-  // Kick off an allocator session
-  Allocate();
-
   // Start pinging as the ports come in.
   thread()->Post(this, MSG_PING);
 
   thread()->PostDelayed(
       check_receiving_delay_, this, MSG_CHECK_RECEIVING);
 }
 
+void P2PTransportChannel::MaybeStartGathering() {
+  if (need_to_gather_candidates_) {
+    need_to_gather_candidates_ = false;
+    if (gathering_state_ != kIceGatheringGathering) {
+      gathering_state_ = kIceGatheringGathering;
+      SignalGatheringState(this);
+    }
+    // Time for a new allocator
+    AddAllocatorSession(allocator_->CreateSession(
+        SessionId(), transport_name(), component(), ice_ufrag_, ice_pwd_));
+  }
+}
+
 // A new port is available, attempt to make connections for it
 void P2PTransportChannel::OnPortReady(PortAllocatorSession *session,
                                       PortInterface* port) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Set in-effect options on the new port
   for (OptionMap::const_iterator it = options_.begin();
        it != options_.end();
        ++it) {
     int val = port->SetOption(it->first, it->second);
@@ skipping 24 matching lines @@
   for (iter = remote_candidates_.begin(); iter != remote_candidates_.end();
        ++iter) {
     CreateConnection(port, *iter, iter->origin_port(), false);
   }
 
   SortConnections();
 }
 
 // A new candidate is available, let listeners know
 void P2PTransportChannel::OnCandidatesReady(
-    PortAllocatorSession *session, const std::vector<Candidate>& candidates) {
+    PortAllocatorSession* session,
+    const std::vector<Candidate>& candidates) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   for (size_t i = 0; i < candidates.size(); ++i) {
-    SignalCandidateReady(this, candidates[i]);
+    SignalCandidateGathered(this, candidates[i]);
   }
 }
 
 void P2PTransportChannel::OnCandidatesAllocationDone(
     PortAllocatorSession* session) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
-  SignalCandidatesAllocationDone(this);
+  gathering_state_ = kIceGatheringComplete;
+  LOG(LS_INFO) << "P2PTransportChannel: " << transport_name() << ", component "
+               << component() << " gathering complete";
+  SignalGatheringState(this);
 }
 
 // Handle stun packets
 void P2PTransportChannel::OnUnknownAddress(
     PortInterface* port,
     const rtc::SocketAddress& address, ProtocolType proto,
     IceMessage* stun_msg, const std::string &remote_username,
     bool port_muxed) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
@@ skipping 50 matching lines @@
     int remote_candidate_priority;
 
     // The priority of the candidate is set to the PRIORITY attribute
     // from the request.
     const StunUInt32Attribute* priority_attr =
         stun_msg->GetUInt32(STUN_ATTR_PRIORITY);
     if (!priority_attr) {
       LOG(LS_WARNING) << "P2PTransportChannel::OnUnknownAddress - "
                       << "No STUN_ATTR_PRIORITY found in the "
                       << "stun request message";
-      port->SendBindingErrorResponse(stun_msg, address,
-                                     STUN_ERROR_BAD_REQUEST,
+      port->SendBindingErrorResponse(stun_msg, address, STUN_ERROR_BAD_REQUEST,
                                      STUN_ERROR_REASON_BAD_REQUEST);
       return;
     }
     remote_candidate_priority = priority_attr->value();
 
     // RFC 5245
     // If the source transport address of the request does not match any
     // existing remote candidates, it represents a new peer reflexive remote
     // candidate.
     remote_candidate =
@@ skipping 29 matching lines @@
                                      STUN_ERROR_SERVER_ERROR,
                                      STUN_ERROR_REASON_SERVER_ERROR);
       return;
     }
   }
 
   Connection* connection = port->CreateConnection(
       remote_candidate, cricket::PortInterface::ORIGIN_THIS_PORT);
   if (!connection) {
     ASSERT(false);
-    port->SendBindingErrorResponse(stun_msg, address,
-                                   STUN_ERROR_SERVER_ERROR,
+    port->SendBindingErrorResponse(stun_msg, address, STUN_ERROR_SERVER_ERROR,
                                    STUN_ERROR_REASON_SERVER_ERROR);
     return;
   }
 
   LOG(LS_INFO) << "Adding connection from "
                << (remote_candidate_is_new ? "peer reflexive" : "resurrected")
                << " candidate: " << remote_candidate.ToString();
   AddConnection(connection);
   connection->ReceivedPing();
 
   bool received_use_candidate =
       stun_msg->GetByteString(STUN_ATTR_USE_CANDIDATE) != nullptr;
   if (received_use_candidate && ice_role_ == ICEROLE_CONTROLLED) {
     connection->set_nominated(true);
     OnNominated(connection);
   }
 
   // Update the list of connections since we just added another.  We do this
   // after sending the response since it could (in principle) delete the
   // connection in question.
   SortConnections();
 }
 
 void P2PTransportChannel::OnRoleConflict(PortInterface* port) {
   SignalRoleConflict(this);  // STUN ping will be sent when SetRole is called
                              // from Transport.
 }
 
-// When the signalling channel is ready, we can really kick off the allocator
-void P2PTransportChannel::OnSignalingReady() {
-  ASSERT(worker_thread_ == rtc::Thread::Current());
-  if (waiting_for_signaling_) {
-    waiting_for_signaling_ = false;
-    AddAllocatorSession(allocator_->CreateSession(
-        SessionId(), content_name(), component(), ice_ufrag_, ice_pwd_));
-  }
-}
-
 void P2PTransportChannel::OnNominated(Connection* conn) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(ice_role_ == ICEROLE_CONTROLLED);
 
   if (conn->write_state() == Connection::STATE_WRITABLE) {
     if (best_connection_ != conn) {
       pending_best_connection_ = NULL;
       LOG(LS_INFO) << "Switching best connection on controlled side: "
                    << conn->ToString();
       SwitchBestConnectionTo(conn);
       // Now we have selected the best connection, time to prune other existing
       // connections and update the read/write state of the channel.
       RequestSort();
     }
   } else {
     LOG(LS_INFO) << "Not switching the best connection on controlled side yet,"
                  << " because it's not writable: " << conn->ToString();
     pending_best_connection_ = conn;
   }
 }
 
-void P2PTransportChannel::OnCandidate(const Candidate& candidate) {
+void P2PTransportChannel::AddRemoteCandidate(const Candidate& candidate) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   uint32 generation = candidate.generation();
   // Network may not guarantee the order of the candidate delivery. If a
   // remote candidate with an older generation arrives, drop it.
   if (generation != 0 && generation < remote_candidate_generation_) {
     LOG(LS_WARNING) << "Dropping a remote candidate because its generation "
                     << generation
                     << " is lower than the current remote generation "
                     << remote_candidate_generation_;
@@ skipping 228 matching lines @@
   return sent;
 }
 
 bool P2PTransportChannel::GetStats(ConnectionInfos *infos) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   // Gather connection infos.
   infos->clear();
 
   std::vector<Connection *>::const_iterator it;
   for (it = connections_.begin(); it != connections_.end(); ++it) {
-    Connection *connection = *it;
+    Connection* connection = *it;
     ConnectionInfo info;
     info.best_connection = (best_connection_ == connection);
     info.readable =
         (connection->read_state() == Connection::STATE_READABLE);
     info.writable =
         (connection->write_state() == Connection::STATE_WRITABLE);
     info.timeout =
         (connection->write_state() == Connection::STATE_WRITE_TIMEOUT);
     info.new_connection = !connection->reported();
     connection->set_reported(true);
@@ skipping 14 matching lines @@
 }
 
 rtc::DiffServCodePoint P2PTransportChannel::DefaultDscpValue() const {
   OptionMap::const_iterator it = options_.find(rtc::Socket::OPT_DSCP);
   if (it == options_.end()) {
     return rtc::DSCP_NO_CHANGE;
   }
   return static_cast<rtc::DiffServCodePoint> (it->second);
 }
 
-// Begin allocate (or immediately re-allocate, if MSG_ALLOCATE pending)
-void P2PTransportChannel::Allocate() {
-  // Time for a new allocator, lets make sure we have a signalling channel
-  // to communicate candidates through first.
-  waiting_for_signaling_ = true;
-  SignalRequestSignaling(this);
-}
-
 // Monitor connection states.
 void P2PTransportChannel::UpdateConnectionStates() {
   uint32 now = rtc::Time();
 
   // We need to copy the list of connections since some may delete themselves
   // when we call UpdateState.
   for (uint32 i = 0; i < connections_.size(); ++i)
     connections_[i]->UpdateState(now);
 }
 
@@ skipping 339 matching lines @@
 //      a.1) |conn| is the best connection OR
 //      a.2) there is no best connection OR
 //      a.3) the best connection is unwritable OR
 //      a.4) |conn| has higher priority than best_connection.
 //    b) we're doing LITE ICE AND
 //      b.1) |conn| is the best_connection AND
 //      b.2) |conn| is writable.
 void P2PTransportChannel::PingConnection(Connection* conn) {
   bool use_candidate = false;
   if (remote_ice_mode_ == ICEMODE_FULL && ice_role_ == ICEROLE_CONTROLLING) {
-    use_candidate = (conn == best_connection_) ||
-                    (best_connection_ == NULL) ||
+    use_candidate = (conn == best_connection_) || (best_connection_ == NULL) ||
                     (!best_connection_->writable()) ||
                     (conn->priority() > best_connection_->priority());
   } else if (remote_ice_mode_ == ICEMODE_LITE && conn == best_connection_) {
     use_candidate = best_connection_->writable();
   }
   conn->set_use_candidate_attr(use_candidate);
   conn->Ping(rtc::Time());
 }
 
 // When a connection's state changes, we need to figure out who to use as
@@ skipping 61 matching lines @@
   std::vector<PortInterface*>::iterator iter =
       std::find(ports_.begin(), ports_.end(), port);
   if (iter != ports_.end())
     ports_.erase(iter);
 
   LOG(INFO) << "Removed port from p2p socket: "
             << static_cast<int>(ports_.size()) << " remaining";
 }
 
 // We data is available, let listeners know
-void P2PTransportChannel::OnReadPacket(
-    Connection *connection, const char *data, size_t len,
-    const rtc::PacketTime& packet_time) {
+void P2PTransportChannel::OnReadPacket(Connection* connection,
+                                       const char* data,
+                                       size_t len,
+                                       const rtc::PacketTime& packet_time) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   // Do not deliver, if packet doesn't belong to the correct transport channel.
   if (!FindConnection(connection))
     return;
 
   // Let the client know of an incoming packet
   SignalReadPacket(this, data, len, packet_time, 0);
 
   // May need to switch the sending connection based on the receiving media path
   // if this is the controlled side.
   if (ice_role_ == ICEROLE_CONTROLLED && !best_nominated_connection() &&
       connection->writable() && best_connection_ != connection) {
     SwitchBestConnectionTo(connection);
   }
 }
 
 void P2PTransportChannel::OnReadyToSend(Connection* connection) {
   if (connection == best_connection_ && writable()) {
     SignalReadyToSend(this);
   }
 }
 
 }  // namespace cricket