Add chromeos::NetworkStateManager

chromeos/network/network_state_handler.h

Index: chromeos/network/network_state_handler.h
diff --git a/chromeos/network/network_state_handler.h b/chromeos/network/network_state_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..91d54bfe52082d31b837eb3ba7c839828a537a93
--- /dev/null
+++ b/chromeos/network/network_state_handler.h
@@ -0,0 +1,190 @@
+// 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>
+#include <vector>
+
+#include "base/gtest_prod_util.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/observer_list.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/network/managed_state.h"
+#include "chromeos/network/shill_property_handler.h"
+
+namespace base {
+class DictionaryValue;
+class ListValue;
+class Value;
+}
+
+namespace chromeos {
+
+class DeviceState;
+class NetworkState;
+class NetworkStateHandlerObserver;
+
+// Class for tracking the list of visible networks and their state.
+//
+// This class maps essential state from the connection manager (Shill) for
+// each visible network. It is not used to change the state of services or
+// devices, only global (manager) state.
+//
+// All getters return the currently cached state. This class is expected to
+// keep states up to date by managing the appropriate Shill observers.
+// It will invoke its own more specific observer methods when the specified
+// changes occur.
+class CHROMEOS_EXPORT NetworkStateHandler
+    : public internal::ShillPropertyHandler::Listener {
+ public:
+  typedef std::vector<ManagedState*> ManagedStateList;
+  typedef std::vector<const NetworkState*> NetworkStateList;
+
+  NetworkStateHandler();
+  virtual ~NetworkStateHandler();
+
+  // Initialize ShillPropertyHandler.
+  void Init();
+
+  // Add/remove observers.
+  void AddObserver(NetworkStateHandlerObserver* observer);
+  void RemoveObserver(NetworkStateHandlerObserver* observer);
+
+  // Returns true if |technology| is enabled / available.
+  bool TechnologyAvailable(const std::string& technology) const;
+  bool TechnologyEnabled(const std::string& technology) const;
+
+  // Asynchronously sets the enabled state for |technology|.
+  // Note: Modifes Manager state. TODO(stevenjb): Add a completion callback.
+  void SetTechnologyEnabled(const std::string& technology, bool enabled);
+
+  // 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.
+  const DeviceState* GetDeviceStateByType(const std::string& 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 state. To receive notifications when the state changes,
+  // observer this class and implement NetworkServiceChanged().
+  const NetworkState* GetNetworkState(const std::string& service_path) const;
+
+  // Returns the "active" network (first network in the list if connected),
+  // NULL if none.
+  const NetworkState* ActiveNetwork() const;
+
+  // Returns the first connected network of type |type|, otherwise NULL.
+  const NetworkState* ConnectedNetworkByType(const std::string& type) const;
+
+  // Returns the first connecting network of type |type|, otherwise NULL.
+  // An empty type will return any connecting non-ethernet network.
+  const NetworkState* ConnectingNetworkByType(const std::string& type) const;
+
+  // Returns the hardware (MAC) address for the first connected network
+  // matching |type|, or an empty string if none.
+  std::string HardwareAddressForType(const std::string& type) const;
+  // Same as above but in aa:bb format.
+  std::string FormattedHardwareAddressForType(const std::string& 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). This also sends a scan request to Shill which may
+  // trigger updates to the networks (which will trigger the appropriate
+  // observer calls).
+  void GetNetworkList(NetworkStateList* list) const;
+
+  // ShillPropertyHandler::Listener overrides.
+
+  // This adds new entries to the managed list specified by |type| and deletes
+  // any entries that are no longer in the list.
+  virtual void UpdateManagedList(ManagedState::ManagedType type,
+                                 const base::ListValue& entries) OVERRIDE;
+
+  // Sets |available_technologies_| to contain only entries in |technologies|.
+  virtual void UpdateAvailableTechnologies(
+      const base::ListValue& technologies) OVERRIDE;
+
+  // Sets |enabled_technologies_| to contain only entries in |technologies|.
+  virtual void UpdateEnabledTechnologies(
+      const base::ListValue& technologies) OVERRIDE;
+
+  // Parses the properties for the network service or device. Mostly calls
+  // managed->PropertyChanged(key, value) for each dictionary entry.
+  virtual void UpdateManagedStateProperties(
+      ManagedState::ManagedType type,
+      const std::string& path,
+      const base::DictionaryValue& properties) OVERRIDE;
+
+  // Called by ShillPropertyHandler when a watched service property changes.
+  // Calls ParseNetworkServiceProperty() and signals observers.
+  virtual void UpdateNetworkServiceProperty(
+      const std::string& service_path,
+      const std::string& key,
+      const base::Value& value) OVERRIDE;
+
+  // Sets the IP Address for the network associated with |service_path|.
+  virtual void UpdateNetworkServiceIPAddress(
+      const std::string& service_path,
+      const std::string& ip_address) OVERRIDE;
+
+  // Sends NetworkManagerChanged() to observers.
+  virtual void ManagerPropertyChanged() OVERRIDE;
+
+  // Called by |shill_property_handler_| when the service or device list has
+  // changed and all entries have been updated. If |type| == TYPE_NETWORK,
+  // this notifies observers that the network list has changed, and if the
+  // active network has changed sends that notification also.
+  virtual void ManagedStateListChanged(
+      ManagedState::ManagedType type) OVERRIDE;
+
+private:
+  FRIEND_TEST_ALL_PREFIXES(NetworkStateHandlerTest, NetworkStateHandlerStub);
+
+  // Non-const getters for managed entries. These are const so that they can
+  // be called by Get[Network|Device]State, even though they return non-const
+  // pointers.
+  DeviceState* GetModifiableDeviceState(const std::string& device_path) const;
+  NetworkState* GetModifiableNetworkState(
+      const std::string& service_path) const;
+  ManagedState* GetModifiableManagedState(const ManagedStateList* managed_list,
+                                          const std::string& path) const;
+
+  // Gets the list specified by |type|.
+  ManagedStateList* GetManagedList(ManagedState::ManagedType type);
+
+  // Helper function called to parse |network| properties.
+  bool ParseNetworkServiceProperty(NetworkState* network,
+                                   const std::string& key,
+                                   const base::Value& value);
+
+  // Shill property handler instance, owned by this class.
+  scoped_ptr<internal::ShillPropertyHandler> shill_property_handler_;
+
+  // Observer list
+  ObserverList<NetworkStateHandlerObserver> observers_;
+
+  // Lists of managed states
+  ManagedStateList network_list_;
+  ManagedStateList device_list_;
+
+  // Lists of available / enabled technologies
+  std::set<std::string> available_technologies_;
+  std::set<std::string> enabled_technologies_;
+
+  // Keeps track of the active network for notifying observers when it changes.
+  std::string active_network_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(NetworkStateHandler);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_H_