Cleanup network type matching.

chromeos/network/network_state_handler.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_
 #define CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 18 matching lines @@
 namespace tracked_objects {
 class Location;
 }
 
 namespace chromeos {
 
 class DeviceState;
 class NetworkState;
 class NetworkStateHandlerObserver;
 class NetworkStateHandlerTest;
+class NetworkTypePattern;
 
 // Class for tracking the list of visible networks and their properties.
 //
 // This class maps essential properties from the connection manager (Shill) for
 // each visible network. It is not used to change the properties of services or
 // devices, only global (manager) properties.
 //
 // All getters return the currently cached properties. This class is expected to
 // keep properties up to date by managing the appropriate Shill observers.
 // It will invoke its own more specific observer methods when the specified
 // changes occur.
 //
-// Most *ByType or *ForType methods will accept any of the following  for
-// |type|. See individual methods for specific notes.
+// Most *ByType or *ForType methods will accept any of the following for |type|.
+// See individual methods for specific notes.
 // * Any type defined in service_constants.h (e.g. flimflam::kTypeWifi)
 // * kMatchTypeDefault returns the default (active) network
 // * kMatchTypeNonVirtual returns the primary non virtual network
+// * kMatchTypeWired returns the primary wired network
 // * kMatchTypeWireless returns the primary wireless network
 // * kMatchTypeMobile returns the primary cellular or wimax network
 
 class CHROMEOS_EXPORT NetworkStateHandler
     : public internal::ShillPropertyHandler::Listener {
  public:
   typedef std::vector<ManagedState*> ManagedStateList;
   typedef std::vector<const NetworkState*> NetworkStateList;
   typedef std::vector<const DeviceState*> DeviceStateList;
   typedef std::vector<const FavoriteState*> FavoriteStateList;
@@ skipping 12 matching lines @@
   void AddObserver(NetworkStateHandlerObserver* observer,
                    const tracked_objects::Location& from_here);
   void RemoveObserver(NetworkStateHandlerObserver* observer,
                       const tracked_objects::Location& from_here);
 
   // Requests all Manager properties, specifically to update the complete
   // list of services which determines the list of Favorites. This should be
   // called any time a new service is configured or a Profile is loaded.
   void UpdateManagerProperties();
 
-  // Returns the state for technology |type|. kMatchTypeMobile (only) is
-  // also supported.
-  TechnologyState GetTechnologyState(const std::string& type) const;
-  bool IsTechnologyAvailable(const std::string& type) const {
+  // Returns the state for technology |type|. Only
+  // NetworkTypePattern::Primitive, ::Mobile and ::Ethernet are supported.
+  TechnologyState GetTechnologyState(const NetworkTypePattern& type) const;
+  bool IsTechnologyAvailable(const NetworkTypePattern& type) const {
     return GetTechnologyState(type) != TECHNOLOGY_UNAVAILABLE;
   }
-  bool IsTechnologyEnabled(const std::string& type) const {
+  bool IsTechnologyEnabled(const NetworkTypePattern& type) const {
     return GetTechnologyState(type) == TECHNOLOGY_ENABLED;
   }
 
-  // Asynchronously sets the technology enabled property for |type|.
-  // kMatchTypeMobile (only) is also supported.
+  // Asynchronously sets the technology enabled property for |type|. Only
+  // NetworkTypePattern::Primitive, ::Mobile and ::Ethernet are supported.
   // Note: Modifies Manager state. Calls |error_callback| on failure.
   void SetTechnologyEnabled(
-      const std::string& type,
+      const NetworkTypePattern& type,
       bool enabled,
       const network_handler::ErrorCallback& error_callback);
 
   // Finds and returns a device state by |device_path| or NULL if not found.
   const DeviceState* GetDeviceState(const std::string& device_path) const;
 
   // Finds and returns a device state by |type|. Returns NULL if not found.
-  // See note above for valid types.
-  const DeviceState* GetDeviceStateByType(const std::string& type) const;
+  const DeviceState* GetDeviceStateByType(const NetworkTypePattern& type) const;
 
   // Returns true if any device of |type| is scanning.
-  // See note above for valid types.
-  bool GetScanningByType(const std::string& type) const;
+  bool GetScanningByType(const NetworkTypePattern& type) const;
 
   // Finds and returns a network state by |service_path| or NULL if not found.
   // Note: NetworkState is frequently updated asynchronously, i.e. properties
   // are not always updated all at once. This will contain the most recent
   // value for each property. To receive notifications when a property changes,
   // observe this class and implement NetworkPropertyChanged().
   const NetworkState* GetNetworkState(const std::string& service_path) const;
 
   // Returns the default connected network (which includes VPNs) or NULL.
   // This is equivalent to ConnectedNetworkByType(kMatchTypeDefault).
   const NetworkState* DefaultNetwork() const;
 
   // Returns the primary connected network of matching |type|, otherwise NULL.
-  // See note above for valid types.
-  const NetworkState* ConnectedNetworkByType(const std::string& type) const;
+  const NetworkState* ConnectedNetworkByType(
+      const NetworkTypePattern& type) const;
 
   // Like ConnectedNetworkByType() but returns a connecting network or NULL.
-  const NetworkState* ConnectingNetworkByType(const std::string& type) const;
+  const NetworkState* ConnectingNetworkByType(
+      const NetworkTypePattern& type) const;
 
   // Like ConnectedNetworkByType() but returns any matching network or NULL.
   // Mostly useful for mobile networks where there is generally only one
   // network. Note: O(N).
-  const NetworkState* FirstNetworkByType(const std::string& type) const;
+  const NetworkState* FirstNetworkByType(const NetworkTypePattern& type) const;
 
   // Returns the hardware (MAC) address for the first connected network
-  // matching |type|, or an empty string if none.
-  // See note above for valid types.
-  std::string HardwareAddressForType(const std::string& type) const;
+  // matching |type|, or an empty string if none is connected.
+  std::string HardwareAddressForType(const NetworkTypePattern& type) const;
   // Same as above but in aa:bb format.
-  std::string FormattedHardwareAddressForType(const std::string& type) const;
+  std::string FormattedHardwareAddressForType(
+      const NetworkTypePattern& type) const;
 
   // Sets |list| to contain the list of networks.  The returned list contains
   // a copy of NetworkState pointers which should not be stored or used beyond
   // the scope of the calling function (i.e. they may later become invalid, but
   // only on the UI thread).
   void GetNetworkList(NetworkStateList* list) const;
 
   // Like GetNetworkList() but only returns networks with matching |type|.
-  void GetNetworkListByType(const std::string& type,
+  void GetNetworkListByType(const NetworkTypePattern& type,
                             NetworkStateList* list) const;
 
   // Sets |list| to contain the list of devices.  The returned list contains
   // a copy of DeviceState pointers which should not be stored or used beyond
   // the scope of the calling function (i.e. they may later become invalid, but
   // only on the UI thread).
   void GetDeviceList(DeviceStateList* list) const;
 
   // Sets |list| to contain the list of favorite (aka "preferred") networks.
   // See GetNetworkList() for usage, and notes for |favorite_list_|.
   // Favorites that are visible have the same path() as the entries in
   // GetNetworkList(), so GetNetworkState() can be used to determine if a
   // favorite is visible and retrieve the complete properties (and vice-versa).
   void GetFavoriteList(FavoriteStateList* list) const;
 
   // Finds and returns a favorite state by |service_path| or NULL if not found.
   const FavoriteState* GetFavoriteState(const std::string& service_path) const;
 
   // Requests a network scan. This may trigger updates to the network
   // list, which will trigger the appropriate observer calls.
   void RequestScan() const;
 
   // Request a scan if not scanning and run |callback| when the Scanning state
-  // for any Device matching |type| completes.
+  // for any Device of network type |type| completes.
   void WaitForScan(const std::string& type, const base::Closure& callback);
 
   // Request a network scan then signal Shill to connect to the best available
   // networks when completed.
   void ConnectToBestWifiNetwork();
 
   // Request an update for an existing NetworkState, e.g. after configuring
   // a network. This is a no-op if an update request is already pending. To
   // ensure that a change is picked up, this must be called after Shill
   // acknowledged it (e.g. in the callback of a SetProperties).
@@ skipping 13 matching lines @@
   const std::string& check_portal_list() const { return check_portal_list_; }
 
   // Generates a DictionaryValue of all NetworkState properties. Currently
   // provided for debugging purposes only.
   void GetNetworkStatePropertiesForTest(
       base::DictionaryValue* dictionary) const;
 
   // Construct and initialize an instance for testing.
   static NetworkStateHandler* InitializeForTest();
 
-  static const char kMatchTypeDefault[];
-  static const char kMatchTypeWireless[];
-  static const char kMatchTypeMobile[];
-  static const char kMatchTypeNonVirtual[];
-
   // Default set of comma separated interfaces on which to enable
   // portal checking.
   static const char kDefaultCheckPortalList[];
 
  protected:
   friend class NetworkHandler;
   NetworkStateHandler();
 
   // ShillPropertyHandler::Listener overrides.
 
@@ skipping 77 matching lines @@
   // Logs an event and notifies observers.
   void OnDefaultNetworkChanged();
 
   // Notifies observers and updates connecting_network_.
   void NetworkPropertiesUpdated(const NetworkState* network);
 
   // Called whenever Device.Scanning state transitions to false.
   void ScanCompleted(const std::string& type);
 
   // Returns the technology type for |type|.
-  std::string GetTechnologyForType(const std::string& type) const;
+  std::string GetTechnologyForType(const NetworkTypePattern& type) const;
 
   // Shill property handler instance, owned by this class.
   scoped_ptr<internal::ShillPropertyHandler> shill_property_handler_;
 
   // Observer list
   ObserverList<NetworkStateHandlerObserver> observers_;
 
   // List of managed network states
   ManagedStateList network_list_;
 
@@ skipping 13 matching lines @@
 
   // Callbacks to run when a scan for the technology type completes.
   ScanCompleteCallbackMap scan_complete_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkStateHandler);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_