Use continual gathering to restore backup connections

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 198 matching lines @@
   AddressMap::iterator iter = connections_.begin();
   while (iter != connections_.end()) {
     list.push_back(iter->second);
     ++iter;
   }
 
   for (uint32_t i = 0; i < list.size(); i++)
     delete list[i];
 }
 
+Port::CloseAndSignalCandidateRemovals() {
+  if (closed_) {
+    return;
+  }
+
+  closed_ = true;
+  SignalClosed(this);
+  SignalCandidatesRemoved(this, candidates_);
+}
+
 void Port::SetIceParameters(int component,
                             const std::string& username_fragment,
                             const std::string& password) {
   component_ = component;
   ice_username_fragment_ = username_fragment;
   password_ = password;
   for (Candidate& c : candidates_) {
     c.set_component(component);
     c.set_username(username_fragment);
     c.set_password(password);
   }
 }
 
 Connection* Port::GetConnection(const rtc::SocketAddress& remote_addr) {
   AddressMap::const_iterator iter = connections_.find(remote_addr);
   if (iter != connections_.end())
     return iter->second;
   else
     return NULL;
 }
 
+void Port::FailAndDestroyConnections() {
+  for (auto kv : connections_) {
+    kv.second->FailAndDestroy();
+  }
+}
+
 void Port::AddAddress(const rtc::SocketAddress& address,
                       const rtc::SocketAddress& base_address,
                       const rtc::SocketAddress& related_address,
                       const std::string& protocol,
                       const std::string& relay_protocol,
                       const std::string& tcptype,
                       const std::string& type,
                       uint32_t type_preference,
                       uint32_t relay_preference,
                       bool final) {
@@ skipping 395 matching lines @@
 
 void Port::OnMessage(rtc::Message *pmsg) {
   ASSERT(pmsg->message_id == MSG_DEAD);
   if (dead()) {
     Destroy();
   }
 }
 
 void Port::OnNetworkInactive(const rtc::Network* network) {
   ASSERT(network == network_);
-  SignalNetworkInactive(this);
+  CloseAndSignalCandidateRemovals();
 }
 
 void Port::OnNetworkTypeChanged(const rtc::Network* network) {
   ASSERT(network == network_);
 
   UpdateNetworkCost();
 }
 
 std::string Port::ToString() const {
   std::stringstream ss;
@@ skipping 842 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     stats_.sent_discarded_packets++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket