Push for ers:...

chrome/browser/chromeos/cros/network_library.cc

 // Copyright (c) 2010 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.
 
 #include "chrome/browser/chromeos/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 
 #include "app/l10n_util.h"
 #include "base/stl_util-inl.h"
 #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>";
 }
 
 // Helper function to wrap Html with <td> tag.
 static std::string WrapWithTD(std::string text) {
   return "<td>" + text + "</td>";
 }
 
@@ skipping 61 matching lines @@
   state_ = network.state();
   error_ = network.error();
 }
 
 void Network::Clear() {
   state_ = STATE_UNKNOWN;
   error_ = ERROR_UNKNOWN;
   service_path_.clear();
   device_path_.clear();
   ip_address_.clear();
+  is_active_ = false;
 }
 
 Network::Network(const ServiceInfo* service) {
   type_ = service->type;
   state_ = service->state;
   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) {
     IPConfigStatus* ipconfig_status = ListIPConfigs(service->device_path);
     if (ipconfig_status) {
       for (int i = 0; i < ipconfig_status->size; i++) {
         IPConfig ipconfig = ipconfig_status->ips[i];
         if (strlen(ipconfig.address) > 0)
           ip_address_ = ipconfig.address;
       }
@@ skipping 383 matching lines @@
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary
 
 class NetworkLibraryImpl : public NetworkLibrary  {
  public:
   NetworkLibraryImpl()
-      : network_status_connection_(NULL),
+      : network_manager_monitor_(NULL),
         data_plan_monitor_(NULL),
         ethernet_(NULL),
         wifi_(NULL),
         cellular_(NULL),
         available_devices_(0),
         enabled_devices_(0),
         connected_devices_(0),
         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_) {
-      DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
-    }
-    // DCHECK(!observers_.size());
-    DCHECK(!property_observers_.size());
-    STLDeleteValues(&property_observers_);
+    DCHECK(!network_manager_observers_.size());
+    DCHECK(network_manager_monitor_);
+    DisconnectPropertyChangeMonitor(network_manager_monitor_);
+    DCHECK(!data_plan_observers_.size());
+    DCHECK(data_plan_monitor_);
+    DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
+    DCHECK(!network_observers_.size());
+    STLDeleteValues(&network_observers_);
     ClearNetworks();
   }
 
-  void AddObserver(Observer* observer) {
-    observers_.AddObserver(observer);
+  virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {
+    network_manager_observers_.AddObserver(observer);
   }
 
-  void RemoveObserver(Observer* observer) {
-    observers_.RemoveObserver(observer);
+  virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {
+    if (!network_manager_observers_.HasObserver(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 RemoveNetworkObserver(const std::string& service_path,
+                                     NetworkObserver* observer) {
+    DCHECK(observer);
+    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;
+        network_observers_.erase(map_iter++);
+      }
     }
   }
 
-  virtual void RemoveProperyObserver(PropertyObserver* observer) {
+  virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {
     DCHECK(observer);
-    PropertyChangeObserverMap::iterator map_iter =
-          property_observers_.begin();
-    while (map_iter != property_observers_.end()) {
+    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;
-        property_observers_.erase(map_iter++);
+        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;
   }
   virtual bool ethernet_connected() const {
     return ethernet_ ? ethernet_->connected() : false;
   }
 
   virtual WifiNetwork* wifi_network() { return wifi_; }
   virtual bool wifi_connecting() const {
@@ skipping 13 matching lines @@
 
   bool Connected() const {
     return ethernet_connected() || wifi_connected() || cellular_connected();
   }
 
   bool Connecting() const {
     return ethernet_connecting() || wifi_connecting() || cellular_connecting();
   }
 
   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 {
     return wifi_networks_;
   }
 
   virtual const WifiNetworkVector& remembered_wifi_networks() const {
     return remembered_wifi_networks_;
   }
 
@@ skipping 44 matching lines @@
     return true;
   }
 
   virtual void ConnectToWifiNetwork(const WifiNetwork* network,
                                     const std::string& password,
                                     const std::string& identity,
                                     const std::string& certpath) {
     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(),
         certpath.empty() ? NULL : certpath.c_str())) {
       // Update local cache and notify listeners.
       WifiNetwork* wifi = GetWirelessNetworkByPath(
           wifi_networks_, network->service_path());
       if (wifi) {
         wifi->set_passphrase(password);
         wifi->set_identity(identity);
         wifi->set_cert_path(certpath);
         wifi->set_connecting(true);
         wifi_ = wifi;
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
   virtual void ConnectToWifiNetwork(ConnectionSecurity security,
                                     const std::string& ssid,
                                     const std::string& password,
                                     const std::string& identity,
                                     const std::string& certpath,
                                     bool auto_connect) {
     if (!EnsureCrosLoaded())
       return;
 
     // First create a service from hidden network.
     ServiceInfo* service = GetWifiService(ssid.c_str(), security);
     if (service) {
       // 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(),
           certpath.empty() ? NULL : certpath.c_str());
 
       // Clean up ServiceInfo object.
       FreeServiceInfo(service);
     } else {
       LOG(WARNING) << "Cannot find hidden network: " << ssid;
       // TODO(chocobo): Show error message.
     }
   }
 
   virtual void ConnectToCellularNetwork(const CellularNetwork* network) {
     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(
           cellular_networks_, network->service_path());
       if (cellular) {
         cellular->set_connecting(true);
         cellular_ = cellular;
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
   virtual void RefreshCellularDataPlans(const CellularNetwork* network) {
     DCHECK(network);
     if (!EnsureCrosLoaded() || !network)
       return;
     RequestCellularDataPlanUpdate(network->service_path().c_str());
   }
 
   virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {
     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) {
         WifiNetwork* wifi = GetWirelessNetworkByPath(
             wifi_networks_, network->service_path());
         if (wifi) {
           wifi->set_connected(false);
           wifi_ = NULL;
         }
       } else if (network->type() == TYPE_CELLULAR) {
         CellularNetwork* cellular = GetWirelessNetworkByPath(
             cellular_networks_, network->service_path());
         if (cellular) {
           cellular->set_connected(false);
           cellular_ = NULL;
         }
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
   virtual void SaveCellularNetwork(const CellularNetwork* network) {
     DCHECK(network);
     // Update the cellular network with libcros.
     if (!EnsureCrosLoaded() || !network)
       return;
 
     SetAutoConnect(network->service_path().c_str(), network->auto_connect());
@@ skipping 21 matching lines @@
       for (WifiNetworkVector::iterator iter =
                remembered_wifi_networks_.begin();
           iter != remembered_wifi_networks_.end();
           ++iter) {
         if ((*iter)->service_path() == service_path) {
           delete (*iter);
           remembered_wifi_networks_.erase(iter);
           break;
         }
       }
-      NotifyNetworkChanged();
+      NotifyNetworkManagerChanged();
     }
   }
 
   virtual bool ethernet_available() const {
     return available_devices_ & (1 << TYPE_ETHERNET);
   }
   virtual bool wifi_available() const {
     return available_devices_ & (1 << TYPE_WIFI);
   }
   virtual bool cellular_available() const {
     return available_devices_ & (1 << TYPE_CELLULAR);
   }
 
   virtual bool ethernet_enabled() const {
     return enabled_devices_ & (1 << TYPE_ETHERNET);
   }
   virtual bool wifi_enabled() const {
     return enabled_devices_ & (1 << TYPE_WIFI);
   }
   virtual bool cellular_enabled() const {
     return enabled_devices_ & (1 << TYPE_CELLULAR);
   }
 
   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);
   }
 
   virtual void EnableWifiNetworkDevice(bool enable) {
     EnableNetworkDeviceType(TYPE_WIFI, enable);
   }
 
   virtual void EnableCellularNetworkDevice(bool enable) {
     EnableNetworkDeviceType(TYPE_CELLULAR, enable);
@@ skipping 85 matching lines @@
       output.append("<tr>" + ToHtmlTableRow(remembered_wifi_networks_[i]) +
           "</tr>");
     }
 
     output.append("</table></body></html>");
     return output;
   }
 
  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);
       }
     }
   }
 
   static void ParseSystem(SystemInfo* system,
       EthernetNetwork** ethernet,
       WifiNetworkVector* wifi_networks,
       CellularNetworkVector* cellular_networks,
       WifiNetworkVector* remembered_wifi_networks) {
     DVLOG(1) << "ParseSystem:";
     DCHECK(!(*ethernet));
     for (int i = 0; i < system->service_size; i++) {
       const ServiceInfo* service = system->GetServiceInfo(i);
       DVLOG(1) << "  (" << service->type << ") " << service->name
                << " mode=" << service->mode
                << " state=" << service->state
                << " sec=" << service->security
                << " req=" << service->passphrase_required
                << " pass=" << service->passphrase
                << " id=" << service->identity
                << " certpath=" << service->cert_path
                << " 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
       if (service->type == TYPE_ETHERNET)
         (*ethernet) = new EthernetNetwork(service);
       else if (service->type == TYPE_WIFI) {
         wifi_networks->push_back(new WifiNetwork(service));
       } else if (service->type == TYPE_CELLULAR) {
         cellular_networks->push_back(new CellularNetwork(service));
       }
@@ skipping 19 matching lines @@
                  << " certpath=" << service->cert_path
                  << " auto=" << service->auto_connect;
         if (service->type == TYPE_WIFI) {
           remembered_wifi_networks->push_back(new WifiNetwork(service));
         }
       }
     }
   }
 
   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() {
     ethernet_ = new EthernetNetwork();
     ethernet_->set_connected(true);
     ethernet_->set_service_path("eth1");
 
     STLDeleteElements(&wifi_networks_);
     wifi_networks_.clear();
     WifiNetwork* wifi1 = new WifiNetwork();
@@ skipping 58 matching lines @@
     test_plan.plan_type = CELLULAR_DATA_PLAN_METERED_PAID;
     test_plan.update_time = base::Time::Now().ToInternalValue() /
         base::Time::kMicrosecondsPerSecond;
     chromeos::CellularDataPlanList test_plans;
     test_plans.push_back(test_plan);
     cellular_->SetDataPlans(test_plans);
   }
 
   void UpdateSystemInfo() {
     if (EnsureCrosLoaded()) {
-      UpdateNetworkStatus();
+      UpdateNetworkManagerStatus();
     }
   }
 
   WifiNetwork* GetWifiNetworkByName(const std::string& name) {
     for (size_t i = 0; i < wifi_networks_.size(); ++i) {
       if (wifi_networks_[i]->name().compare(name) == 0) {
         return wifi_networks_[i];
       }
     }
     return NULL;
@@ skipping 28 matching lines @@
     }
     if (!enable && !(enabled_devices_ & (1 << device))) {
       LOG(WARNING) << "Trying to disable a device that's already disabled: "
                    << device;
       return;
     }
 
     EnableNetworkDevice(device, enable);
   }
 
-  void NotifyNetworkChanged() {
-    FOR_EACH_OBSERVER(Observer, observers_, NetworkChanged(this));
+  void NotifyNetworkManagerChanged() {
+    FOR_EACH_OBSERVER(NetworkManagerObserver,
+                      network_manager_observers_,
+                      OnNetworkManagerChanged(this));
+  }
+
+  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 " <<
+           network->service_path();
+    }
   }
 
   void NotifyCellularDataPlanChanged() {
-    FOR_EACH_OBSERVER(Observer, observers_, CellularDataPlanChanged(this));
+    FOR_EACH_OBSERVER(CellularDataPlanObserver,
+                      data_plan_observers_,
+                      OnCellularDataPlanChanged(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));
-    } else {
-      NOTREACHED() <<
-          "There weren't supposed to be any property change observers of " <<
-          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 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;
     }
 
     SystemInfo* system = GetSystemInfo();
     if (!system)
       return;
 
 
     std::string prev_cellular_service_path = cellular_ ?
         cellular_->service_path() : std::string();
@@ skipping 23 matching lines @@
         }
         break;  // There is only one connected or connecting cellular network.
       }
     }
 
     available_devices_ = system->available_technologies;
     enabled_devices_ = system->enabled_technologies;
     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();
+  }
 
-  // Property change observer map
-  PropertyChangeObserverMap  property_observers_;
+  // Network manager observer list
+  ObserverList<NetworkManagerObserver> network_manager_observers_;
 
-  // The network status connection for monitoring network status changes.
-  MonitorNetworkConnection network_status_connection_;
+  // Cellular data plan observer list
+  ObserverList<CellularDataPlanObserver> data_plan_observers_;
+
+  // 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_;
 
   // The list of available wifi networks.
   WifiNetworkVector wifi_networks_;
 
   // The current connected (or connecting) wifi network.
   WifiNetwork* wifi_;
 
   // The remembered wifi networks.
@@ skipping 21 matching lines @@
 
 class NetworkLibraryStubImpl : public NetworkLibrary {
  public:
   NetworkLibraryStubImpl()
       : ip_address_("1.1.1.1"),
         ethernet_(new EthernetNetwork()),
         wifi_(NULL),
         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_;
   }
   virtual bool ethernet_connecting() const { return false; }
   virtual bool ethernet_connected() const { return true; }
   virtual WifiNetwork* wifi_network() {
     return wifi_;
   }
   virtual bool wifi_connecting() const { return false; }
   virtual bool wifi_connected() const { return false; }
@@ skipping 44 matching lines @@
   virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {}
   virtual void SaveCellularNetwork(const CellularNetwork* network) {}
   virtual void SaveWifiNetwork(const WifiNetwork* network) {}
   virtual void ForgetWifiNetwork(const std::string& service_path) {}
   virtual bool ethernet_available() const { return true; }
   virtual bool wifi_available() const { return false; }
   virtual bool cellular_available() const { return false; }
   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) {}
   virtual void EnableCellularNetworkDevice(bool enable) {}
   virtual void EnableOfflineMode(bool enable) {}
   virtual NetworkIPConfigVector GetIPConfigs(const std::string& device_path,
                                              std::string* hardware_address) {
     hardware_address->clear();
     return NetworkIPConfigVector();
   }
@@ skipping 15 matching lines @@
     return new NetworkLibraryStubImpl();
   else
     return new NetworkLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);