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 149 matching lines @@
   return b_conn->rtt() <= a_conn->rtt() + kMinImprovement;
 }
 
 }  // unnamed namespace
 
 namespace cricket {
 
 P2PTransportChannel::P2PTransportChannel(const std::string& content_name,
                                          int component,
                                          P2PTransport* transport,
-                                         PortAllocator *allocator) :
+                                         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),
     protocol_type_(ICEPROTO_HYBRID),
     remote_ice_mode_(ICEMODE_FULL),
     ice_role_(ICEROLE_UNKNOWN),
     tiebreaker_(0),
     remote_candidate_generation_(0),
+    candidate_gathering_state_(Transport::kGatheringNew),
     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];
 }
@@ skipping 218 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]);
   }
 }
 
 void P2PTransportChannel::OnCandidatesAllocationDone(
     PortAllocatorSession* session) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
+  candidate_gathering_state_ = Transport::kGatheringDone;
   SignalCandidatesAllocationDone(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 166 matching lines @@
     // 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::OnUseCandidate(Connection* conn) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(ice_role_ == ICEROLE_CONTROLLED);
   ASSERT(protocol_type_ == ICEPROTO_RFC5245);
 
   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();
@@ skipping 256 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)
+// Begin allocate
 void P2PTransportChannel::Allocate() {

[pthatcher1, 2015/08/10 20:40:17]

We could probably call this Gather() now

[Taylor Brandstetter, 2015/08/11 01:20:07]

Done (I'll call it StartGatheringCandidates for clarity/consistency)

-  // Time for a new allocator, lets make sure we have a signalling channel
-  // to communicate candidates through first.
-  waiting_for_signaling_ = true;
-  SignalRequestSignaling(this);
+  // Time for a new allocator
+  if (candidate_gathering_state_ != Transport::kGatheringGathering) {
+    candidate_gathering_state_ = Transport::kGatheringGathering;
+    SignalCandidatesAllocationStarted(this);
+  }
+  AddAllocatorSession(allocator_->CreateSession(
+      SessionId(), content_name(), component(), ice_ufrag_, ice_pwd_));
 }
 
 // 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 429 matching lines @@
       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,
+    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);
 }
 
 void P2PTransportChannel::OnReadyToSend(Connection* connection) {
   if (connection == best_connection_ && writable()) {
     SignalReadyToSend(this);
   }
 }
 
 }  // namespace cricket