Add logs and small change in BasicPortAllocator

webrtc/p2p/client/basicportallocator.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 531 matching lines @@
   }
   return networks;
 }
 
 // For each network, see if we have a sequence that covers it already.  If not,
 // create a new sequence to create the appropriate ports.
 void BasicPortAllocatorSession::DoAllocate() {
   bool done_signal_needed = false;
   std::vector<rtc::Network*> networks = GetNetworks();
 
+  if (IsStopped()) {

[Taylor Brandstetter, 2016/08/23 21:50:09]

Is this condition only hit when regathering due to a network change?

[honghaiz3, 2016/08/23 22:06:25]

yes. 

+    return;
+  }
   if (networks.empty()) {
     LOG(LS_WARNING) << "Machine has no networks; no ports will be allocated";
     done_signal_needed = true;
   } else {
+    LOG(LS_INFO) << "Allocate ports on "<< networks.size() << " networks";
     PortConfiguration* config = configs_.empty() ? nullptr : configs_.back();
     for (uint32_t i = 0; i < networks.size(); ++i) {
       uint32_t sequence_flags = flags();
       if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
         // If all the ports are disabled we should just fire the allocation
         // done event and return.
         done_signal_needed = true;
         break;
       }
 
@@ skipping 12 matching lines @@
       // ones that we have already made.
       DisableEquivalentPhases(networks[i], config, &sequence_flags);
 
       if ((sequence_flags & DISABLE_ALL_PHASES) == DISABLE_ALL_PHASES) {
         // New AllocationSequence would have nothing to do, so don't make it.
         continue;
       }
 
       AllocationSequence* sequence =
           new AllocationSequence(this, networks[i], config, sequence_flags);
-      if (!sequence->Init()) {
-        delete sequence;
-        continue;
-      }
-      done_signal_needed = true;
       sequence->SignalPortAllocationComplete.connect(
           this, &BasicPortAllocatorSession::OnPortAllocationComplete);
-      if (!IsStopped()) {
-        sequence->Start();
-      }
+      sequence->Init();
+      sequence->Start();
       sequences_.push_back(sequence);
+      done_signal_needed = true;
     }
   }
   if (done_signal_needed) {
     network_thread_->Post(RTC_FROM_HERE, this, MSG_SEQUENCEOBJECTS_CREATED);
   }
 }
 
 void BasicPortAllocatorSession::OnNetworksChanged() {
   std::vector<rtc::Network*> networks = GetNetworks();
   std::vector<rtc::Network*> failed_networks;
   for (AllocationSequence* sequence : sequences_) {
     // Mark the sequence as "network failed" if its network is not in
     // |networks|.
     if (!sequence->network_failed() &&
         std::find(networks.begin(), networks.end(), sequence->network()) ==
             networks.end()) {
       sequence->OnNetworkFailed();
       failed_networks.push_back(sequence->network());
     }
   }
   RemovePortsAndCandidates(failed_networks);
 
-  network_manager_started_ = true;
+  if (!network_manager_started_) {
+    LOG(LS_INFO) << "Network manager is started";
+    network_manager_started_ = true;
+  }
   if (allocation_started_)
     DoAllocate();
 }
 
 void BasicPortAllocatorSession::DisableEquivalentPhases(
     rtc::Network* network,
     PortConfiguration* config,
     uint32_t* flags) {
   for (uint32_t i = 0; i < sequences_.size() &&
                            (*flags & DISABLE_ALL_PHASES) != DISABLE_ALL_PHASES;
@@ skipping 347 matching lines @@
       network_(network),
       ip_(network->GetBestIP()),
       config_(config),
       state_(kInit),
       flags_(flags),
       udp_socket_(),
       udp_port_(NULL),
       phase_(0) {
 }
 
-bool AllocationSequence::Init() {
+void AllocationSequence::Init() {
   if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
     udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
         rtc::SocketAddress(ip_, 0), session_->allocator()->min_port(),
         session_->allocator()->max_port()));
     if (udp_socket_) {
       udp_socket_->SignalReadPacket.connect(
           this, &AllocationSequence::OnReadPacket);
     }
     // Continuing if |udp_socket_| is NULL, as local TCP and RelayPort using TCP
     // are next available options to setup a communication channel.
   }
-  return true;
 }
 
 void AllocationSequence::Clear() {
   udp_port_ = NULL;
   turn_ports_.clear();
 }
 
 void AllocationSequence::OnNetworkFailed() {
   RTC_DCHECK(!network_failed_);
   network_failed_ = true;
@@ skipping 448 matching lines @@
   ServerAddresses servers;
   for (size_t i = 0; i < relays.size(); ++i) {
     if (relays[i].type == turn_type && SupportsProtocol(relays[i], type)) {
       servers.insert(relays[i].ports.front().address);
     }
   }
   return servers;
 }
 
 }  // namespace cricket