Call libcros functions through proxy functions

chrome/browser/chromeos/cros/network_library_impl_cros.cc

 // Copyright (c) 2012 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_impl_cros.h"
 
 #include <dbus/dbus-glib.h>
 #include "base/json/json_writer.h"  // for debug output only.
 #include "base/metrics/histogram.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
@@ skipping 162 matching lines @@
 ////////////////////////////////////////////////////////////////////////////
 
 NetworkLibraryImplCros::NetworkLibraryImplCros()
     : NetworkLibraryImplBase(),
       network_manager_monitor_(NULL),
       data_plan_monitor_(NULL) {
 }
 
 NetworkLibraryImplCros::~NetworkLibraryImplCros() {
   if (network_manager_monitor_)
-    chromeos::DisconnectNetworkPropertiesMonitor(network_manager_monitor_);
+    CrosDisconnectNetworkPropertiesMonitor(network_manager_monitor_);
   if (data_plan_monitor_)
-    chromeos::DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
+    CrosDisconnectDataPlanUpdateMonitor(data_plan_monitor_);
   for (NetworkPropertiesMonitorMap::iterator iter =
            montitored_networks_.begin();
        iter != montitored_networks_.end(); ++iter) {
-    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
+    CrosDisconnectNetworkPropertiesMonitor(iter->second);
   }
   for (NetworkPropertiesMonitorMap::iterator iter =
            montitored_devices_.begin();
        iter != montitored_devices_.end(); ++iter) {
-    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
+    CrosDisconnectNetworkPropertiesMonitor(iter->second);
   }
 }
 
 void NetworkLibraryImplCros::Init() {
   CHECK(CrosLibrary::Get()->libcros_loaded())
       << "libcros must be loaded before NetworkLibraryImplCros::Init()";
   // First, get the currently available networks. This data is cached
   // on the connman side, so the call should be quick.
   VLOG(1) << "Requesting initial network manager info from libcros.";
-  chromeos::RequestNetworkManagerProperties(&NetworkManagerUpdate, this);
+  CrosRequestNetworkManagerProperties(&NetworkManagerUpdate, this);
   network_manager_monitor_ =
-      chromeos::MonitorNetworkManagerProperties(
+      CrosMonitorNetworkManagerProperties(
           &NetworkManagerStatusChangedHandler, this);
   data_plan_monitor_ =
-      chromeos::MonitorCellularDataPlan(&DataPlanUpdateHandler, this);
+      CrosMonitorCellularDataPlan(&DataPlanUpdateHandler, this);
   // Always have at least one device obsever so that device updates are
   // always received.
   network_device_observer_.reset(new NetworkLibraryDeviceObserver());
 }
 
 bool NetworkLibraryImplCros::IsCros() const {
   return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase implementation.
 
 void NetworkLibraryImplCros::MonitorNetworkStart(
     const std::string& service_path) {
   if (montitored_networks_.find(service_path) == montitored_networks_.end()) {
     chromeos::NetworkPropertiesMonitor monitor =
-        chromeos::MonitorNetworkServiceProperties(
+        CrosMonitorNetworkServiceProperties(
             &NetworkStatusChangedHandler, service_path.c_str(), this);
     montitored_networks_[service_path] = monitor;
   }
 }
 
 void NetworkLibraryImplCros::MonitorNetworkStop(
     const std::string& service_path) {
   NetworkPropertiesMonitorMap::iterator iter =
       montitored_networks_.find(service_path);
   if (iter != montitored_networks_.end()) {
-    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
+    CrosDisconnectNetworkPropertiesMonitor(iter->second);
     montitored_networks_.erase(iter);
   }
 }
 
 void NetworkLibraryImplCros::MonitorNetworkDeviceStart(
     const std::string& device_path) {
   if (montitored_devices_.find(device_path) == montitored_devices_.end()) {
     chromeos::NetworkPropertiesMonitor monitor =
-        chromeos::MonitorNetworkDeviceProperties(
+        CrosMonitorNetworkDeviceProperties(
             &NetworkDevicePropertyChangedHandler, device_path.c_str(), this);
     montitored_devices_[device_path] = monitor;
   }
 }
 
 void NetworkLibraryImplCros::MonitorNetworkDeviceStop(
     const std::string& device_path) {
   NetworkPropertiesMonitorMap::iterator iter =
       montitored_devices_.find(device_path);
   if (iter != montitored_devices_.end()) {
-    chromeos::DisconnectNetworkPropertiesMonitor(iter->second);
+    CrosDisconnectNetworkPropertiesMonitor(iter->second);
     montitored_devices_.erase(iter);
   }
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkStatusChangedHandler(
     void* object, const char* path, const char* key, const GValue* gvalue) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
@@ skipping 62 matching lines @@
         }
       }
     } else {
       VLOG(1) << "UpdateNetworkDeviceStatus: Failed to update: "
               << path << "." << key;
     }
     // Notify only observers on device property change.
     NotifyNetworkDeviceChanged(device, index);
     // If a device's power state changes, new properties may become defined.
     if (index == PROPERTY_INDEX_POWERED)
-      chromeos::RequestNetworkDeviceProperties(path.c_str(),
-                                               &NetworkDeviceUpdate,
-                                               this);
+      CrosRequestNetworkDeviceProperties(path.c_str(),
+                                         &NetworkDeviceUpdate,
+                                         this);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // NetworkLibraryImplBase connect implementation.
 
 // static callback
 void NetworkLibraryImplCros::ConfigureServiceCallback(
     void* object,
     const char* service_path,
     NetworkMethodErrorType error,
     const char* error_message) {
   if (error != NETWORK_METHOD_ERROR_NONE) {
     LOG(WARNING) << "Error from ConfigureService callback for: "
                  << service_path
                  << " Error: " << error << " Message: " << error_message;
   }
 }
 
 void NetworkLibraryImplCros::CallConfigureService(const std::string& identifier,
                                                   const DictionaryValue* info) {
   GHashTable* ghash = ConvertDictionaryValueToGValueMap(info);
   if (VLOG_IS_ON(2)) {
     scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
     std::string dict_json;
     base::JSONWriter::Write(static_cast<Value*>(dict.get()), true, &dict_json);
     VLOG(2) << "ConfigureService will be called on:" << dict_json;
   }
-  chromeos::ConfigureService(identifier.c_str(), ghash,
-                             ConfigureServiceCallback, this);
+  CrosConfigureService(identifier.c_str(), ghash,
+                       ConfigureServiceCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::NetworkConnectCallback(
     void* object,
     const char* service_path,
     NetworkMethodErrorType error,
     const char* error_message) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkConnectStatus status;
@@ skipping 15 matching lines @@
   Network* network = networklib->FindNetworkByPath(std::string(service_path));
   if (!network) {
     LOG(ERROR) << "No network for path: " << service_path;
     return;
   }
   networklib->NetworkConnectCompleted(network, status);
 }
 
 void NetworkLibraryImplCros::CallConnectToNetwork(Network* network) {
   DCHECK(network);
-  chromeos::RequestNetworkServiceConnect(network->service_path().c_str(),
-                                         NetworkConnectCallback, this);
+  CrosRequestNetworkServiceConnect(network->service_path().c_str(),
+                                   NetworkConnectCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
     void* object, const char* service_path, GHashTable* ghash) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (service_path && ghash) {
     scoped_ptr<DictionaryValue> dict(ConvertGHashTable(ghash));
     Network* network =
         networklib->ParseNetwork(std::string(service_path), *(dict.get()));
     DCHECK_EQ(network->type(), TYPE_WIFI);
     networklib->ConnectToWifiNetworkUsingConnectData(
         static_cast<WifiNetwork*>(network));
   }
 }
 
 void NetworkLibraryImplCros::CallRequestWifiNetworkAndConnect(
     const std::string& ssid, ConnectionSecurity security) {
   // Asynchronously request service properties and call
   // WifiServiceUpdateAndConnect.
-  chromeos::RequestHiddenWifiNetworkProperties(
+  CrosRequestHiddenWifiNetworkProperties(
       ssid.c_str(),
       SecurityToString(security),
       WifiServiceUpdateAndConnect,
       this);
 }
 
 // static callback
 void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
     void* object, const char* service_path, GHashTable* ghash) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
@@ skipping 10 matching lines @@
         static_cast<VirtualNetwork*>(network));
   } else {
     LOG(WARNING) << "Unable to create VPN Service: " << service_path;
   }
 }
 
 void NetworkLibraryImplCros::CallRequestVirtualNetworkAndConnect(
     const std::string& service_name,
     const std::string& server_hostname,
     ProviderType provider_type) {
-  chromeos::RequestVirtualNetworkProperties(
+  CrosRequestVirtualNetworkProperties(
       service_name.c_str(),
       server_hostname.c_str(),
       ProviderTypeToString(provider_type),
       VPNServiceUpdateAndConnect,
       this);
 }
 
 void NetworkLibraryImplCros::CallDeleteRememberedNetwork(
     const std::string& profile_path,
     const std::string& service_path) {
-  chromeos::DeleteServiceFromProfile(
+  CrosDeleteServiceFromProfile(
       profile_path.c_str(), service_path.c_str());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary implementation.
 
 void NetworkLibraryImplCros::ChangePin(const std::string& old_pin,
                                        const std::string& new_pin) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling ChangePin method w/o cellular device.";
     return;
   }
   sim_operation_ = SIM_OPERATION_CHANGE_PIN;
-  chromeos::RequestChangePin(cellular->device_path().c_str(),
-                             old_pin.c_str(), new_pin.c_str(),
-                             PinOperationCallback, this);
+  CrosRequestChangePin(cellular->device_path().c_str(),
+                       old_pin.c_str(), new_pin.c_str(),
+                       PinOperationCallback, this);
 }
 
 void NetworkLibraryImplCros::ChangeRequirePin(bool require_pin,
                                               const std::string& pin) {
   VLOG(1) << "ChangeRequirePin require_pin: " << require_pin
           << " pin: " << pin;
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling ChangeRequirePin method w/o cellular device.";
     return;
   }
   sim_operation_ = SIM_OPERATION_CHANGE_REQUIRE_PIN;
-  chromeos::RequestRequirePin(cellular->device_path().c_str(),
-                              pin.c_str(), require_pin,
-                              PinOperationCallback, this);
+  CrosRequestRequirePin(cellular->device_path().c_str(),
+                        pin.c_str(), require_pin,
+                        PinOperationCallback, this);
 }
 
 void NetworkLibraryImplCros::EnterPin(const std::string& pin) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling EnterPin method w/o cellular device.";
     return;
   }
   sim_operation_ = SIM_OPERATION_ENTER_PIN;
-  chromeos::RequestEnterPin(cellular->device_path().c_str(),
-                            pin.c_str(),
-                            PinOperationCallback, this);
+  CrosRequestEnterPin(cellular->device_path().c_str(),
+                      pin.c_str(),
+                      PinOperationCallback, this);
 }
 
 void NetworkLibraryImplCros::UnblockPin(const std::string& puk,
                                         const std::string& new_pin) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling UnblockPin method w/o cellular device.";
     return;
   }
   sim_operation_ = SIM_OPERATION_UNBLOCK_PIN;
-  chromeos::RequestUnblockPin(cellular->device_path().c_str(),
-                              puk.c_str(), new_pin.c_str(),
-                              PinOperationCallback, this);
+  CrosRequestUnblockPin(cellular->device_path().c_str(),
+                        puk.c_str(), new_pin.c_str(),
+                        PinOperationCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::PinOperationCallback(
     void* object,
     const char* path,
     NetworkMethodErrorType error,
     const char* error_message) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
@@ skipping 20 matching lines @@
   }
   networklib->NotifyPinOperationCompleted(pin_error);
 }
 
 void NetworkLibraryImplCros::RequestCellularScan() {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling RequestCellularScan method w/o cellular device.";
     return;
   }
-  chromeos::ProposeScan(cellular->device_path().c_str());
+  CrosProposeScan(cellular->device_path().c_str());
 }
 
 void NetworkLibraryImplCros::RequestCellularRegister(
     const std::string& network_id) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling CellularRegister method w/o cellular device.";
     return;
   }
-  chromeos::RequestCellularRegister(cellular->device_path().c_str(),
-                                    network_id.c_str(),
-                                    CellularRegisterCallback,
-                                    this);
+  CrosRequestCellularRegister(cellular->device_path().c_str(),
+                              network_id.c_str(),
+                              CellularRegisterCallback,
+                              this);
 }
 
 // static callback
 void NetworkLibraryImplCros::CellularRegisterCallback(
     void* object,
     const char* path,
     NetworkMethodErrorType error,
     const char* error_message) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   // TODO(dpolukhin): Notify observers about network registration status
   // but not UI doesn't assume such notification so just ignore result.
 }
 
 void NetworkLibraryImplCros::SetCellularDataRoamingAllowed(bool new_value) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling SetCellularDataRoamingAllowed method "
         "w/o cellular device.";
     return;
   }
   scoped_ptr<GValue> gvalue(ConvertBoolToGValue(new_value));
-  chromeos::SetNetworkDevicePropertyGValue(
+  CrosSetNetworkDevicePropertyGValue(
       cellular->device_path().c_str(),
       flimflam::kCellularAllowRoamingProperty, gvalue.get());
 }
 
 bool NetworkLibraryImplCros::IsCellularAlwaysInRoaming() {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling IsCellularAlwaysInRoaming method "
         "w/o cellular device.";
     return false;
   }
   const std::string& home_provider_name = cellular->home_provider_name();
   for (size_t i = 0; i < arraysize(kAlwaysInRoamingOperators); i++) {
     if (home_provider_name == kAlwaysInRoamingOperators[i])
       return true;
   }
   return false;
 }
 
 void NetworkLibraryImplCros::RequestNetworkScan() {
   if (wifi_enabled()) {
     wifi_scanning_ = true;  // Cleared when updates are received.
-    chromeos::RequestNetworkScan(flimflam::kTypeWifi);
+    CrosRequestNetworkScan(flimflam::kTypeWifi);
   }
   if (cellular_network())
     cellular_network()->RefreshDataPlansIfNeeded();
   // Make sure all Manager info is up to date. This will also update
   // remembered networks and visible services.
-  chromeos::RequestNetworkManagerProperties(&NetworkManagerUpdate, this);
+  CrosRequestNetworkManagerProperties(&NetworkManagerUpdate, this);
 }
 
 bool NetworkLibraryImplCros::GetWifiAccessPoints(
     WifiAccessPointVector* result) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DeviceNetworkList* network_list = chromeos::GetDeviceNetworkList();
+  DeviceNetworkList* network_list = CrosGetDeviceNetworkList();
   if (network_list == NULL)
     return false;
   result->clear();
   result->reserve(network_list->network_size);
   const base::Time now = base::Time::Now();
   for (size_t i = 0; i < network_list->network_size; ++i) {
     DCHECK(network_list->networks[i].address);
     DCHECK(network_list->networks[i].name);
     WifiAccessPoint ap;
     ap.mac_address = SafeString(network_list->networks[i].address);
     ap.name = SafeString(network_list->networks[i].name);
     ap.timestamp = now -
         base::TimeDelta::FromSeconds(network_list->networks[i].age_seconds);
     ap.signal_strength = network_list->networks[i].strength;
     ap.channel = network_list->networks[i].channel;
     result->push_back(ap);
   }
-  chromeos::FreeDeviceNetworkList(network_list);
+  CrosFreeDeviceNetworkList(network_list);
   return true;
 }
 
 void NetworkLibraryImplCros::DisconnectFromNetwork(const Network* network) {
   DCHECK(network);
   // Asynchronous disconnect request. Network state will be updated through
   // the network manager once disconnect completes.
-  chromeos::RequestNetworkServiceDisconnect(network->service_path().c_str());
+  CrosRequestNetworkServiceDisconnect(network->service_path().c_str());
 }
 
 void NetworkLibraryImplCros::CallEnableNetworkDeviceType(
     ConnectionType device, bool enable) {
   busy_devices_ |= 1 << device;
-  chromeos::RequestNetworkDeviceEnable(
+  CrosRequestNetworkDeviceEnable(
       ConnectionTypeToString(device), enable);
 }
 
 void NetworkLibraryImplCros::CallRemoveNetwork(const Network* network) {
   const char* service_path = network->service_path().c_str();
   if (network->connected())
-    chromeos::RequestNetworkServiceDisconnect(service_path);
-  chromeos::RequestRemoveNetworkService(service_path);
+    CrosRequestNetworkServiceDisconnect(service_path);
+  CrosRequestRemoveNetworkService(service_path);
 }
 
 void NetworkLibraryImplCros::EnableOfflineMode(bool enable) {
   // If network device is already enabled/disabled, then don't do anything.
-  if (chromeos::SetOfflineMode(enable))
+  if (CrosSetOfflineMode(enable))
     offline_mode_ = enable;
 }
 
 NetworkIPConfigVector NetworkLibraryImplCros::GetIPConfigs(
     const std::string& device_path,
     std::string* hardware_address,
     HardwareAddressFormat format) {
   DCHECK(hardware_address);
   hardware_address->clear();
   NetworkIPConfigVector ipconfig_vector;
   if (!device_path.empty()) {
-    IPConfigStatus* ipconfig_status = ListIPConfigs(device_path.c_str());
+    IPConfigStatus* ipconfig_status = CrosListIPConfigs(device_path.c_str());
     if (ipconfig_status) {
       for (int i = 0; i < ipconfig_status->size; ++i) {
         IPConfig ipconfig = ipconfig_status->ips[i];
         ipconfig_vector.push_back(
             NetworkIPConfig(device_path, ipconfig.type, ipconfig.address,
                             ipconfig.netmask, ipconfig.gateway,
                             ipconfig.name_servers));
       }
       *hardware_address = ipconfig_status->hardware_address;
-      FreeIPConfigStatus(ipconfig_status);
+      CrosFreeIPConfigStatus(ipconfig_status);
     }
   }
 
   for (size_t i = 0; i < hardware_address->size(); ++i)
     (*hardware_address)[i] = toupper((*hardware_address)[i]);
   if (format == FORMAT_COLON_SEPARATED_HEX) {
     if (hardware_address->size() % 2 == 0) {
       std::string output;
       for (size_t i = 0; i < hardware_address->size(); ++i) {
         if ((i != 0) && (i % 2 == 0))
           output.push_back(':');
         output.push_back((*hardware_address)[i]);
       }
       *hardware_address = output;
     }
   } else {
     DCHECK_EQ(format, FORMAT_RAW_HEX);
   }
   return ipconfig_vector;
 }
 
 void NetworkLibraryImplCros::SetIPConfig(const NetworkIPConfig& ipconfig) {
   if (ipconfig.device_path.empty())
     return;
 
   IPConfig* ipconfig_dhcp = NULL;
   IPConfig* ipconfig_static = NULL;
 
   IPConfigStatus* ipconfig_status =
-      chromeos::ListIPConfigs(ipconfig.device_path.c_str());
+      CrosListIPConfigs(ipconfig.device_path.c_str());
   if (ipconfig_status) {
     for (int i = 0; i < ipconfig_status->size; ++i) {
       if (ipconfig_status->ips[i].type == chromeos::IPCONFIG_TYPE_DHCP)
         ipconfig_dhcp = &ipconfig_status->ips[i];
       else if (ipconfig_status->ips[i].type == chromeos::IPCONFIG_TYPE_IPV4)
         ipconfig_static = &ipconfig_status->ips[i];
     }
   }
 
   IPConfigStatus* ipconfig_status2 = NULL;
   if (ipconfig.type == chromeos::IPCONFIG_TYPE_DHCP) {
     // If switching from static to dhcp, create new dhcp ip config.
     if (!ipconfig_dhcp)
-      chromeos::AddIPConfig(ipconfig.device_path.c_str(),
-                            chromeos::IPCONFIG_TYPE_DHCP);
+      CrosAddIPConfig(ipconfig.device_path.c_str(),
+                      chromeos::IPCONFIG_TYPE_DHCP);
     // User wants DHCP now. So delete the static ip config.
     if (ipconfig_static)
-      chromeos::RemoveIPConfig(ipconfig_static);
+      CrosRemoveIPConfig(ipconfig_static);
   } else if (ipconfig.type == chromeos::IPCONFIG_TYPE_IPV4) {
     // If switching from dhcp to static, create new static ip config.
     if (!ipconfig_static) {
-      chromeos::AddIPConfig(ipconfig.device_path.c_str(),
-                            chromeos::IPCONFIG_TYPE_IPV4);
+      CrosAddIPConfig(ipconfig.device_path.c_str(),
+                      chromeos::IPCONFIG_TYPE_IPV4);
       // Now find the newly created IP config.
       ipconfig_status2 =
-          chromeos::ListIPConfigs(ipconfig.device_path.c_str());
+          CrosListIPConfigs(ipconfig.device_path.c_str());
       if (ipconfig_status2) {
         for (int i = 0; i < ipconfig_status2->size; ++i) {
           if (ipconfig_status2->ips[i].type == chromeos::IPCONFIG_TYPE_IPV4)
             ipconfig_static = &ipconfig_status2->ips[i];
         }
       }
     }
     if (ipconfig_static) {
       // Save any changed details.
       if (ipconfig.address != ipconfig_static->address) {
         scoped_ptr<GValue> gvalue(ConvertStringToGValue(ipconfig.address));
-        chromeos::SetNetworkIPConfigPropertyGValue(
+        CrosSetNetworkIPConfigPropertyGValue(
             ipconfig_static->path, flimflam::kAddressProperty, gvalue.get());
       }
       if (ipconfig.netmask != ipconfig_static->netmask) {
         int prefixlen = ipconfig.GetPrefixLength();
         if (prefixlen == -1) {
           VLOG(1) << "IP config prefixlen is invalid for netmask "
                   << ipconfig.netmask;
         } else {
           scoped_ptr<GValue> gvalue(ConvertIntToGValue(prefixlen));
-          chromeos::SetNetworkIPConfigPropertyGValue(
+          CrosSetNetworkIPConfigPropertyGValue(
               ipconfig_static->path,
               flimflam::kPrefixlenProperty, gvalue.get());
         }
       }
       if (ipconfig.gateway != ipconfig_static->gateway) {
         scoped_ptr<GValue> gvalue(ConvertStringToGValue(ipconfig.gateway));
-        chromeos::SetNetworkIPConfigPropertyGValue(
+        CrosSetNetworkIPConfigPropertyGValue(
             ipconfig_static->path, flimflam::kGatewayProperty, gvalue.get());
       }
       if (ipconfig.name_servers != ipconfig_static->name_servers) {
         scoped_ptr<GValue> gvalue(ConvertStringToGValue(ipconfig.name_servers));
-        chromeos::SetNetworkIPConfigPropertyGValue(
+        CrosSetNetworkIPConfigPropertyGValue(
             ipconfig_static->path,
             flimflam::kNameServersProperty, gvalue.get());
       }
       // Remove dhcp ip config if there is one.
       if (ipconfig_dhcp)
-        chromeos::RemoveIPConfig(ipconfig_dhcp);
+        CrosRemoveIPConfig(ipconfig_dhcp);
     }
   }
 
   if (ipconfig_status)
-    chromeos::FreeIPConfigStatus(ipconfig_status);
+    CrosFreeIPConfigStatus(ipconfig_status);
   if (ipconfig_status2)
-    chromeos::FreeIPConfigStatus(ipconfig_status2);
+    CrosFreeIPConfigStatus(ipconfig_status2);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Network Manager functions.
 
 // static
 void NetworkLibraryImplCros::NetworkManagerStatusChangedHandler(
     void* object, const char* path, const char* key, const GValue* gvalue) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
@@ skipping 226 matching lines @@
         AddNetwork(found->second);
         old_network_map.erase(found);
       }
       // Always request network updates.
       // TODO(stevenjb): Investigate why we are missing updates then
       // rely on watched network updates and only request updates here for
       // new networks.
       // Use update_request map to store network priority.
       network_update_requests_[service_path] = network_priority_order++;
       wifi_scanning_ = true;
-      chromeos::RequestNetworkServiceProperties(service_path.c_str(),
-                                                &NetworkServiceUpdate,
-                                                this);
+      CrosRequestNetworkServiceProperties(service_path.c_str(),
+                                          &NetworkServiceUpdate,
+                                          this);
     }
   }
   // Iterate through list of remaining networks that are no longer in the
   // list and delete them or update their status and re-add them to the list.
   for (NetworkMap::iterator iter = old_network_map.begin();
        iter != old_network_map.end(); ++iter) {
     Network* network = iter->second;
     VLOG(2) << "Delete Network: " << network->name()
             << " State = " << network->GetStateString()
             << " connecting = " << network->connecting()
@@ skipping 22 matching lines @@
 // Existing networks will be updated. There should not be any new networks
 // in this list, but if there are they will be added appropriately.
 void NetworkLibraryImplCros::UpdateWatchedNetworkServiceList(
     const ListValue* services) {
   for (ListValue::const_iterator iter = services->begin();
        iter != services->end(); ++iter) {
     std::string service_path;
     (*iter)->GetAsString(&service_path);
     if (!service_path.empty()) {
       VLOG(1) << "Watched Service: " << service_path;
-      chromeos::RequestNetworkServiceProperties(service_path.c_str(),
-                                                &NetworkServiceUpdate,
-                                                this);
+      CrosRequestNetworkServiceProperties(service_path.c_str(),
+                                          &NetworkServiceUpdate,
+                                          this);
     }
   }
 }
 
 // static
 void NetworkLibraryImplCros::NetworkServiceUpdate(
     void* object, const char* service_path, GHashTable* ghash) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
@@ skipping 88 matching lines @@
   // We can do this safely because we do not save any local state for
   // remembered networks. This list updates infrequently.
   DeleteRememberedNetworks();
   // Request remembered networks from each profile. Later entries will
   // override earlier entries, so default/local entries will override
   // user entries (as desired).
   for (NetworkProfileList::iterator iter = profile_list_.begin();
        iter != profile_list_.end(); ++iter) {
     NetworkProfile& profile = *iter;
     VLOG(1) << " Requesting Profile: " << profile.path;
-    chromeos::RequestNetworkProfileProperties(
+    CrosRequestNetworkProfileProperties(
         profile.path.c_str(), &ProfileUpdate, this);
   }
 }
 
 // static
 void NetworkLibraryImplCros::ProfileUpdate(
     void* object, const char* profile_path, GHashTable* ghash) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
@@ skipping 32 matching lines @@
     std::string service_path;
     (*iter2)->GetAsString(&service_path);
     if (service_path.empty()) {
       LOG(WARNING) << "Empty service path in profile.";
       continue;
     }
     VLOG(1) << " Remembered service: " << service_path;
     // Add service to profile list.
     profile.services.insert(service_path);
     // Request update for remembered network.
-    chromeos::RequestNetworkProfileEntryProperties(
+    CrosRequestNetworkProfileEntryProperties(
         profile_path,
         service_path.c_str(),
         &RememberedNetworkServiceUpdate,
         this);
   }
 }
 
 // static
 void NetworkLibraryImplCros::RememberedNetworkServiceUpdate(
     void* object, const char* service_path, GHashTable* ghash) {
@@ skipping 51 matching lines @@
 
   if (remembered->type() == TYPE_VPN) {
     // VPNs are only stored in profiles. If we don't have a network for it,
     // request one.
     if (!FindNetworkByUniqueId(remembered->unique_id())) {
       VirtualNetwork* vpn = static_cast<VirtualNetwork*>(remembered);
       std::string provider_type = ProviderTypeToString(vpn->provider_type());
       VLOG(1) << "Requesting VPN: " << vpn->name()
               << " Server: " << vpn->server_hostname()
               << " Type: " << provider_type;
-      chromeos::RequestVirtualNetworkProperties(
+      CrosRequestVirtualNetworkProperties(
           vpn->name().c_str(),
           vpn->server_hostname().c_str(),
           provider_type.c_str(),
           NetworkServiceUpdate,
           this);
     }
   }
 
   return remembered;
 }
@@ skipping 12 matching lines @@
     std::string device_path;
     (*iter)->GetAsString(&device_path);
     if (!device_path.empty()) {
       NetworkDeviceMap::iterator found = old_device_map.find(device_path);
       if (found != old_device_map.end()) {
         VLOG(2) << " Adding existing device: " << device_path;
         CHECK(found->second) << "Attempted to add NULL device pointer";
         device_map_[device_path] = found->second;
         old_device_map.erase(found);
       }
-      chromeos::RequestNetworkDeviceProperties(device_path.c_str(),
-                                               &NetworkDeviceUpdate,
-                                               this);
+      CrosRequestNetworkDeviceProperties(device_path.c_str(),
+                                         &NetworkDeviceUpdate,
+                                         this);
     }
   }
   // Delete any old devices that no longer exist.
   for (NetworkDeviceMap::iterator iter = old_device_map.begin();
        iter != old_device_map.end(); ++iter) {
     DeleteDeviceFromDeviceObserversMap(iter->first);
     // Delete device.
     delete iter->second;
   }
 }
@@ skipping 81 matching lines @@
         // Switch back to signed settings value.
         SetCellularDataRoamingAllowed(settings_value);
       }
     }
   }
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 }  // namespace chromeos