Move the concept of multiple route into Network

webrtc/base/network.h

 /*
  *  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 38 matching lines @@
 // length of that prefix.
 std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
                            int prefix_length);
 
 // Generic network manager interface. It provides list of local
 // networks.
 class NetworkManager {
  public:
   typedef std::vector<Network*> NetworkList;
 
+  // This enum indicates the state of GetNetworks.
+  enum NetworkPermissionState {
+    STATE_UNKNOWN,  // SignalNetworksChanged is not fired yet.
+    STATE_ALLOWED,  // Adapter enumeration is allowed. Getting 0 network from
+                    // GetNetworks means that there is no network available.
+    STATE_BLOCKED   // Adapter enumeration is disabled. GetAnyAddressNetworks()
+                    // should be used instead.

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

I think a better name might be:

enum EnumerationPermission {
  ENUMERATION_PENDING
  ENUMERATION_ALLOWED,
  ENUMERATION_DISALLOWED
}

Actually, the style of enums is supposed to be:

enum EnumerationPermission {
  kEnumerationPending,
  kEnumerationAllowed,
  kEnumerationDisallowed,
}

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

Peter, we (and Chrome) use old-style enum macros everywhere. I don't understand
why we would use k-style here.

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

We switched back to old-style enums?  I wasn't aware.  Thanks for letting me
know.  Sorry, Guowei.  I guess we should switch it back.

+  };
+
   NetworkManager();
   virtual ~NetworkManager();
 
   // Called when network list is updated.
   sigslot::signal0<> SignalNetworksChanged;
 
   // Indicates a failure when getting list of network interfaces.
   sigslot::signal0<> SignalError;
 
   // Start/Stop monitoring of network interfaces
   // list. SignalNetworksChanged or SignalError is emitted immediately
   // after StartUpdating() is called. After that SignalNetworksChanged
   // is emitted whenever list of networks changes.
   virtual void StartUpdating() = 0;
   virtual void StopUpdating() = 0;
 
   // Returns the current list of networks available on this machine.
-  // UpdateNetworks() must be called before this method is called.
+  // StartUpdating() must be called before this method is called.
   // It makes sure that repeated calls return the same object for a
   // given network, so that quality is tracked appropriately. Does not
   // include ignored networks.
   virtual void GetNetworks(NetworkList* networks) const = 0;

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

We might consider calling this EnumerateNetworks.

 
+  // return the current permission state of GetNetworks()
+  virtual NetworkPermissionState network_permission_state() const = 0;

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

enumeration_permission() would work well here as a name.

+
   // "AnyAddressNetwork" is a network which only contains single "any address"
   // IP address.  (i.e. INADDR_ANY for IPv4 or in6addr_any for IPv6). This is
   // useful as binding to such interfaces allow default routing behavior like
   // http traffic.
   // TODO(guoweis): remove this body when chromium implements this.
   virtual void GetAnyAddressNetworks(NetworkList* networks) {}
 
   // Dumps a list of networks available to LS_INFO.
   virtual void DumpNetworks(bool include_ignored) {}
 
@@ skipping 14 matching lines @@
   ~NetworkManagerBase() override;
 
   void GetNetworks(std::vector<Network*>* networks) const override;
   void GetAnyAddressNetworks(NetworkList* networks) override;
   bool ipv6_enabled() const { return ipv6_enabled_; }
   void set_ipv6_enabled(bool enabled) { ipv6_enabled_ = enabled; }
 
   void set_max_ipv6_networks(int networks) { max_ipv6_networks_ = networks; }
   int max_ipv6_networks() { return max_ipv6_networks_; }
 
+  NetworkPermissionState network_permission_state() const override;
+
  protected:
   typedef std::map<std::string, Network*> NetworkMap;
   // Updates |networks_| with the networks listed in |list|. If
   // |network_map_| already has a Network object for a network listed
   // in the |list| then it is reused. Accept ownership of the Network
   // objects in the |list|. |changed| will be set to true if there is
   // any change in the network list.
   void MergeNetworkList(const NetworkList& list, bool* changed);
 
   // |stats| will be populated even if |*changed| is false.
   void MergeNetworkList(const NetworkList& list,
                         bool* changed,
                         NetworkManager::Stats* stats);
 
+  void set_network_permission_state(NetworkPermissionState state) {
+    network_permission_state_ = state;
+  }
+
  private:
   friend class NetworkTest;
   void DoUpdateNetworks();
 
+  NetworkPermissionState network_permission_state_;
+
   NetworkList networks_;
   int max_ipv6_networks_;
 
   NetworkMap networks_map_;
   bool ipv6_enabled_;
 
   rtc::scoped_ptr<rtc::Network> ipv4_any_address_network_;
   rtc::scoped_ptr<rtc::Network> ipv6_any_address_network_;
 };
 
@@ skipping 157 matching lines @@
   bool ignored_;
   AdapterType type_;
   int preference_;
 
   friend class NetworkManager;
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_NETWORK_H_