Push for ers:...

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 30 matching lines @@
   bool connecting() const { return state_ == STATE_ASSOCIATION ||
       state_ == STATE_CONFIGURATION || state_ == STATE_CARRIER; }
   bool configuring() const { return state_ == STATE_CONFIGURATION; }
   bool connected() const { return state_ == STATE_READY; }
   bool connecting_or_connected() const { return connecting() || connected(); }
   bool failed() const { return state_ == STATE_FAILURE; }
   bool failed_or_disconnected() const { return failed() ||
       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();
 
   // Return a string representation of the state code.
   std::string GetStateString() const;
 
   // Return a string representation of the error code.
   std::string GetErrorString() const;
 
  protected:
   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() {}
 
   std::string service_path_;
   std::string device_path_;
   std::string ip_address_;
   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 {
  public:
   EthernetNetwork() : Network() {
     type_ = TYPE_ETHERNET;
   }
 
   explicit EthernetNetwork(const EthernetNetwork& network)
       : Network(network) {
@@ skipping 19 matching lines @@
       return a->service_path().compare(path) == 0;
     }
     const std::string& path;
   };
 
   const std::string& name() const { return name_; }
   int strength() const { return strength_; }
   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; }
 
   // Network overrides.
   virtual void Clear();
 
  protected:
   WirelessNetwork()
       : Network(),
         strength_(0),
         auto_connect_(false),
         favorite_(false) {}
   explicit WirelessNetwork(const WirelessNetwork& network);
   explicit WirelessNetwork(const ServiceInfo* service);
 
   std::string name_;
   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 CellularNetwork : public WirelessNetwork {
  public:
   enum DataLeft {
     DATA_NORMAL,
     DATA_LOW,
     DATA_VERY_LOW,
     DATA_NONE
   };
 
   CellularNetwork();
   explicit CellularNetwork(const CellularNetwork& network);
   explicit CellularNetwork(const ServiceInfo* service);
 
   // 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_;
   }
   const NetworkRoamingState roaming_state() const { return roaming_state_; }
   bool restricted_pool() const { return restricted_pool_; }
   const std::string& service_name() const { return service_name_; }
   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_; }
   const std::string& esn() const { return esn_; }
   const std::string& mdn() const { return mdn_; }
   const std::string& min() const { return min_; }
   const std::string& model_id() const { return model_id_; }
   const std::string& manufacturer() const { return manufacturer_; }
   const std::string& firmware_revision() const { return firmware_revision_; }
   const std::string& hardware_revision() const { return hardware_revision_; }
@@ skipping 40 matching lines @@
   std::string esn_;
   std::string mdn_;
   std::string min_;
   std::string model_id_;
   std::string manufacturer_;
   std::string firmware_revision_;
   std::string hardware_revision_;
   std::string last_update_;
   unsigned int prl_version_;
   CellularDataPlanList 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 {
  public:
   WifiNetwork();
   explicit WifiNetwork(const WifiNetwork& network);
   explicit WifiNetwork(const ServiceInfo* service);
 
   bool encrypted() const { return encryption_ != SECURITY_NONE; }
   ConnectionSecurity encryption() const { return encryption_; }
@@ skipping 85 matching lines @@
   std::string gateway;
   std::string name_servers;
 };
 typedef std::vector<NetworkIPConfig> NetworkIPConfigVector;
 
 // This class handles the interaction with the ChromeOS network library APIs.
 // Classes can add themselves as observers. Users can get an instance of the
 // 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;
   virtual bool ethernet_connecting() const = 0;
   virtual bool ethernet_connected() const = 0;
 
   // Return the active Wifi network (or a default structure if none active).
   virtual WifiNetwork* wifi_network() = 0;
   virtual bool wifi_connecting() const = 0;
   virtual bool wifi_connected() const = 0;
@@ skipping 77 matching lines @@
   virtual void ForgetWifiNetwork(const std::string& service_path) = 0;
 
   virtual bool ethernet_available() const = 0;
   virtual bool wifi_available() const = 0;
   virtual bool cellular_available() const = 0;
 
   virtual bool ethernet_enabled() const = 0;
   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.
   virtual void EnableEthernetNetworkDevice(bool enable) = 0;
 
   // Enables/disables the wifi network device.
   virtual void EnableWifiNetworkDevice(bool enable) = 0;
 
   // Enables/disables the cellular network device.
   virtual void EnableCellularNetworkDevice(bool enable) = 0;
@@ skipping 14 matching lines @@
   virtual std::string GetHtmlInfo(int refresh) = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_