Refactor libcros calls for ChromeOS

chrome/browser/chromeos/cros/network_library.h

 // Copyright (c) 2009 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_
 
 #include <string>
 #include <vector>
 
@@ skipping 14 matching lines @@
 
   std::string device_path;
   std::string ip_address;
   bool connecting;
   bool connected;
 };
 
 struct WifiNetwork {
   WifiNetwork()
       : encrypted(false),
-        encryption(chromeos::NONE),
+        encryption(chromeos::SECURITY_UNKNOWN),
         strength(0),
         connecting(false),
-        connected(false) {}
-  WifiNetwork(const std::string& device_path, const std::string& ssid,
-              bool encrypted, chromeos::EncryptionType encryption, int strength,
-              bool connecting, bool connected, const std::string& ip_address)
-      : device_path(device_path),
-        ssid(ssid),
-        encrypted(encrypted),
-        encryption(encryption),
-        strength(strength),
+        connected(false),
+        auto_connect(false) {}
+  WifiNetwork(ServiceInfo service, bool connecting, bool connected,
+              const std::string& ip_address)
+      : service_path(service.service_path),
+        device_path(service.device_path),
+        ssid(service.name),
+        encrypted(service.passphrase_required),
+        encryption(service.security),
+        strength(service.strength),
         connecting(connecting),
         connected(connected),
         ip_address(ip_address) {}
 
   // WifiNetworks are sorted by ssids.
   bool operator< (const WifiNetwork& other) const {
     return ssid < other.ssid;
   }
 
+  std::string service_path;
   std::string device_path;
   std::string ssid;
   bool encrypted;
-  chromeos::EncryptionType encryption;
+  chromeos::ConnectionSecurity encryption;
   int strength;
   bool connecting;
   bool connected;
+  bool auto_connect;
   std::string ip_address;
 };
 typedef std::vector<WifiNetwork> WifiNetworkVector;
 
 struct CellularNetwork {
   CellularNetwork()
       : strength(strength),
         connecting(false),
-        connected(false) {}
-  CellularNetwork(const std::string& device_path, const std::string& name,
-                  int strength, bool connecting, bool connected,
+        connected(false),
+        auto_connect(false) {}
+  CellularNetwork(ServiceInfo service, bool connecting, bool connected,
                   const std::string& ip_address)
-      : device_path(device_path),
-        name(name),
-        strength(strength),
+      : service_path(service.service_path),
+        device_path(service.device_path),
+        name(service.name),
+        strength(service.strength),
         connecting(connecting),
         connected(connected),
         ip_address(ip_address) {}
 
   // CellularNetworks are sorted by name.
   bool operator< (const CellularNetwork& other) const {
     return name < other.name;
   }
 
+  std::string service_path;
   std::string device_path;
   std::string name;
   int strength;
   bool connecting;
   bool connected;
+  bool auto_connect;
   std::string ip_address;
 };
 typedef std::vector<CellularNetwork> CellularNetworkVector;
 
 struct NetworkIPConfig {
   NetworkIPConfig(const std::string& device_path, IPConfigType type,
                   const std::string& address, const std::string& netmask,
                   const std::string& gateway, const std::string& name_servers)
       : device_path(device_path),
         type(type),
@@ skipping 88 matching lines @@
 
   // Connect to the specified wireless network with password.
   void ConnectToWifiNetwork(WifiNetwork network, const string16& password);
 
   // Connect to the specified wifi ssid with password.
   void ConnectToWifiNetwork(const string16& ssid, const string16& password);
 
   // Connect to the specified cellular network.
   void ConnectToCellularNetwork(CellularNetwork network);
 
-  bool ethernet_enabled() const { return network_devices_ & TYPE_ETHERNET; }
-  bool wifi_enabled() const { return network_devices_ & TYPE_WIFI; }
-  bool cellular_enabled() const { return network_devices_ & TYPE_CELLULAR; }
+  bool ethernet_enabled() const {
+      return network_devices_ & (1 << TYPE_ETHERNET); }
+  bool wifi_enabled() const {
+      return network_devices_ & (1 << TYPE_WIFI); }
+  bool cellular_enabled() const {
+      return network_devices_ & (1 << TYPE_CELLULAR); }
   bool offline_mode() const { return offline_mode_; }
 
   // Enables/disables the ethernet network device.
   void EnableEthernetNetworkDevice(bool enable);
 
   // Enables/disables the wifi network device.
   void EnableWifiNetworkDevice(bool enable);
 
   // Enables/disables the cellular network device.
   void EnableCellularNetworkDevice(bool enable);
@@ skipping 89 matching lines @@
   int network_devices_;
 
   bool offline_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLibrary);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_