Add NetworkDeviceHandler

chromeos/network/network_device_handler.h

Index: chromeos/network/network_device_handler.h
diff --git a/chromeos/network/network_device_handler.h b/chromeos/network/network_device_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..366e22316e12981ea1131ef521795f470c2b8b75
--- /dev/null
+++ b/chromeos/network/network_device_handler.h
@@ -0,0 +1,102 @@
+// 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_DEVICE_HANDLER_H_
+#define CHROMEOS_NETWORK_NETWORK_DEVICE_HANDLER_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "base/memory/weak_ptr.h"
+#include "base/observer_list.h"
+#include "chromeos/chromeos_export.h"
+#include "chromeos/dbus/dbus_method_call_status.h"
+#include "chromeos/dbus/shill_property_changed_observer.h"
+#include "chromeos/network/network_util.h"  // WifiAccessPoint
+
+namespace base {
+class DictionaryValue;
+class ListValue;
+class Value;
+}
+
+namespace chromeos {
+
+class CHROMEOS_EXPORT NetworkDeviceHandler
+    : public ShillPropertyChangedObserver {
+ public:
+  struct Device {
+    Device() : powered(false), scanning(false), scan_interval(0) {}
+    std::string type;
+    bool powered;
+    bool scanning;
+    int scan_interval;
+    std::map<std::string, WifiAccessPoint> wifi_access_points;
+  };
+  typedef std::map<std::string, Device> DeviceMap;
+
+  class Observer {

[Greg Spencer (Chromium), 2013/01/04 23:57:26]

This class should be in a separate header.  There was a thread about this in
chromium-dev and in a bug, where it was decided that because it becomes
ambiguous at times when it's a nested class, and because then observers don't
need to include the entire header that it's better to separate observers into
separate headers.

[stevenjb, 2013/01/07 15:56:22]

I don't recall the specifics of that discussion, but we still use this pattern
in Ash. I think it still makes sense when the Observer class has dependencies on
the parent class (here we depend on DeviceMap which depends on Device, so we
would have to put Device in its own header as well to remove the dependency).

[Greg Spencer (Chromium), 2013/01/08 21:03:07]

Well, Device could go in the same header file as the Observer.

I don't feel super strongly about this, but it's been shown to be a weakness of
this pattern in the past.  I'll let you decide if you think it's worth it or
not.

[stevenjb, 2013/01/08 21:29:17]

Yeah, but it wouldn't make sense to have Device in the _observer file, so you're
really talking three files at that point. I'm going to leave it as is. If this
gains complexity, then Device can become a class of its own and we can extract
the observer, the same as we did for NetworkState / Handler / Observer. In the
meanwhile, I hope to keep this class constrained and simple.

+   public:
+    typedef NetworkDeviceHandler::DeviceMap DeviceMap;
+
+    // Called when |devices_| is updated, passes |devices_| as a convenience.

[Greg Spencer (Chromium), 2013/01/04 23:57:26]

Shouldn't one of those be "|devices|" without the underscore?

[stevenjb, 2013/01/07 15:56:22]

Done.

+    virtual void NetworkDevicesUpdated(const DeviceMap& devices) = 0;
+
+   protected:
+    virtual ~Observer() {}
+  };
+
+  NetworkDeviceHandler();
+  virtual ~NetworkDeviceHandler();
+  void Init();
+
+  // Add/remove observers.
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+  bool devices_ready() const { return devices_ready_; }
+  const DeviceMap& devices() const { return devices_; }
+
+  // ShillPropertyChangedObserver overrides
+  virtual void OnPropertyChanged(const std::string& key,
+                                 const base::Value& value) OVERRIDE;
+
+ private:
+  void ManagerPropertiesCallback(DBusMethodCallStatus call_status,
+                                 const base::DictionaryValue& properties);
+  void DevicePropertyChanged(const base::ListValue* devices);
+  void DevicePropertiesCallback(const std::string& device_path,
+                                DBusMethodCallStatus call_status,
+                                const base::DictionaryValue& properties);
+  void NetworkPropertiesCallback(const std::string& device_path,
+                                 const std::string& network_path,
+                                 DBusMethodCallStatus call_status,
+                                 const base::DictionaryValue& properties);
+  void DeviceNetworkReady(const std::string& device_path,
+                          const std::string& network_path);
+  void DeviceReady(const std::string& device_path);
+
+  // True when the device list is up to date.
+  bool devices_ready_;
+
+  // Map of Device structs, valid when |devices_ready_| is true.
+  DeviceMap devices_;
+
+  // Map of pending devices.
+  std::set<std::string> pending_device_paths_;
+
+  // Map of pending networks per device path.
+  std::map<std::string, std::set<std::string> > pending_network_paths_;
+
+  // Observer list
+  ObserverList<Observer> observers_;
+
+  // For Shill client callbacks
+  base::WeakPtrFactory<NetworkDeviceHandler> weak_ptr_factory_;
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_NETWORK_NETWORK_DEVICE_HANDLER_H_