Add chromeos::NetworkStateManager

chromeos/network/network_state_handler_observer.h

Index: chromeos/network/network_state_handler_observer.h
diff --git a/chromeos/network/network_state_handler_observer.h b/chromeos/network/network_state_handler_observer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c2ee34e89bfe1bcc737063fdea8943e52bfef38
--- /dev/null
+++ b/chromeos/network/network_state_handler_observer.h
@@ -0,0 +1,48 @@
+// 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_OBSERVER_H_
+#define CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_OBSERVER_H_
+
+#include <string>
+#include <vector>
+#include "base/basictypes.h"
+
+namespace chromeos {
+
+class NetworkState;
+
+// Observer class for all network state changes, including changes to
+// active (connecting or connected) services.
+class NetworkStateHandlerObserver {
+ public:
+  typedef std::vector<NetworkState*> NetworkStateList;
+
+  NetworkStateHandlerObserver();
+  virtual ~NetworkStateHandlerObserver();
+
+  // If |property| is non empty than that property has changed. Otherwise

[pneubeck (no reviews), 2012/10/25 14:42:17]

Nit: than -> then
The "otherwise" doesn't sound sophisticated. Should we perhaps provide a vector
of the changed properties?

[stevenjb, 2012/10/25 22:05:22]

This wasn't meant to be sophisticated. That would require a lot of bookkeeping
and I can think of where that would be useful. I did update the comment.

+  // multiple properties may have changed.
+  virtual void NetworkManagerChanged(const std::string& property);

[pneubeck (no reviews), 2012/10/25 14:42:17]

I'm rather unhappy about this mixture of property names/keys (here |property|) 
with the accessors in the State classes.

That means, every user of the state classes has to know the mapping from the
method names (like security()) to the shill constants
(flimflam::kSecurityProperty) which he has to look up in the incomplete shill
documentation.

Why that redundancy and mental-complication? Wouldn't it be easier to agree on a
well-defined state format (similar to ONC) and put it into a dictionary?

e.g. a network state could look like:

{ type: "network",
  path: "service/123",
  network : {
    type: "wifi",
    name: "my wifi",
    ssid: "my ssid",
    signal_strength: 123
  }
}

Then we also get the translation to json/JS for free!
And changes could simply be a subset of that dictionary.

[stevenjb, 2012/10/25 22:05:22]

I agree that this is not ideal, and I've been considering just storing the
states into a DictionaryValue. There are two reasons I have resisted that:
a) Most of the UI code will never use the keys at all, and just needs easy
access to the named properties.
b) A couple of the properties are not direct mappings to shill dictionary
values: ip_address, home_provider_id. I expect a few more may crop up for
mobile.

Most of the observer implementations will ignore the property argument, it's
provided primarily for the code that does want to optimize.

That said, with this implementation we will need to convert these values to JSON
for the JS api. However, doing so will be pretty trivial.

I think this code may be an evolutionary step which we can eventually replaced
with just ONC data, but I feel like there are still too many questions that
still need to be resolved there, so the intermediate step seems worthwhile, but
I may be able to be convinced otherwise.

+  // The list of networks changed.
+  virtual void NetworkListChanged(const NetworkStateList& networks);
+  // The active network changed. |network| will be NULL if there is no longer
+  // an active network.
+  virtual void ActiveNetworkChanged(const NetworkState* network);
+  // The state of the active network changed.
+  virtual void ActiveNetworkStateChanged(const NetworkState* network);
+  // A network service property changed. |property| is the name of the changed
+  // property (from service_constants.h). Note: for the active network,
+  // this will be called in *addition* to ActiveNetworkStateChanged() if
+  // property == flimflam::kStateProperty.
+  virtual void NetworkServicePropertyChanged(const NetworkState* network,
+                                             const std::string& property);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NetworkStateHandlerObserver);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROMEOS_NETWORK_NETWORK_STATE_HANDLER_OBSERVER_H_