Use continual gathering to restore backup connections

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 <algorithm>
 #include <set>
 
 #include "webrtc/base/common.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/candidatepairinterface.h"
 #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/system_wrappers/include/field_trial.h"
 
 namespace {
 
 // messages for queuing up work for ourselves
-enum { MSG_SORT = 1, MSG_CHECK_AND_PING };
+enum { MSG_SORT = 1, MSG_CHECK_AND_PING, MSG_REGATHER_ON_FAILED_NETWORKS };
 
 // The minimum improvement in RTT that justifies a switch.
-static const double kMinImprovement = 10;
+const int kMinImprovement = 10;
 
 bool IsRelayRelay(const cricket::Connection* conn) {
   return conn->local_candidate().type() == cricket::RELAY_PORT_TYPE &&
          conn->remote_candidate().type() == cricket::RELAY_PORT_TYPE;
 }
 
 bool IsUdp(cricket::Connection* conn) {
   return conn->local_candidate().relay_protocol() == cricket::UDP_PROTOCOL_NAME;
 }
 
@@ skipping 25 matching lines @@
 const int WEAK_PING_INTERVAL = 1000 * PING_PACKET_SIZE / 10000;
 
 // Writable connections are pinged at a faster rate while stabilizing.
 const int STABILIZING_WRITABLE_CONNECTION_PING_INTERVAL = 900;  // ms
 
 // Writable connections are pinged at a slower rate once stabilized.
 const int STABLE_WRITABLE_CONNECTION_PING_INTERVAL = 2500;  // ms
 
 static const int MIN_CHECK_RECEIVING_INTERVAL = 50;  // ms
 
+// We periodically check if any existing networks do not have any connection
+// and regather on those networks.
+static const int DEFAULT_REGATHER_ON_FAILED_NETWORKS_INTERVAL = 5 * 60 * 1000;
 static constexpr int a_is_better = 1;
 static constexpr int b_is_better = -1;
 
 P2PTransportChannel::P2PTransportChannel(const std::string& transport_name,
                                          int component,
                                          P2PTransport* transport,
                                          PortAllocator* allocator)
     : P2PTransportChannel(transport_name, component, allocator) {}
 
 P2PTransportChannel::P2PTransportChannel(const std::string& transport_name,
                                          int component,
                                          PortAllocator* allocator)
     : TransportChannelImpl(transport_name, component),
       allocator_(allocator),
       worker_thread_(rtc::Thread::Current()),
       incoming_only_(false),
       error_(0),
       sort_dirty_(false),
       remote_ice_mode_(ICEMODE_FULL),
       ice_role_(ICEROLE_UNKNOWN),
       tiebreaker_(0),
       gathering_state_(kIceGatheringNew),
       check_receiving_interval_(MIN_CHECK_RECEIVING_INTERVAL * 5),
       config_(MIN_CHECK_RECEIVING_INTERVAL * 50 /* receiving_timeout */,
               0 /* backup_connection_ping_interval */,
-              false /* gather_continually */,
+              GATHER_ONCE /* continual_gathering_policy */,
               false /* prioritize_most_likely_candidate_pairs */,
               STABLE_WRITABLE_CONNECTION_PING_INTERVAL,
-              true /* presume_writable_when_fully_relayed */) {
+              true /* presume_writable_when_fully_relayed */,
+              DEFAULT_REGATHER_ON_FAILED_NETWORKS_INTERVAL) {
   uint32_t weak_ping_interval = ::strtoul(
       webrtc::field_trial::FindFullName("WebRTC-StunInterPacketDelay").c_str(),
       nullptr, 10);
   if (weak_ping_interval) {
     weak_ping_interval_ = static_cast<int>(weak_ping_interval);
   }
 }
 
 P2PTransportChannel::~P2PTransportChannel() {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 }
 
 // Add the allocator session to our list so that we know which sessions
 // are still active.
 void P2PTransportChannel::AddAllocatorSession(
     std::unique_ptr<PortAllocatorSession> session) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
   session->set_generation(static_cast<uint32_t>(allocator_sessions_.size()));
   session->SignalPortReady.connect(this, &P2PTransportChannel::OnPortReady);
+  session->SignalPortsRemoved.connect(this,
+                                      &P2PTransportChannel::OnPortsRemoved);
   session->SignalCandidatesReady.connect(
       this, &P2PTransportChannel::OnCandidatesReady);
+  session->SignalCandidatesRemoved.connect(
+      this, &P2PTransportChannel::OnCandidatesRemoved);
   session->SignalCandidatesAllocationDone.connect(
       this, &P2PTransportChannel::OnCandidatesAllocationDone);
 
   // We now only want to apply new candidates that we receive to the ports
   // created by this new session because these are replacing those of the
   // previous sessions.
   removed_ports_.insert(removed_ports_.end(), ports_.begin(), ports_.end());
   ports_.clear();
 
   allocator_sessions_.push_back(std::move(session));
@@ skipping 148 matching lines @@
   }
   // Updating the remote ICE candidate generation could change the sort order.
   RequestSort();
 }
 
 void P2PTransportChannel::SetRemoteIceMode(IceMode mode) {
   remote_ice_mode_ = mode;
 }
 
 void P2PTransportChannel::SetIceConfig(const IceConfig& config) {
-  config_.gather_continually = config.gather_continually;
-  LOG(LS_INFO) << "Set gather_continually to " << config_.gather_continually;
+  if (config_.continual_gathering_policy != config.continual_gathering_policy) {
+    LOG(LS_INFO) << "Set continual_gathering_policy to "
+                 << config_.continual_gathering_policy;
+    config_.continual_gathering_policy = config.continual_gathering_policy;
+  }
 
   if (config.backup_connection_ping_interval >= 0 &&
       config_.backup_connection_ping_interval !=
           config.backup_connection_ping_interval) {
     config_.backup_connection_ping_interval =
         config.backup_connection_ping_interval;
     LOG(LS_INFO) << "Set backup connection ping interval to "
                  << config_.backup_connection_ping_interval << " milliseconds.";
   }
 
@@ skipping 29 matching lines @@
     if (!connections_.empty()) {
       LOG(LS_ERROR) << "Trying to change 'presume writable' "
                     << "while connections already exist!";
     } else {
       config_.presume_writable_when_fully_relayed =
           config.presume_writable_when_fully_relayed;
       LOG(LS_INFO) << "Set presume writable when fully relayed to "
                    << config_.presume_writable_when_fully_relayed;
     }
   }
+
+  if (config.regather_on_failed_networks_interval >= 0 &&
+      config.regather_on_failed_networks_interval !=

[pthatcher1, 2016/06/29 18:53:27]

Can we use an rtc::optional in config rather than a -1?

[honghaiz3, 2016/06/29 20:19:22]

Done.

+          config_.regather_on_failed_networks_interval) {
+    config_.regather_on_failed_networks_interval =
+        config.regather_on_failed_networks_interval;
+    LOG(LS_INFO) << "Set regather_on_failed_networks_interval to "
+                 << config_.regather_on_failed_networks_interval;
+  }
 }
 
 const IceConfig& P2PTransportChannel::config() const {
   return config_;
 }
 
 // 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;
   }
 
   // Start checking and pinging as the ports come in.
   thread()->Post(RTC_FROM_HERE, this, MSG_CHECK_AND_PING);
+  thread()->PostDelayed(RTC_FROM_HERE,
+                        config_.regather_on_failed_networks_interval, this,
+                        MSG_REGATHER_ON_FAILED_NETWORKS);

[pthatcher1, 2016/06/29 18:53:27]

Taylor just refactored this :)

[honghaiz3, 2016/06/29 20:19:22]

Will merge when his CL is in. 

 }
 
 void P2PTransportChannel::MaybeStartGathering() {
   // Start gathering if we never started before, or if an ICE restart occurred.
   if (allocator_sessions_.empty() ||
       IceCredentialsChanged(allocator_sessions_.back()->ice_ufrag(),
                             allocator_sessions_.back()->ice_pwd(), ice_ufrag_,
                             ice_pwd_)) {
     if (gathering_state_ != kIceGatheringGathering) {
       gathering_state_ = kIceGatheringGathering;
@@ skipping 44 matching lines @@
   // Remember the ports and candidates, and signal that candidates are ready.
   // The session will handle this, and send an initiate/accept/modify message
   // if one is pending.
 
   port->SetIceRole(ice_role_);
   port->SetIceTiebreaker(tiebreaker_);
   ports_.push_back(port);
   port->SignalUnknownAddress.connect(
       this, &P2PTransportChannel::OnUnknownAddress);
   port->SignalDestroyed.connect(this, &P2PTransportChannel::OnPortDestroyed);
-  port->SignalNetworkInactive.connect(
-      this, &P2PTransportChannel::OnPortNetworkInactive);
+
   port->SignalRoleConflict.connect(
       this, &P2PTransportChannel::OnRoleConflict);
   port->SignalSentPacket.connect(this, &P2PTransportChannel::OnSentPacket);
 
   // Attempt to create a connection from this new port to all of the remote
   // candidates that we were given so far.
 
   std::vector<RemoteCandidate>::iterator iter;
   for (iter = remote_candidates_.begin(); iter != remote_candidates_.end();
        ++iter) {
@@ skipping 853 matching lines @@
 
 void P2PTransportChannel::MaybeStopPortAllocatorSessions() {
   if (!IsGettingPorts()) {
     return;
   }
 
   for (const auto& session : allocator_sessions_) {
     if (!session->IsGettingPorts()) {
       continue;
     }
-    // If gathering continually, keep the last session running so that it
-    // will gather candidates if the networks change.
-    if (config_.gather_continually && session == allocator_sessions_.back()) {
+    // If gathering continually, keep the last session running so that
+    // it can gather candidates if the networks change.
+    if (config_.gather_continually() && session == allocator_sessions_.back()) {
       session->ClearGettingPorts();
-      break;
+    } else {
+      session->StopGettingPorts();
     }
-    session->StopGettingPorts();
   }
 }
 
 // If all connections timed out, delete them all.
 void P2PTransportChannel::HandleAllTimedOut() {
   for (Connection* connection : connections_) {
     connection->Destroy();
   }
 }
 
@@ skipping 34 matching lines @@
 
 // Handle any queued up requests
 void P2PTransportChannel::OnMessage(rtc::Message *pmsg) {
   switch (pmsg->message_id) {
     case MSG_SORT:
       OnSort();
       break;
     case MSG_CHECK_AND_PING:
       OnCheckAndPing();
       break;
+    case MSG_REGATHER_ON_FAILED_NETWORKS:
+      OnRegatherOnFailedNetworks();
+      break;
     default:
       ASSERT(false);
       break;
   }
 }
 
 // Handle queued up sort request
 void P2PTransportChannel::OnSort() {
   // Resort the connections based on the new statistics.
   SortConnections();
@@ skipping 210 matching lines @@
   // selected connection.
   if (selected_connection_ == connection) {
     LOG(LS_INFO) << "selected connection destroyed. Will choose a new one.";
     SwitchSelectedConnection(nullptr);
     RequestSort();
   }
 
   UpdateState();
 }
 
-// When a port is destroyed remove it from our list of ports to use for
+// When a port is destroyed, remove it from our list of ports to use for
 // connection attempts.
 void P2PTransportChannel::OnPortDestroyed(PortInterface* port) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
 
-  // Remove this port from the lists (if we didn't drop it already).
   ports_.erase(std::remove(ports_.begin(), ports_.end(), port), ports_.end());
   removed_ports_.erase(
       std::remove(removed_ports_.begin(), removed_ports_.end(), port),
       removed_ports_.end());
-
-  LOG(INFO) << "Removed port from p2p socket: "
-            << static_cast<int>(ports_.size()) << " remaining";
+  LOG(INFO) << "Removed port because it is destroyed: " << ports_.size()
+            << " remaining";
 }
 
-void P2PTransportChannel::OnPortNetworkInactive(PortInterface* port) {
-  // If it does not gather continually, the port will be removed from the list
-  // when ICE restarts.
-  if (!config_.gather_continually) {
+void P2PTransportChannel::OnPortsRemoved(
+    PortAllocatorSession* session,
+    const std::vector<PortInterface*>& ports) {
+  ASSERT(worker_thread_ == rtc::Thread::Current());
+  LOG(LS_INFO) << "Remove " << ports.size() << " ports";
+  for (PortInterface* port : ports) {
+    if (RemovePort(port)) {
+      LOG(INFO) << "Removed port: " << port->ToString() << " " << ports_.size()
+                << " remaining";
+    }
+  }
+}
+
+bool P2PTransportChannel::RemovePort(PortInterface* port) {
+  // Move this port from |ports_| to |removed_ports_| (if we haven't done it
+  // already).
+  auto new_end = std::remove(ports_.begin(), ports_.end(), port);
+  if (new_end != ports_.end()) {
+    ports_.erase(new_end, ports_.end());
+    removed_ports_.push_back(port);
+    return true;
+  }
+  return false;
+}
+
+void P2PTransportChannel::OnCandidatesRemoved(
+    PortAllocatorSession* session,
+    const std::vector<Candidate>& candidates) {
+  ASSERT(worker_thread_ == rtc::Thread::Current());
+  // Do not signal candidate removals if continual gathering is not enabled, or
+  // if this is not the last session because an ICE restart would have signaled
+  // the remote side to remove all candidates in previous sessions.
+  if (!config_.gather_continually() || session != allocator_session()) {
     return;
   }
-  auto it = std::find(ports_.begin(), ports_.end(), port);
-  // Don't need to do anything if the port has been deleted from the port list.
-  if (it == ports_.end()) {
+
+  std::vector<Candidate> candidates_to_remove;
+  for (Candidate candidate : candidates) {
+    candidate.set_transport_name(transport_name());
+    candidates_to_remove.push_back(candidate);
+  }
+  SignalCandidatesRemoved(this, candidates_to_remove);
+}
+
+void P2PTransportChannel::OnRegatherOnFailedNetworks() {
+  if (!config_.gather_continually() || allocator_sessions_.empty()) {
     return;
   }
-  removed_ports_.push_back(*it);
-  ports_.erase(it);
-  LOG(INFO) << "Removed port due to inactive networks: " << ports_.size()
-            << " remaining";
-  std::vector<Candidate> candidates = port->Candidates();
-  for (Candidate& candidate : candidates) {
-    candidate.set_transport_name(transport_name());
-  }
-  SignalCandidatesRemoved(this, candidates);
+  allocator_session()->RegatherOnFailedNetworks();
+
+  thread()->PostDelayed(RTC_FROM_HERE,
+                        config_.regather_on_failed_networks_interval, this,
+                        MSG_REGATHER_ON_FAILED_NETWORKS);
 }
 
 // We data is available, let listeners know
 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.
@@ skipping 136 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket