Landing change for ers@chromium.org: http://codereview.chromium.org/4134012/show

Added handling of network ("service" in flimflam parlance) property changes. 
NetworkLibrary updates its Network objects in response to property changes, 
then calls any NetworkObservers that have registered for the given network. 

Use the is_active member of Network in various places to ensure that we are 
dealing with the correct network. 

Created separate observer classes for NetworkManager, Network, and 
CellularDataPlan, so that monitors can be established independently for each 
of them. Changed the callback method names to prepend "On", i.e., 
OnNetworkManagerChanged, OnNetworkChanged, OnCellularDataPlanChanged. 

Wired up signal strength update and network technology update in the status 
bar, network dropdown menu, and internet settings page. 

Added new icon badges for 1xRTT radio technology. These are used when EVDO 
coverage switches to 1xRTT. Just as is the case for the 3G icons, there are 
three 1x icons: normal, warn, and error. Please consider these icons to be 
placeholders if the UI folks think they need to be redesigned. 

Centralized choosing of the network technology badge in 
NetworkMenu::BadgeForNetworkTechnology. 

BUG=chromium-os:5612:chromium-os:7619,chromium-os:5917,chromium-os:4674 
TEST=Extensive manual testing with different combinations of wi-fi and 
cellular networks connected and disconnected. Used a modified version 
of flimflam that randomly changes reported signal strength, network 
technology, and roaming state, and verified that the UI correctly reflected 
current values for the active network (roaming is not handled in the UI 
at this time).
Review URL: http://codereview.chromium.org/4482003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@65106 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 464 insertions, 172 deletions

diff --git a/chrome/browser/chromeos/cros/cros_mock.cc b/chrome/browser/chromeos/cros/cros_mock.cc
index 25bf9aa..51652db 100644
--- a/chrome/browser/chromeos/cros/cros_mock.cc
+++ b/chrome/browser/chromeos/cros/cros_mock.cc
@@ -29,6 +29,7 @@
 namespace chromeos {
 
 using ::testing::AnyNumber;
+using ::testing::AtMost;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
@@ -269,33 +270,28 @@ void CrosMock::SetInputMethodLibraryStatusAreaExpectations() {
 }
 
 void CrosMock::SetNetworkLibraryStatusAreaExpectations() {
-  EXPECT_CALL(*mock_network_library_, AddObserver(_))
+  EXPECT_CALL(*mock_network_library_, AddNetworkManagerObserver(_))
       .Times(1)
       .RetiresOnSaturation();
-
-  // NetworkDropdownButton::NetworkChanged() calls:
-  EXPECT_CALL(*mock_network_library_, ethernet_connected())
+  EXPECT_CALL(*mock_network_library_, AddCellularDataPlanObserver(_))
       .Times(1)
-      .WillRepeatedly((Return(false)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_network_library_, wifi_connected())
+
+  // NetworkMenuButton::OnNetworkManagerChanged() calls:
+  EXPECT_CALL(*mock_network_library_, active_network())
       .Times(1)
-      .WillRepeatedly((Return(false)))
+      .WillRepeatedly((Return((const Network*)(NULL))))
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, wifi_connecting())
       .Times(1)
       .WillRepeatedly((Return(false)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*mock_network_library_, cellular_connected())
-      .Times(1)
-      .WillRepeatedly((Return(false)))
-      .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, cellular_connecting())
       .Times(1)
       .WillRepeatedly((Return(false)))
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, Connected())
-      .Times(1)
+      .Times(2)
       .WillRepeatedly((Return(false)))
       .RetiresOnSaturation();
   EXPECT_CALL(*mock_network_library_, Connecting())
@@ -325,7 +321,13 @@ void CrosMock::SetNetworkLibraryStatusAreaExpectations() {
       .WillRepeatedly((Return(false)))
       .RetiresOnSaturation();
 
-  EXPECT_CALL(*mock_network_library_, RemoveObserver(_))
+  EXPECT_CALL(*mock_network_library_, RemoveNetworkManagerObserver(_))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*mock_network_library_, RemoveObserverForAllNetworks(_))
+      .Times(1)
+      .RetiresOnSaturation();
+  EXPECT_CALL(*mock_network_library_, RemoveCellularDataPlanObserver(_))
       .Times(1)
       .RetiresOnSaturation();
 }
diff --git a/chrome/browser/chromeos/cros/mock_network_library.h b/chrome/browser/chromeos/cros/mock_network_library.h
index 21465c7..ef72702 100644
--- a/chrome/browser/chromeos/cros/mock_network_library.h
+++ b/chrome/browser/chromeos/cros/mock_network_library.h
@@ -17,10 +17,14 @@ class MockNetworkLibrary : public NetworkLibrary {
  public:
   MockNetworkLibrary() {}
   virtual ~MockNetworkLibrary() {}
-  MOCK_METHOD1(AddObserver, void(Observer*));
-  MOCK_METHOD1(RemoveObserver, void(Observer*));
-  MOCK_METHOD2(AddProperyObserver, void(const char*, PropertyObserver*));
-  MOCK_METHOD1(RemoveProperyObserver, void(PropertyObserver*));
+  MOCK_METHOD1(AddNetworkManagerObserver, void(NetworkManagerObserver*));
+  MOCK_METHOD1(RemoveNetworkManagerObserver, void(NetworkManagerObserver*));
+  MOCK_METHOD2(AddNetworkObserver, void(const std::string&, NetworkObserver*));
+  MOCK_METHOD2(RemoveNetworkObserver, void(const std::string&,
+                                           NetworkObserver*));
+  MOCK_METHOD1(RemoveObserverForAllNetworks, void(NetworkObserver*));
+  MOCK_METHOD1(AddCellularDataPlanObserver, void(CellularDataPlanObserver*));
+  MOCK_METHOD1(RemoveCellularDataPlanObserver, void(CellularDataPlanObserver*));
   MOCK_METHOD0(ethernet_network, EthernetNetwork*(void));
   MOCK_CONST_METHOD0(ethernet_connecting, bool(void));
   MOCK_CONST_METHOD0(ethernet_connected, bool(void));
@@ -72,6 +76,7 @@ class MockNetworkLibrary : public NetworkLibrary {
   MOCK_CONST_METHOD0(wifi_enabled, bool(void));
   MOCK_CONST_METHOD0(cellular_enabled, bool(void));
 
+  MOCK_CONST_METHOD0(active_network, const Network*(void));
   MOCK_CONST_METHOD0(offline_mode, bool(void));
 
   MOCK_METHOD1(EnableEthernetNetworkDevice, void(bool));
diff --git a/chrome/browser/chromeos/cros/network_library.cc b/chrome/browser/chromeos/cros/network_library.cc
index 645279f..3aecc25 100644
--- a/chrome/browser/chromeos/cros/network_library.cc
+++ b/chrome/browser/chromeos/cros/network_library.cc
@@ -12,12 +12,129 @@
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "grit/generated_resources.h"
 
 namespace chromeos {
 
+namespace {
+// TODO(ers) These string constants and Parse functions are copied
+// straight out of libcros:chromeos_network.cc. Fix this by moving
+// all handling of properties into libcros.
+// Network service properties we are interested in monitoring
+static const char* kIsActiveProperty = "IsActive";
+static const char* kStateProperty = "State";
+static const char* kSignalStrengthProperty = "Strength";
+static const char* kActivationStateProperty = "Cellular.ActivationState";
+static const char* kNetworkTechnologyProperty = "Cellular.NetworkTechnology";
+static const char* kPaymentURLProperty = "Cellular.OlpUrl";
+static const char* kRestrictedPoolProperty = "Cellular.RestrictedPool";
+static const char* kRoamingStateProperty = "Cellular.RoamingState";
+
+// Connman state options.
+static const char* kStateIdle = "idle";
+static const char* kStateCarrier = "carrier";
+static const char* kStateAssociation = "association";
+static const char* kStateConfiguration = "configuration";
+static const char* kStateReady = "ready";
+static const char* kStateDisconnect = "disconnect";
+static const char* kStateFailure = "failure";
+static const char* kStateActivationFailure = "activation-failure";
+
+// Connman activation state options
+static const char* kActivationStateActivated = "activated";
+static const char* kActivationStateActivating = "activating";
+static const char* kActivationStateNotActivated = "not-activated";
+static const char* kActivationStatePartiallyActivated = "partially-activated";
+static const char* kActivationStateUnknown = "unknown";
+
+// Connman network technology options.
+static const char* kNetworkTechnology1Xrtt = "1xRTT";
+static const char* kNetworkTechnologyEvdo = "EVDO";
+static const char* kNetworkTechnologyGprs = "GPRS";
+static const char* kNetworkTechnologyEdge = "EDGE";
+static const char* kNetworkTechnologyUmts = "UMTS";
+static const char* kNetworkTechnologyHspa = "HSPA";
+static const char* kNetworkTechnologyHspaPlus = "HSPA+";
+static const char* kNetworkTechnologyLte = "LTE";
+static const char* kNetworkTechnologyLteAdvanced = "LTE Advanced";
+
+// Connman roaming state options
+static const char* kRoamingStateHome = "home";
+static const char* kRoamingStateRoaming = "roaming";
+static const char* kRoamingStateUnknown = "unknown";
+
+static ConnectionState ParseState(const std::string& state) {
+  if (state == kStateIdle)
+    return STATE_IDLE;
+  if (state == kStateCarrier)
+    return STATE_CARRIER;
+  if (state == kStateAssociation)
+    return STATE_ASSOCIATION;
+  if (state == kStateConfiguration)
+    return STATE_CONFIGURATION;
+  if (state == kStateReady)
+    return STATE_READY;
+  if (state == kStateDisconnect)
+    return STATE_DISCONNECT;
+  if (state == kStateFailure)
+    return STATE_FAILURE;
+  if (state == kStateActivationFailure)
+    return STATE_ACTIVATION_FAILURE;
+  return STATE_UNKNOWN;
+}
+
+static ActivationState ParseActivationState(
+    const std::string& activation_state) {
+  if (activation_state == kActivationStateActivated)
+    return ACTIVATION_STATE_ACTIVATED;
+  if (activation_state == kActivationStateActivating)
+    return ACTIVATION_STATE_ACTIVATING;
+  if (activation_state == kActivationStateNotActivated)
+    return ACTIVATION_STATE_NOT_ACTIVATED;
+  if (activation_state == kActivationStateUnknown)
+    return ACTIVATION_STATE_UNKNOWN;
+  if (activation_state == kActivationStatePartiallyActivated)
+    return ACTIVATION_STATE_PARTIALLY_ACTIVATED;
+  return ACTIVATION_STATE_UNKNOWN;
+}
+
+static NetworkTechnology ParseNetworkTechnology(
+    const std::string& technology) {
+    if (technology == kNetworkTechnology1Xrtt)
+    return NETWORK_TECHNOLOGY_1XRTT;
+  if (technology == kNetworkTechnologyEvdo)
+    return NETWORK_TECHNOLOGY_EVDO;
+  if (technology == kNetworkTechnologyGprs)
+    return NETWORK_TECHNOLOGY_GPRS;
+  if (technology == kNetworkTechnologyEdge)
+    return NETWORK_TECHNOLOGY_EDGE;
+  if (technology == kNetworkTechnologyUmts)
+    return NETWORK_TECHNOLOGY_UMTS;
+  if (technology == kNetworkTechnologyHspa)
+    return NETWORK_TECHNOLOGY_HSPA;
+  if (technology == kNetworkTechnologyHspaPlus)
+    return NETWORK_TECHNOLOGY_HSPA_PLUS;
+  if (technology == kNetworkTechnologyLte)
+    return NETWORK_TECHNOLOGY_LTE;
+  if (technology == kNetworkTechnologyLteAdvanced)
+    return NETWORK_TECHNOLOGY_LTE_ADVANCED;
+  return NETWORK_TECHNOLOGY_UNKNOWN;
+}
+static NetworkRoamingState ParseRoamingState(
+    const std::string& roaming_state) {
+    if (roaming_state == kRoamingStateHome)
+    return ROAMING_STATE_HOME;
+  if (roaming_state == kRoamingStateRoaming)
+    return ROAMING_STATE_ROAMING;
+  if (roaming_state == kRoamingStateUnknown)
+    return ROAMING_STATE_UNKNOWN;
+  return ROAMING_STATE_UNKNOWN;
+}
+}
+
 // Helper function to wrap Html with <th> tag.
 static std::string WrapWithTH(std::string text) {
   return "<th>" + text + "</th>";
@@ -99,6 +216,7 @@ void Network::Clear() {
   service_path_.clear();
   device_path_.clear();
   ip_address_.clear();
+  is_active_ = false;
 }
 
 Network::Network(const ServiceInfo* service) {
@@ -107,6 +225,7 @@ Network::Network(const ServiceInfo* service) {
   error_ = service->error;
   service_path_ = SafeString(service->service_path);
   device_path_ = SafeString(service->device_path);
+  is_active_ = service->is_active;
   ip_address_.clear();
   // If connected, get ip config.
   if (EnsureCrosLoaded() && connected() && service->device_path) {
@@ -514,7 +633,7 @@ bool WifiNetwork::IsCertificateLoaded() const {
 class NetworkLibraryImpl : public NetworkLibrary  {
  public:
   NetworkLibraryImpl()
-      : network_status_connection_(NULL),
+      : network_manager_monitor_(NULL),
         data_plan_monitor_(NULL),
         ethernet_(NULL),
         wifi_(NULL),
@@ -525,68 +644,97 @@ class NetworkLibraryImpl : public NetworkLibrary  {
         offline_mode_(false) {
     if (EnsureCrosLoaded()) {
       Init();
+      network_manager_monitor_ =
+          MonitorNetworkManager(&NetworkManagerStatusChangedHandler,
+                                this);
+      data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler,
+                                                   this);
     } else {
       InitTestData();
     }
   }
 
   ~NetworkLibraryImpl() {
-    if (network_status_connection_) {
-      DisconnectMonitorNetwork(network_status_connection_);
-    }
-    if (data_plan_monitor_) {
+    network_manager_observers_.Clear();
+    if (network_manager_monitor_)
+      DisconnectPropertyChangeMonitor(network_manager_monitor_);
+    data_plan_observers_.Clear();
+    if (data_plan_monitor_)
       DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
-    }
-    // DCHECK(!observers_.size());
-    DCHECK(!property_observers_.size());
-    STLDeleteValues(&property_observers_);
+    STLDeleteValues(&network_observers_);
     ClearNetworks();
   }
 
-  void AddObserver(Observer* observer) {
-    observers_.AddObserver(observer);
+  virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {
+    if (!network_manager_observers_.HasObserver(observer))
+      network_manager_observers_.AddObserver(observer);
   }
 
-  void RemoveObserver(Observer* observer) {
-    observers_.RemoveObserver(observer);
+  virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {
+    network_manager_observers_.RemoveObserver(observer);
   }
 
-  virtual void AddProperyObserver(const char* service_path,
-                                  PropertyObserver* observer) {
-    DCHECK(service_path);
+  virtual void AddNetworkObserver(const std::string& service_path,
+                                  NetworkObserver* observer) {
     DCHECK(observer);
     if (!EnsureCrosLoaded())
       return;
     // First, add the observer to the callback map.
-    PropertyChangeObserverMap::iterator iter = property_observers_.find(
-        std::string(service_path));
-    if (iter != property_observers_.end()) {
-      iter->second->AddObserver(observer);
+    NetworkObserverMap::iterator iter = network_observers_.find(service_path);
+    NetworkObserverList* oblist;
+    if (iter != network_observers_.end()) {
+      oblist = iter->second;
     } else {
-      std::pair<PropertyChangeObserverMap::iterator, bool> inserted =
-        property_observers_.insert(
-            std::pair<std::string, PropertyObserverList*>(
-                std::string(service_path),
-                new PropertyObserverList(this, service_path)));
-      inserted.first->second->AddObserver(observer);
+      std::pair<NetworkObserverMap::iterator, bool> inserted =
+        network_observers_.insert(
+            std::make_pair<std::string, NetworkObserverList*>(
+                service_path,
+                new NetworkObserverList(this, service_path)));
+      oblist = inserted.first->second;
     }
+    if (!oblist->HasObserver(observer))
+      oblist->AddObserver(observer);
   }
 
-  virtual void RemoveProperyObserver(PropertyObserver* observer) {
+  virtual void RemoveNetworkObserver(const std::string& service_path,
+                                     NetworkObserver* observer) {
     DCHECK(observer);
-    PropertyChangeObserverMap::iterator map_iter =
-          property_observers_.begin();
-    while (map_iter != property_observers_.end()) {
+    DCHECK(service_path.size());
+    NetworkObserverMap::iterator map_iter =
+        network_observers_.find(service_path);
+    if (map_iter != network_observers_.end()) {
       map_iter->second->RemoveObserver(observer);
       if (!map_iter->second->size()) {
         delete map_iter->second;
-        property_observers_.erase(map_iter++);
+        network_observers_.erase(map_iter++);
+      }
+    }
+  }
+
+  virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {
+    DCHECK(observer);
+    NetworkObserverMap::iterator map_iter = network_observers_.begin();
+    while (map_iter != network_observers_.end()) {
+      map_iter->second->RemoveObserver(observer);
+      if (!map_iter->second->size()) {
+        delete map_iter->second;
+        network_observers_.erase(map_iter++);
       } else {
         ++map_iter;
       }
     }
   }
 
+  virtual void AddCellularDataPlanObserver(CellularDataPlanObserver* observer) {
+    if (!data_plan_observers_.HasObserver(observer))
+      data_plan_observers_.AddObserver(observer);
+  }
+
+  virtual void RemoveCellularDataPlanObserver(
+      CellularDataPlanObserver* observer) {
+    data_plan_observers_.RemoveObserver(observer);
+  }
+
   virtual EthernetNetwork* ethernet_network() { return ethernet_; }
   virtual bool ethernet_connecting() const {
     return ethernet_ ? ethernet_->connecting() : false;
@@ -620,14 +768,14 @@ class NetworkLibraryImpl : public NetworkLibrary  {
   }
 
   const std::string& IPAddress() const {
-    // Returns highest priority IP address.
-    if (ethernet_connected())
+    // Returns IP address for the active network.
+    const Network* active = active_network();
+    if (active != NULL)
+      return active->ip_address();
+    if (ethernet_)
       return ethernet_->ip_address();
-    if (wifi_connected())
-      return wifi_->ip_address();
-    if (cellular_connected())
-      return cellular_->ip_address();
-    return ethernet_->ip_address();
+    static std::string null_address("0.0.0.0");
+    return null_address;
   }
 
   virtual const WifiNetworkVector& wifi_networks() const {
@@ -692,6 +840,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
     DCHECK(network);
     if (!EnsureCrosLoaded())
       return;
+    // TODO(ers) make wifi the highest priority service type
     if (ConnectToNetworkWithCertInfo(network->service_path().c_str(),
         password.empty() ? NULL : password.c_str(),
         identity.empty() ? NULL : identity.c_str(),
@@ -706,7 +855,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
         wifi->set_connecting(true);
         wifi_ = wifi;
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
@@ -725,6 +874,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
       // Set auto-connect.
       SetAutoConnect(service->service_path, auto_connect);
       // Now connect to that service.
+      // TODO(ers) make wifi the highest priority service type
       ConnectToNetworkWithCertInfo(service->service_path,
           password.empty() ? NULL : password.c_str(),
           identity.empty() ? NULL : identity.c_str(),
@@ -742,6 +892,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
     DCHECK(network);
     if (!EnsureCrosLoaded())
       return;
+    // TODO(ers) make cellular the highest priority service type
     if (network && ConnectToNetwork(network->service_path().c_str(), NULL)) {
       // Update local cache and notify listeners.
       CellularNetwork* cellular = GetWirelessNetworkByPath(
@@ -750,7 +901,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
         cellular->set_connecting(true);
         cellular_ = cellular;
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
@@ -765,6 +916,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
     DCHECK(network);
     if (!EnsureCrosLoaded() || !network)
       return;
+    // TODO(ers) restore default service type priority ordering?
     if (DisconnectFromNetwork(network->service_path().c_str())) {
       // Update local cache and notify listeners.
       if (network->type() == TYPE_WIFI) {
@@ -782,7 +934,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
           cellular_ = NULL;
         }
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
@@ -824,7 +976,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
           break;
         }
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
@@ -850,6 +1002,16 @@ class NetworkLibraryImpl : public NetworkLibrary  {
 
   virtual bool offline_mode() const { return offline_mode_; }
 
+  virtual const Network* active_network() const {
+    if (ethernet_ && ethernet_->is_active())
+      return ethernet_;
+    if (wifi_ && wifi_->is_active())
+      return wifi_;
+    if (cellular_ && cellular_->is_active())
+      return cellular_;
+    return NULL;
+  }
+
   virtual void EnableEthernetNetworkDevice(bool enable) {
     EnableNetworkDeviceType(TYPE_ETHERNET, enable);
   }
@@ -955,52 +1117,53 @@ class NetworkLibraryImpl : public NetworkLibrary  {
 
  private:
 
-  class PropertyObserverList : public ObserverList<PropertyObserver> {
+  class NetworkObserverList : public ObserverList<NetworkObserver> {
    public:
-    PropertyObserverList(NetworkLibraryImpl* library,
-                         const char* service_path) {
-      DCHECK(service_path);
-      property_change_monitor_ = MonitorNetworkService(&PropertyChangeHandler,
-                                                       service_path,
-                                                       library);
+    NetworkObserverList(NetworkLibraryImpl* library,
+                        const std::string& service_path) {
+      network_monitor_ = MonitorNetworkService(&NetworkStatusChangedHandler,
+                                               service_path.c_str(),
+                                               library);
     }
 
-    virtual ~PropertyObserverList() {
-      if (property_change_monitor_)
-        DisconnectPropertyChangeMonitor(property_change_monitor_);
+    virtual ~NetworkObserverList() {
+      if (network_monitor_)
+        DisconnectPropertyChangeMonitor(network_monitor_);
     }
 
    private:
-    static void PropertyChangeHandler(void* object,
-                                      const char* path,
-                                      const char* key,
-                                      const Value* value) {
-      NetworkLibraryImpl* network = static_cast<NetworkLibraryImpl*>(object);
-      DCHECK(network);
-      network->NotifyPropertyChange(path, key, value);
+    static void NetworkStatusChangedHandler(void* object,
+                                            const char* path,
+                                            const char* key,
+                                            const Value* value) {
+      NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
+      DCHECK(networklib);
+      networklib->UpdateNetworkStatus(path, key, value);
     }
-    PropertyChangeMonitor property_change_monitor_;
+    PropertyChangeMonitor network_monitor_;
   };
 
-  typedef std::map<std::string, PropertyObserverList*>
-      PropertyChangeObserverMap;
+  typedef std::map<std::string, NetworkObserverList*> NetworkObserverMap;
 
-  static void NetworkStatusChangedHandler(void* object) {
-    NetworkLibraryImpl* network = static_cast<NetworkLibraryImpl*>(object);
-    DCHECK(network);
-    network->UpdateNetworkStatus();
+  static void NetworkManagerStatusChangedHandler(void* object,
+                                                 const char* path,
+                                                 const char* key,
+                                                 const Value* value) {
+    NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
+    DCHECK(networklib);
+    networklib->UpdateNetworkManagerStatus();
   }
 
   static void DataPlanUpdateHandler(void* object,
                                     const char* modem_service_path,
                                     const CellularDataPlanList* dataplan) {
-    NetworkLibraryImpl* network = static_cast<NetworkLibraryImpl*>(object);
-    DCHECK(network && network->cellular_network());
+    NetworkLibraryImpl* networklib = static_cast<NetworkLibraryImpl*>(object);
+    DCHECK(networklib && networklib->cellular_network());
     // Store data plan for currently connected cellular network.
-    if (network->cellular_network()->service_path()
+    if (networklib->cellular_network()->service_path()
         .compare(modem_service_path) == 0) {
       if (dataplan != NULL) {
-        network->UpdateCellularDataPlan(dataplan);
+        networklib->UpdateCellularDataPlan(dataplan);
       }
     }
   }
@@ -1025,6 +1188,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
                << " str=" << service->strength
                << " fav=" << service->favorite
                << " auto=" << service->auto_connect
+               << " is_active=" << service->is_active
                << " error=" << service->error;
       // Once a connected ethernet service is found, disregard other ethernet
       // services that are also found
@@ -1064,17 +1228,10 @@ class NetworkLibraryImpl : public NetworkLibrary  {
   }
 
   void Init() {
-    // First, get the currently available networks.  This data is cached
+    // First, get the currently available networks. This data is cached
     // on the connman side, so the call should be quick.
     VLOG(1) << "Getting initial CrOS network info.";
     UpdateSystemInfo();
-
-    VLOG(1) << "Registering for network status updates.";
-    // Now, register to receive updates on network status.
-    network_status_connection_ = MonitorNetwork(&NetworkStatusChangedHandler,
-                                                this);
-    VLOG(1) << "Registering for cellular data plan updates.";
-    data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler, this);
   }
 
   void InitTestData() {
@@ -1136,7 +1293,7 @@ class NetworkLibraryImpl : public NetworkLibrary  {
 
   void UpdateSystemInfo() {
     if (EnsureCrosLoaded()) {
-      UpdateNetworkStatus();
+      UpdateNetworkManagerStatus();
     }
   }
 
@@ -1185,53 +1342,40 @@ class NetworkLibraryImpl : public NetworkLibrary  {
     EnableNetworkDevice(device, enable);
   }
 
-  void NotifyNetworkChanged() {
-    FOR_EACH_OBSERVER(Observer, observers_, NetworkChanged(this));
+  void NotifyNetworkManagerChanged() {
+    FOR_EACH_OBSERVER(NetworkManagerObserver,
+                      network_manager_observers_,
+                      OnNetworkManagerChanged(this));
   }
 
-  void NotifyCellularDataPlanChanged() {
-    FOR_EACH_OBSERVER(Observer, observers_, CellularDataPlanChanged(this));
-  }
-
-  void NotifyPropertyChange(const char* service_path,
-                            const char* key,
-                            const Value* value) {
-    DCHECK(service_path);
-    DCHECK(key);
-    DCHECK(value);
-    PropertyChangeObserverMap::const_iterator iter = property_observers_.find(
-        std::string(service_path));
-    if (iter != property_observers_.end()) {
-      FOR_EACH_OBSERVER(PropertyObserver, *(iter->second),
-          PropertyChanged(service_path, key, value));
+  void NotifyNetworkChanged(Network* network) {
+    DCHECK(network);
+    NetworkObserverMap::const_iterator iter = network_observers_.find(
+        network->service_path());
+    if (iter != network_observers_.end()) {
+      FOR_EACH_OBSERVER(NetworkObserver,
+                        *(iter->second),
+                        OnNetworkChanged(this, network));
     } else {
       NOTREACHED() <<
           "There weren't supposed to be any property change observers of " <<
-          service_path;
+           network->service_path();
     }
   }
 
-  void ClearNetworks() {
-    if (ethernet_)
-      delete ethernet_;
-    ethernet_ = NULL;
-    wifi_ = NULL;
-    cellular_ = NULL;
-    STLDeleteElements(&wifi_networks_);
-    wifi_networks_.clear();
-    STLDeleteElements(&cellular_networks_);
-    cellular_networks_.clear();
-    STLDeleteElements(&remembered_wifi_networks_);
-    remembered_wifi_networks_.clear();
+  void NotifyCellularDataPlanChanged() {
+    FOR_EACH_OBSERVER(CellularDataPlanObserver,
+                      data_plan_observers_,
+                      OnCellularDataPlanChanged(this));
   }
 
-  void UpdateNetworkStatus() {
+  void UpdateNetworkManagerStatus() {
     // Make sure we run on UI thread.
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           NewRunnableMethod(this,
-                            &NetworkLibraryImpl::UpdateNetworkStatus));
+                            &NetworkLibraryImpl::UpdateNetworkManagerStatus));
       return;
     }
 
@@ -1276,30 +1420,114 @@ class NetworkLibraryImpl : public NetworkLibrary  {
     connected_devices_ = system->connected_technologies;
     offline_mode_ = system->offline_mode;
 
-    NotifyNetworkChanged();
+    NotifyNetworkManagerChanged();
     FreeSystemInfo(system);
   }
 
+  void UpdateNetworkStatus(const char* path,
+                           const char* key,
+                           const Value* value) {
+    if (key == NULL || value == NULL)
+      return;
+    // Make sure we run on UI thread.
+    if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          NewRunnableMethod(this,
+                            &NetworkLibraryImpl::UpdateNetworkStatus,
+                            path, key, value));
+      return;
+    }
+
+    bool boolval = false;
+    int intval = 0;
+    std::string stringval;
+    Network* network;
+    if (ethernet_->service_path() == path) {
+      network = ethernet_;
+    } else {
+      CellularNetwork* cellular =
+          GetWirelessNetworkByPath(cellular_networks_, path);
+      WifiNetwork* wifi =
+          GetWirelessNetworkByPath(wifi_networks_, path);
+      if (cellular == NULL && wifi == NULL)
+        return;
+
+      WirelessNetwork* wireless;
+      if (wifi != NULL)
+        wireless = static_cast<WirelessNetwork*>(wifi);
+      else
+        wireless = static_cast<WirelessNetwork*>(cellular);
+
+      if (strcmp(key, kSignalStrengthProperty) == 0) {
+        if (value->GetAsInteger(&intval))
+          wireless->set_strength(intval);
+      } else if (cellular != NULL) {
+        if (strcmp(key, kRestrictedPoolProperty) == 0) {
+          if (value->GetAsBoolean(&boolval))
+            cellular->set_restricted_pool(boolval);
+        } else if (strcmp(key, kActivationStateProperty) == 0) {
+          if (value->GetAsString(&stringval))
+            cellular->set_activation_state(ParseActivationState(stringval));
+        } else if (strcmp(key, kPaymentURLProperty) == 0) {
+          if (value->GetAsString(&stringval))
+            cellular->set_payment_url(stringval);
+        } else if (strcmp(key, kNetworkTechnologyProperty) == 0) {
+          if (value->GetAsString(&stringval))
+            cellular->set_network_technology(
+                ParseNetworkTechnology(stringval));
+        } else if (strcmp(key, kRoamingStateProperty) == 0) {
+          if (value->GetAsString(&stringval))
+            cellular->set_roaming_state(ParseRoamingState(stringval));
+        }
+      }
+      network = wireless;
+    }
+    if (strcmp(key, kIsActiveProperty) == 0) {
+      if (value->GetAsBoolean(&boolval))
+        network->set_active(boolval);
+    } else if (strcmp(key, kStateProperty) == 0) {
+      if (value->GetAsString(&stringval))
+        network->set_state(ParseState(stringval));
+    }
+    NotifyNetworkChanged(network);
+  }
+
   void UpdateCellularDataPlan(const CellularDataPlanList* data_plans) {
     DCHECK(cellular_);
     cellular_->SetDataPlans(data_plans);
     NotifyCellularDataPlanChanged();
   }
 
-  ObserverList<Observer> observers_;
+  void ClearNetworks() {
+    if (ethernet_)
+      delete ethernet_;
+    ethernet_ = NULL;
+    wifi_ = NULL;
+    cellular_ = NULL;
+    STLDeleteElements(&wifi_networks_);
+    wifi_networks_.clear();
+    STLDeleteElements(&cellular_networks_);
+    cellular_networks_.clear();
+    STLDeleteElements(&remembered_wifi_networks_);
+    remembered_wifi_networks_.clear();
+  }
+
+  // Network manager observer list
+  ObserverList<NetworkManagerObserver> network_manager_observers_;
 
-  // Property change observer map
-  PropertyChangeObserverMap  property_observers_;
+  // Cellular data plan observer list
+  ObserverList<CellularDataPlanObserver> data_plan_observers_;
 
-  // The network status connection for monitoring network status changes.
-  MonitorNetworkConnection network_status_connection_;
+  // Network observer map
+  NetworkObserverMap network_observers_;
+
+  // For monitoring network manager status changes.
+  PropertyChangeMonitor network_manager_monitor_;
 
   // For monitoring data plan changes to the connected cellular network.
   DataPlanUpdateMonitor data_plan_monitor_;
 
-  // The property change connection for monitoring service property changes.
-  std::map<std::string, PropertyChangeMonitor> property_change_monitors_;
-
   // The ethernet network.
   EthernetNetwork* ethernet_;
 
@@ -1341,11 +1569,17 @@ class NetworkLibraryStubImpl : public NetworkLibrary {
         cellular_(NULL) {
   }
   ~NetworkLibraryStubImpl() { if (ethernet_) delete ethernet_; }
-  virtual void AddObserver(Observer* observer) {}
-  virtual void RemoveObserver(Observer* observer) {}
-  virtual void AddProperyObserver(const char* service_path,
-                                  PropertyObserver* observer) {}
-  virtual void RemoveProperyObserver(PropertyObserver* observer) {}
+  virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {}
+  virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {}
+  virtual void AddNetworkObserver(const std::string& service_path,
+                                  NetworkObserver* observer) {}
+  virtual void RemoveNetworkObserver(const std::string& service_path,
+                                     NetworkObserver* observer) {}
+  virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {}
+  virtual void AddCellularDataPlanObserver(
+      CellularDataPlanObserver* observer) {}
+  virtual void RemoveCellularDataPlanObserver(
+      CellularDataPlanObserver* observer) {}
   virtual EthernetNetwork* ethernet_network() {
     return ethernet_;
   }
@@ -1410,6 +1644,7 @@ class NetworkLibraryStubImpl : public NetworkLibrary {
   virtual bool ethernet_enabled() const { return true; }
   virtual bool wifi_enabled() const { return false; }
   virtual bool cellular_enabled() const { return false; }
+  virtual const Network* active_network() const { return NULL; }
   virtual bool offline_mode() const { return false; }
   virtual void EnableEthernetNetworkDevice(bool enable) {}
   virtual void EnableWifiNetworkDevice(bool enable) {}
diff --git a/chrome/browser/chromeos/cros/network_library.h b/chrome/browser/chromeos/cros/network_library.h
index a54aba4..70ef38bc 100644
--- a/chrome/browser/chromeos/cros/network_library.h
+++ b/chrome/browser/chromeos/cros/network_library.h
@@ -48,13 +48,10 @@ class Network {
       state_ == STATE_IDLE; }
   ConnectionError error() const { return error_; }
   ConnectionState state() const { return state_; }
-
-  void set_service_path(const std::string& service_path) {
-      service_path_ = service_path; }
-  void set_connecting(bool connecting) { state_ = (connecting ?
-      STATE_ASSOCIATION : STATE_IDLE); }
-  void set_connected(bool connected) { state_ = (connected ?
-      STATE_READY : STATE_IDLE); }
+  // Is this the active network, i.e, the one through which
+  // network traffic is being routed? A network can be connected,
+  // but not be carrying traffic.
+  bool is_active() const { return is_active_; }
 
   // Clear the fields.
   virtual void Clear();
@@ -69,7 +66,8 @@ class Network {
   Network()
       : type_(TYPE_UNKNOWN),
         state_(STATE_UNKNOWN),
-        error_(ERROR_UNKNOWN) {}
+        error_(ERROR_UNKNOWN),
+        is_active_(false) {}
   explicit Network(const Network& network);
   explicit Network(const ServiceInfo* service);
   virtual ~Network() {}
@@ -80,6 +78,19 @@ class Network {
   ConnectionType type_;
   ConnectionState state_;
   ConnectionError error_;
+  bool is_active_;
+
+ private:
+  void set_service_path(const std::string& service_path) {
+      service_path_ = service_path; }
+  void set_connecting(bool connecting) { state_ = (connecting ?
+      STATE_ASSOCIATION : STATE_IDLE); }
+  void set_connected(bool connected) { state_ = (connected ?
+      STATE_READY : STATE_IDLE); }
+  void set_state(ConnectionState state) { state_ = state; }
+  void set_active(bool is_active) { is_active_ = is_active; }
+
+  friend class NetworkLibraryImpl;
 };
 
 class EthernetNetwork : public Network {
@@ -119,8 +130,6 @@ class WirelessNetwork : public Network {
   bool auto_connect() const { return auto_connect_; }
   bool favorite() const { return favorite_; }
 
-  void set_name(const std::string& name) { name_ = name; }
-  void set_strength(int strength) { strength_ = strength; }
   void set_auto_connect(bool auto_connect) { auto_connect_ = auto_connect; }
   void set_favorite(bool favorite) { favorite_ = favorite; }
 
@@ -140,6 +149,12 @@ class WirelessNetwork : public Network {
   int strength_;
   bool auto_connect_;
   bool favorite_;
+
+ private:
+  void set_name(const std::string& name) { name_ = name; }
+  void set_strength(int strength) { strength_ = strength; }
+
+  friend class NetworkLibraryImpl;
 };
 
 class CellularDataPlan {
@@ -185,9 +200,6 @@ class CellularNetwork : public WirelessNetwork {
   // Starts device activation process. Returns false if the device state does
   // not permit activation.
   bool StartActivation() const;
-  void set_activation_state(ActivationState state) {
-    activation_state_ = state;
-  }
   const ActivationState activation_state() const { return activation_state_; }
   const NetworkTechnology network_technology() const {
     return network_technology_;
@@ -198,9 +210,6 @@ class CellularNetwork : public WirelessNetwork {
   const std::string& operator_name() const { return operator_name_; }
   const std::string& operator_code() const { return operator_code_; }
   const std::string& payment_url() const { return payment_url_; }
-  void set_payment_url(const std::string& url) {
-    payment_url_ = url;
-  }
   const std::string& meid() const { return meid_; }
   const std::string& imei() const { return imei_; }
   const std::string& imsi() const { return imsi_; }
@@ -265,6 +274,25 @@ class CellularNetwork : public WirelessNetwork {
   std::string last_update_;
   unsigned int prl_version_;
   CellularDataPlanVector data_plans_;
+
+ private:
+  void set_activation_state(ActivationState state) {
+    activation_state_ = state;
+  }
+  void set_payment_url(const std::string& url) {
+    payment_url_ = url;
+  }
+  void set_network_technology(NetworkTechnology technology) {
+    network_technology_ = technology;
+  }
+  void set_roaming_state(NetworkRoamingState state) {
+    roaming_state_ = state;
+  }
+  void set_restricted_pool(bool restricted_pool) {
+    restricted_pool_ = restricted_pool;
+  }
+
+  friend class NetworkLibraryImpl;
 };
 
 class WifiNetwork : public WirelessNetwork {
@@ -370,27 +398,47 @@ typedef std::vector<NetworkIPConfig> NetworkIPConfigVector;
 // library like this: chromeos::CrosLibrary::Get()->GetNetworkLibrary()
 class NetworkLibrary {
  public:
-  class Observer {
+  class NetworkManagerObserver {
    public:
-    // Called when the network has changed. (wifi networks, and ethernet)
-    virtual void NetworkChanged(NetworkLibrary* obj) = 0;
-    // Called when the cellular data plan has changed.
-    virtual void CellularDataPlanChanged(NetworkLibrary* obj) {}
+    // Called when the state of the network manager has changed,
+    // for example, networks have appeared or disappeared.
+    virtual void OnNetworkManagerChanged(NetworkLibrary* obj) = 0;
   };
 
-  class PropertyObserver {
+  class NetworkObserver {
    public:
-    virtual void PropertyChanged(const char* service_path,
-                                 const char* key,
-                                 const Value* value) = 0;
+    // Called when the state of a single network has changed,
+    // for example signal strength or connection state.
+    virtual void OnNetworkChanged(NetworkLibrary* cros,
+                                  const Network* network) = 0;
+  };
+
+  class CellularDataPlanObserver {
+   public:
+    // Called when the cellular data plan has changed.
+    virtual void OnCellularDataPlanChanged(NetworkLibrary* obj) = 0;
   };
 
   virtual ~NetworkLibrary() {}
-  virtual void AddObserver(Observer* observer) = 0;
-  virtual void RemoveObserver(Observer* observer) = 0;
-  virtual void AddProperyObserver(const char* service_path,
-                                  PropertyObserver* observer) = 0;
-  virtual void RemoveProperyObserver(PropertyObserver* observer) = 0;
+
+  virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) = 0;
+  virtual void RemoveNetworkManagerObserver(
+      NetworkManagerObserver* observer) = 0;
+
+  // An attempt to add an observer that has already been added for a
+  // give service path will be ignored.
+  virtual void AddNetworkObserver(const std::string& service_path,
+                                  NetworkObserver* observer) = 0;
+  // Remove an observer of a single network
+  virtual void RemoveNetworkObserver(const std::string& service_path,
+                                     NetworkObserver* observer) = 0;
+  // Stop |observer| from observing any networks
+  virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) = 0;
+
+  virtual void AddCellularDataPlanObserver(
+      CellularDataPlanObserver* observer) = 0;
+  virtual void RemoveCellularDataPlanObserver(
+      CellularDataPlanObserver* observer) = 0;
 
   // Return the active Ethernet network (or a default structure if inactive).
   virtual EthernetNetwork* ethernet_network() = 0;
@@ -488,6 +536,8 @@ class NetworkLibrary {
   virtual bool wifi_enabled() const = 0;
   virtual bool cellular_enabled() const = 0;
 
+  virtual const Network* active_network() const = 0;
+
   virtual bool offline_mode() const = 0;
 
   // Enables/disables the ethernet network device.