Rewritten parts of NetworkLibrary to work around memory corruption that prev...

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 41 matching lines @@
   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); }
 
   // 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;
 
   // Return a string representation of the error code.
   std::string GetErrorString() const;
 
  protected:
   Network()
       : type_(TYPE_UNKNOWN),
         state_(STATE_UNKNOWN),
         error_(ERROR_UNKNOWN) {}
+  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_;
 };
 
 class EthernetNetwork : public Network {
  public:
   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 {
  public:
   // WirelessNetwork are sorted by name.
   bool operator< (const WirelessNetwork& other) const {
     return name_ < other.name();
   }
 
   // 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;
   };
 
   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();
-  virtual void ConfigureFromService(const ServiceInfo& service);
 
  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_;
 };
 
 class CellularNetwork : public WirelessNetwork {
  public:
   enum DataLeft {
     DATA_NORMAL,
     DATA_LOW,
     DATA_VERY_LOW,
     DATA_NONE
   };
 
   CellularNetwork();
-  explicit CellularNetwork(const ServiceInfo& service)
-      : WirelessNetwork() {
-    ConfigureFromService(service);
-  }
+  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_;
@@ skipping 17 matching lines @@
   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_; }
   const std::string& last_update() const { return last_update_; }
   const unsigned int prl_version() const { return prl_version_; }
   bool is_gsm() const;
   DataLeft data_left() const;
 
   // WirelessNetwork overrides.
   virtual void Clear();
-  virtual void ConfigureFromService(const ServiceInfo& service);
 
   const CellularDataPlanList& GetDataPlans() const {
     return data_plans_;
   }
 
   void SetDataPlans(const CellularDataPlanList& data_plans) {
     data_plans_ = data_plans;
   }
   // Return a string representation of network technology.
   std::string GetNetworkTechnologyString() const;
   // Return a string representation of activation state.
   std::string GetActivationStateString() const;
   // 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_;
   bool restricted_pool_;
   std::string service_name_;
   // Carrier Info
   std::string operator_name_;
   std::string operator_code_;
   std::string payment_url_;
   // Device Info
   std::string meid_;
   std::string imei_;
   std::string imsi_;
   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_;
 };
 
 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_; }
   const std::string& identity() const { return identity_; }
   const std::string& cert_path() const { return cert_path_; }
 
   void set_encryption(ConnectionSecurity encryption) {
     encryption_ = encryption;
   }
   void set_passphrase(const std::string& passphrase) {
     passphrase_ = passphrase;
   }
   void set_identity(const std::string& identity) {
     identity_ = identity;
   }
   void set_cert_path(const std::string& cert_path) {
     cert_path_ = cert_path;
   }
 
   // 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.
   std::string GetEncryptionString();
 
   // Return true if cert_path_ indicates that we have loaded the certificate.
   bool IsCertificateLoaded() const;
 
  protected:
   ConnectionSecurity encryption_;
   std::string passphrase_;
   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 {
     RADIOTYPE_GSM,
     RADIOTYPE_CDMA,
     RADIOTYPE_WCDMA,
   } radio_type;                   // GSM/WCDMA     CDMA
   int mobile_country_code;        //   MCC          MCC
   int mobile_network_code;        //   MNC          SID
   int location_area_code;         //   LAC          NID
@@ skipping 62 matching lines @@
   };
 
   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;
 
   // 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;
 
   // Return true if any network is currently connected.
   virtual bool Connected() const = 0;
 
   // Return true if any network is currently connecting.
   virtual bool Connecting() const = 0;
 
   // Returns the current IP address if connected. If not, returns empty string.
-  virtual const std::string& IPAddress() const = 0;
+  // virtual const std::string& IPAddress() const = 0;
 
   // Returns the current list of wifi networks.
   virtual const WifiNetworkVector& wifi_networks() const = 0;
 
   // Returns the list of remembered wifi networks.
   virtual const WifiNetworkVector& remembered_wifi_networks() const = 0;
 
   // 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;
 
   // Reads out the results of the last wifi scan. These results are not
   // pre-cached in the library, so the call may block whilst the results are
   // read over IPC.
   // Returns false if an error occurred in reading the results. Note that
   // a true return code only indicates the result set was successfully read,
   // it does not imply a scan has successfully completed yet.
   virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) = 0;
 
   // 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,
+  virtual void 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,
                                     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;
+  virtual void 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;
   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 bool offline_mode() const = 0;
@@ skipping 23 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_