1 files changed, 172 insertions, 60 deletions

diff --git a/chrome/browser/chromeos/cros/network_library.h b/chrome/browser/chromeos/cros/network_library.h
index 5426da1..8296660 100644
--- a/chrome/browser/chromeos/cros/network_library.h
+++ b/chrome/browser/chromeos/cros/network_library.h
@@ -15,6 +15,8 @@
 #include "base/timer.h"
 #include "cros/chromeos_network.h"
 
+class Value;
+
 namespace chromeos {
 
 // Cellular network is considered low data when less than 60 minues.
@@ -38,25 +40,22 @@ class Network {
   ConnectionState connection_state() const { return state_; }
   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();
 
-  // Configure the Network from a ServiceInfo object.
-  virtual void ConfigureFromService(const ServiceInfo& service);
-
   // Return a string representation of the state code.
   std::string GetStateString() const;
 
@@ -67,7 +66,10 @@ 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() {}
 
   std::string service_path_;
@@ -76,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 {
@@ -83,6 +98,15 @@ class EthernetNetwork : public Network {
   EthernetNetwork() : Network() {
     type_ = TYPE_ETHERNET;
   }
+
+  explicit EthernetNetwork(const EthernetNetwork& network)
+      : Network(network) {
+    type_ = TYPE_ETHERNET;
+  }
+
+  explicit EthernetNetwork(const ServiceInfo* service) : Network(service) {
+    type_ = TYPE_ETHERNET;
+  }
 };
 
 class WirelessNetwork : public Network {
@@ -95,8 +119,8 @@ class WirelessNetwork : public Network {
   // We frequently want to compare networks by service path.
   struct ServicePathEq {
     explicit ServicePathEq(const std::string& path_in) : path(path_in) {}
-    bool operator()(const WirelessNetwork& a) {
-      return a.service_path().compare(path) == 0;
+    bool operator()(const WirelessNetwork* a) {
+      return a->service_path().compare(path) == 0;
     }
     const std::string& path;
   };
@@ -106,14 +130,11 @@ 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; }
 
   // Network overrides.
   virtual void Clear();
-  virtual void ConfigureFromService(const ServiceInfo& service);
 
  protected:
   WirelessNetwork()
@@ -121,13 +142,48 @@ class WirelessNetwork : public Network {
         strength_(0),
         auto_connect_(false),
         favorite_(false) {}
-
+  explicit WirelessNetwork(const WirelessNetwork& network);
+  explicit WirelessNetwork(const ServiceInfo* service);
+  virtual ~WirelessNetwork() {}
   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 CellularDataPlan {
+ public:
+  CellularDataPlan() :
+      plan_name("Unknown"),
+      plan_type(CELLULAR_DATA_PLAN_UNLIMITED),
+      plan_data_bytes(0),
+      data_bytes_used(0) { }
+  explicit CellularDataPlan(const CellularDataPlanInfo &plan) :
+      plan_name(plan.plan_name?plan.plan_name:""),
+      plan_type(plan.plan_type),
+      update_time(base::Time::FromInternalValue(plan.update_time)),
+      plan_start_time(base::Time::FromInternalValue(plan.plan_start_time)),
+      plan_end_time(base::Time::FromInternalValue(plan.plan_end_time)),
+      plan_data_bytes(plan.plan_data_bytes),
+      data_bytes_used(plan.data_bytes_used) { }
+
+  std::string plan_name;
+  CellularDataPlanType plan_type;
+  base::Time update_time;
+  base::Time plan_start_time;
+  base::Time plan_end_time;
+  int64 plan_data_bytes;
+  int64 data_bytes_used;
 };
 
+typedef std::vector<CellularDataPlan> CellularDataPlanVector;
+
 class CellularNetwork : public WirelessNetwork {
  public:
   enum DataLeft {
@@ -138,11 +194,9 @@ class CellularNetwork : public WirelessNetwork {
   };
 
   CellularNetwork();
-  explicit CellularNetwork(const ServiceInfo& service)
-      : WirelessNetwork() {
-    ConfigureFromService(service);
-  }
-
+  explicit CellularNetwork(const CellularNetwork& network);
+  explicit CellularNetwork(const ServiceInfo* service);
+  virtual ~CellularNetwork();
   // Starts device activation process. Returns false if the device state does
   // not permit activation.
   bool StartActivation() const;
@@ -173,14 +227,17 @@ class CellularNetwork : public WirelessNetwork {
 
   // WirelessNetwork overrides.
   virtual void Clear();
-  virtual void ConfigureFromService(const ServiceInfo& service);
 
-  const CellularDataPlanList& GetDataPlans() const {
+  const CellularDataPlanVector& GetDataPlans() const {
     return data_plans_;
   }
 
-  void SetDataPlans(const CellularDataPlanList& data_plans) {
-    data_plans_ = data_plans;
+  void SetDataPlans(const CellularDataPlanList* data_plan_list) {
+    data_plans_.clear();
+    for (size_t i = 0; i < data_plan_list->plans_size; i++) {
+      const CellularDataPlanInfo* info(data_plan_list->GetCellularDataPlan(i));
+      data_plans_.push_back(CellularDataPlan(*info));
+    }
   }
   // Return a string representation of network technology.
   std::string GetNetworkTechnologyString() const;
@@ -189,7 +246,11 @@ class CellularNetwork : public WirelessNetwork {
   // Return a string representation of roaming state.
   std::string GetRoamingStateString() const;
 
+  // Return a string representation of |activation_state|.
+  static std::string ActivationStateToString(ActivationState activation_state);
+
  protected:
+
   ActivationState activation_state_;
   NetworkTechnology network_technology_;
   NetworkRoamingState roaming_state_;
@@ -212,17 +273,38 @@ class CellularNetwork : public WirelessNetwork {
   std::string hardware_revision_;
   std::string last_update_;
   unsigned int prl_version_;
-  CellularDataPlanList data_plans_;
+  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 {
  public:
   WifiNetwork();
-  explicit WifiNetwork(const ServiceInfo& service);
+  explicit WifiNetwork(const WifiNetwork& network);
+  explicit WifiNetwork(const ServiceInfo* service);
 
   bool encrypted() const { return encryption_ != SECURITY_NONE; }
   ConnectionSecurity encryption() const { return encryption_; }
   const std::string& passphrase() const { return passphrase_; }
+  bool passphrase_required() const { return passphrase_required_; }
   const std::string& identity() const { return identity_; }
   const std::string& cert_path() const { return cert_path_; }
 
@@ -241,7 +323,6 @@ class WifiNetwork : public WirelessNetwork {
 
   // WirelessNetwork overrides.
   virtual void Clear();
-  virtual void ConfigureFromService(const ServiceInfo& service);
 
   // Return a string representation of the encryption code.
   // This not translated and should be only used for debugging purposes.
@@ -253,12 +334,13 @@ class WifiNetwork : public WirelessNetwork {
  protected:
   ConnectionSecurity encryption_;
   std::string passphrase_;
+  bool passphrase_required_;
   std::string identity_;
   std::string cert_path_;
 };
 
-typedef std::vector<WifiNetwork> WifiNetworkVector;
-typedef std::vector<CellularNetwork> CellularNetworkVector;
+typedef std::vector<chromeos::WifiNetwork*> WifiNetworkVector;
+typedef std::vector<chromeos::CellularNetwork*> CellularNetworkVector;
 
 struct CellTower {
   enum RadioType {
@@ -318,30 +400,60 @@ typedef std::vector<NetworkIPConfig> NetworkIPConfigVector;
 // library like this: chromeos::CrosLibrary::Get()->GetNetworkLibrary()
 class NetworkLibrary {
  public:
-  class Observer {
+  class NetworkManagerObserver {
+   public:
+    // Called when the state of the network manager has changed,
+    // for example, networks have appeared or disappeared.
+    virtual void OnNetworkManagerChanged(NetworkLibrary* obj) = 0;
+  };
+
+  class NetworkObserver {
+   public:
+    // 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 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) {}
+    virtual void OnCellularDataPlanChanged(NetworkLibrary* obj) = 0;
   };
 
   virtual ~NetworkLibrary() {}
-  virtual void AddObserver(Observer* observer) = 0;
-  virtual void RemoveObserver(Observer* 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 const EthernetNetwork& ethernet_network() const = 0;
+  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 const WifiNetwork& wifi_network() const = 0;
+  virtual WifiNetwork* wifi_network() = 0;
   virtual bool wifi_connecting() const = 0;
   virtual bool wifi_connected() const = 0;
 
   // Return the active Cellular network (or a default structure if none active).
-  virtual const CellularNetwork& cellular_network() const = 0;
+  virtual CellularNetwork* cellular_network() = 0;
   virtual bool cellular_connecting() const = 0;
   virtual bool cellular_connected() const = 0;
 
@@ -363,15 +475,12 @@ class NetworkLibrary {
   // Returns the current list of cellular networks.
   virtual const CellularNetworkVector& cellular_networks() const = 0;
 
-  // Returns the list of remembered cellular networks.
-  virtual const CellularNetworkVector& remembered_cellular_networks() const = 0;
-
   // Search the current list of networks by path and if the network
   // is available, copy the result and return true.
-  virtual bool FindWifiNetworkByPath(const std::string& path,
-                                     WifiNetwork* result) const = 0;
-  virtual bool FindCellularNetworkByPath(const std::string& path,
-                                         CellularNetwork* result) const = 0;
+  virtual WifiNetwork* FindWifiNetworkByPath(const std::string& path) = 0;
+  virtual CellularNetwork* FindCellularNetworkByPath(
+      const std::string& path) = 0;
+
 
   // Request a scan for new wifi networks.
   virtual void RequestWifiScan() = 0;
@@ -386,39 +495,40 @@ class NetworkLibrary {
 
   // TODO(joth): Add GetCellTowers to retrieve a CellTowerVector.
 
-  // Force an update of the system info.
-  virtual void UpdateSystemInfo() = 0;
-
   // Connect to the specified wireless network with password.
-  virtual void ConnectToWifiNetwork(WifiNetwork network,
+  // Returns false if the attempt fails immediately (e.g. passphrase too short).
+  virtual bool ConnectToWifiNetwork(const WifiNetwork* network,
                                     const std::string& password,
                                     const std::string& identity,
                                     const std::string& certpath) = 0;
 
-  // Connect to the specified wifi ssid with password.
-  virtual void ConnectToWifiNetwork(const std::string& ssid,
+  // Connect to the specified network with security, ssid, and password.
+  // Returns false if the attempt fails immediately (e.g. passphrase too short).
+  virtual bool ConnectToWifiNetwork(ConnectionSecurity security,
+                                    const std::string& ssid,
                                     const std::string& password,
                                     const std::string& identity,
                                     const std::string& certpath,
                                     bool auto_connect) = 0;
 
   // Connect to the specified cellular network.
-  virtual void ConnectToCellularNetwork(CellularNetwork network) = 0;
+  // Returns false if the attempt fails immediately.
+  virtual bool ConnectToCellularNetwork(const CellularNetwork* network) = 0;
 
   // Initiates cellular data plan refresh. Plan data will be passed through
   // Network::Observer::CellularDataPlanChanged callback.
-  virtual void RefreshCellularDataPlans(const CellularNetwork& network) = 0;
+  virtual void RefreshCellularDataPlans(const CellularNetwork* network) = 0;
 
   // Disconnect from the specified wireless (either cellular or wifi) network.
   virtual void DisconnectFromWirelessNetwork(
-      const WirelessNetwork& network) = 0;
+      const WirelessNetwork* network) = 0;
 
   // Save network information including passwords (wifi) and auto-connect.
-  virtual void SaveCellularNetwork(const CellularNetwork& network) = 0;
-  virtual void SaveWifiNetwork(const WifiNetwork& network) = 0;
+  virtual void SaveCellularNetwork(const CellularNetwork* network) = 0;
+  virtual void SaveWifiNetwork(const WifiNetwork* network) = 0;
 
-  // Forget the passed in wireless (either cellular or wifi) network.
-  virtual void ForgetWirelessNetwork(const std::string& service_path) = 0;
+  // Forget the wifi network corresponding to service_path.
+  virtual void ForgetWifiNetwork(const std::string& service_path) = 0;
 
   virtual bool ethernet_available() const = 0;
   virtual bool wifi_available() const = 0;
@@ -428,6 +538,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.