Move the concept of multiple route into Network

webrtc/base/network.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 146 matching lines @@
   return ost.str();
 }
 
 NetworkManager::NetworkManager() {
 }
 
 NetworkManager::~NetworkManager() {
 }
 
 NetworkManagerBase::NetworkManagerBase()
-    : max_ipv6_networks_(kMaxIPv6Networks), ipv6_enabled_(true) {
+    : network_permission_state_(NetworkManager::STATE_UNKNOWN),
+      max_ipv6_networks_(kMaxIPv6Networks),
+      ipv6_enabled_(true) {
 }
 
 NetworkManagerBase::~NetworkManagerBase() {
   for (const auto& kv : networks_map_) {
     delete kv.second;
   }
 }
 
+NetworkManager::NetworkPermissionState
+NetworkManagerBase::network_permission_state() const {
+  return network_permission_state_;
+}
+
 void NetworkManagerBase::GetAnyAddressNetworks(NetworkList* networks) {
   if (!ipv4_any_address_network_) {
     const rtc::IPAddress ipv4_any_address(INADDR_ANY);
     ipv4_any_address_network_.reset(
         new rtc::Network("any", "any", ipv4_any_address, 0));
     ipv4_any_address_network_->AddIP(ipv4_any_address);
   }
   networks->push_back(ipv4_any_address_network_.get());
 
   if (ipv6_enabled()) {
@@ skipping 113 matching lines @@
     for (Network* network : networks_) {
       network->set_preference(pref);
       if (pref > 0) {
         --pref;
       } else {
         LOG(LS_ERROR) << "Too many network interfaces to handle!";
         break;
       }
     }
   }
+
+  network_permission_state_ = STATE_ALLOWED;

[pthatcher1, 2015/08/18 18:34:19]

I don't understand.  Why is it not allowed until after the network list is
merged?  Why isn't it allowed right from the start?

[juberti1, 2015/08/20 06:31:04]

I'm not sure we know if it's allowed initially.

[pthatcher1, 2015/08/20 06:43:36]

Outside of Chrome it is.  Chrome can change the state for its uses.

 }
 
 BasicNetworkManager::BasicNetworkManager()
     : thread_(NULL), sent_first_update_(false), start_count_(0),
       network_ignore_mask_(kDefaultNetworkIgnoreMask),
       ignore_non_default_routes_(false) {
 }
 
 BasicNetworkManager::~BasicNetworkManager() {
 }
@@ skipping 338 matching lines @@
 
 void BasicNetworkManager::StopUpdating() {
   ASSERT(Thread::Current() == thread_);
   if (!start_count_)
     return;
 
   --start_count_;
   if (!start_count_) {
     thread_->Clear(this);
     sent_first_update_ = false;
+    set_network_permission_state(NetworkManager::STATE_UNKNOWN);

[pthatcher1, 2015/08/18 18:34:19]

Why does the permission state change when we stop updating?  It seems like we're
mixing up "ready state" with "permission state".

   }
 }
 
 void BasicNetworkManager::OnMessage(Message* msg) {
   switch (msg->message_id) {
     case kUpdateNetworksMessage:  {
       DoUpdateNetworks();
       break;
     }
     case kSignalNetworksMessage:  {
@@ skipping 123 matching lines @@
   std::stringstream ss;
   // Print out the first space-terminated token of the network desc, plus
   // the IP address.
   ss << "Net[" << description_.substr(0, description_.find(' '))
      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
      << ":" << AdapterTypeToString(type_) << "]";
   return ss.str();
 }
 
 }  // namespace rtc