Replace const char* in cros_network_functions.h with const std::stirng&

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/command_line.h"
 #include "base/json/json_writer.h"  // for debug output only.
 #include "base/metrics/histogram.h"
@@ skipping 105 matching lines @@
 // static callback
 void NetworkLibraryImplCros::NetworkStatusChangedHandler(
     void* object,
     const std::string& path,
     const std::string& key,
     const Value& value) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkStatus(std::string(path), std::string(key), value);
+  networklib->UpdateNetworkStatus(path, key, value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkStatus(
     const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Network* network = FindNetworkByPath(path);
   if (network) {
     VLOG(2) << "UpdateNetworkStatus: " << network->name() << "." << key;
     bool prev_connected = network->connected();
     if (!network->UpdateStatus(key, value, NULL)) {
@@ skipping 12 matching lines @@
 // static callback
 void NetworkLibraryImplCros::NetworkDevicePropertyChangedHandler(
     void* object,
     const std::string& path,
     const std::string& key,
     const Value& value) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  networklib->UpdateNetworkDeviceStatus(std::string(path),
-                                        std::string(key),
-                                        value);
+  networklib->UpdateNetworkDeviceStatus(path, key, value);
 }
 
 void NetworkLibraryImplCros::UpdateNetworkDeviceStatus(
     const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   NetworkDevice* device = FindNetworkDeviceByPath(path);
   if (device) {
     VLOG(2) << "UpdateNetworkDeviceStatus: " << device->name() << "." << key;
     PropertyIndex index = PROPERTY_INDEX_UNKNOWN;
     if (device->UpdateStatus(key, value, &index)) {
       if (device->type() == TYPE_CELLULAR) {
         if (!UpdateCellularDeviceStatus(device, index))
           return;  // Update aborted, skip notify.
       }
     } 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) {
-      CrosRequestNetworkDeviceProperties(path.c_str(),
+      CrosRequestNetworkDeviceProperties(path,
                                          base::Bind(&NetworkDeviceUpdate,
                                                     this));
     }
   }
 }
 
 bool NetworkLibraryImplCros::UpdateCellularDeviceStatus(
     NetworkDevice* device, PropertyIndex index) {
   if (index == PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING) {
     if (!device->data_roaming_allowed() && IsCellularAlwaysInRoaming()) {
@@ skipping 27 matching lines @@
     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) {
-  CrosConfigureService(identifier.c_str(), *info,
-                       ConfigureServiceCallback, this);
+  CrosConfigureService(identifier, *info, 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;
   if (error == NETWORK_METHOD_ERROR_NONE) {
     status = CONNECT_SUCCESS;
   } else {
     LOG(WARNING) << "Error from ServiceConnect callback for: "
                  << service_path
                  << " Error: " << error << " Message: " << error_message;
     if (error_message &&
         strcmp(error_message, flimflam::kErrorPassphraseRequiredMsg) == 0) {
       status = CONNECT_BAD_PASSPHRASE;
     } else {
       status = CONNECT_FAILED;
     }
   }
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
-  Network* network = networklib->FindNetworkByPath(std::string(service_path));
+  Network* network = networklib->FindNetworkByPath(service_path);
   if (!network) {
     LOG(ERROR) << "No network for path: " << service_path;
     return;
   }
   networklib->NetworkConnectCompleted(network, status);
 }
 
 void NetworkLibraryImplCros::CallConnectToNetwork(Network* network) {
   DCHECK(network);
-  CrosRequestNetworkServiceConnect(network->service_path().c_str(),
+  CrosRequestNetworkServiceConnect(network->service_path(),
                                    NetworkConnectCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::WifiServiceUpdateAndConnect(
     void* object,
-    const char* service_path,
+    const std::string& service_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (service_path && properties) {
-    Network* network =
-        networklib->ParseNetwork(std::string(service_path), *properties);
+  if (properties) {
+    Network* network = networklib->ParseNetwork(service_path, *properties);
     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.
   CrosRequestHiddenWifiNetworkProperties(
-      ssid.c_str(),
+      ssid,
       SecurityToString(security),
       base::Bind(&WifiServiceUpdateAndConnect, this));
 }
 
 // static callback
 void NetworkLibraryImplCros::VPNServiceUpdateAndConnect(
     void* object,
-    const char* service_path,
+    const std::string& service_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (service_path && properties) {
+  if (properties) {
     VLOG(1) << "Connecting to new VPN Service: " << service_path;
-    Network* network =
-        networklib->ParseNetwork(std::string(service_path), *properties);
+    Network* network = networklib->ParseNetwork(service_path, *properties);
     DCHECK_EQ(network->type(), TYPE_VPN);
     networklib->ConnectToVirtualNetworkUsingConnectData(
         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) {
   CrosRequestVirtualNetworkProperties(
-      service_name.c_str(),
-      server_hostname.c_str(),
+      service_name,
+      server_hostname,
       ProviderTypeToString(provider_type),
       base::Bind(&VPNServiceUpdateAndConnect, this));
 }
 
 void NetworkLibraryImplCros::CallDeleteRememberedNetwork(
     const std::string& profile_path,
     const std::string& service_path) {
-  CrosDeleteServiceFromProfile(
-      profile_path.c_str(), service_path.c_str());
+  CrosDeleteServiceFromProfile(profile_path, service_path);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // NetworkLibrary implementation.
 
 void NetworkLibraryImplCros::SetCheckPortalList(
     const std::string& check_portal_list) {
   base::StringValue value(check_portal_list);
   CrosSetNetworkManagerProperty(flimflam::kCheckPortalListProperty, value);
 }
 
 void NetworkLibraryImplCros::SetDefaultCheckPortalList() {
   SetCheckPortalList(kDefaultCheckPortalList);
 }
 
 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;
-  CrosRequestChangePin(cellular->device_path().c_str(),
-                       old_pin.c_str(), new_pin.c_str(),
+  CrosRequestChangePin(cellular->device_path(), old_pin, new_pin,
                        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;
-  CrosRequestRequirePin(cellular->device_path().c_str(),
-                        pin.c_str(), require_pin,
+  CrosRequestRequirePin(cellular->device_path(), pin, 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;
-  CrosRequestEnterPin(cellular->device_path().c_str(),
-                      pin.c_str(),
-                      PinOperationCallback, this);
+  CrosRequestEnterPin(cellular->device_path(), pin, 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;
-  CrosRequestUnblockPin(cellular->device_path().c_str(),
-                        puk.c_str(), new_pin.c_str(),
+  CrosRequestUnblockPin(cellular->device_path(), puk, new_pin,
                         PinOperationCallback, this);
 }
 
 // static callback
 void NetworkLibraryImplCros::PinOperationCallback(
     void* object,
     const char* path,
     NetworkMethodErrorType error,
     const char* error_message) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
@@ skipping 21 matching lines @@
   }
   networklib->NotifyPinOperationCompleted(pin_error);
 }
 
 void NetworkLibraryImplCros::RequestCellularScan() {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling RequestCellularScan method w/o cellular device.";
     return;
   }
-  CrosProposeScan(cellular->device_path().c_str());
+  CrosProposeScan(cellular->device_path());
 }
 
 void NetworkLibraryImplCros::RequestCellularRegister(
     const std::string& network_id) {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling CellularRegister method w/o cellular device.";
     return;
   }
-  CrosRequestCellularRegister(cellular->device_path().c_str(),
-                              network_id.c_str(),
-                              CellularRegisterCallback,
-                              this);
+  CrosRequestCellularRegister(
+      cellular->device_path(), network_id, 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;
   }
   base::FundamentalValue value(new_value);
-  CrosSetNetworkDeviceProperty(cellular->device_path().c_str(),
+  CrosSetNetworkDeviceProperty(cellular->device_path(),
                                flimflam::kCellularAllowRoamingProperty,
                                value);
 }
 
 bool NetworkLibraryImplCros::IsCellularAlwaysInRoaming() {
   const NetworkDevice* cellular = FindCellularDevice();
   if (!cellular) {
     NOTREACHED() << "Calling IsCellularAlwaysInRoaming method "
         "w/o cellular device.";
     return false;
@@ skipping 40 matching lines @@
     result->push_back(ap);
   }
   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.
-  CrosRequestNetworkServiceDisconnect(network->service_path().c_str());
+  CrosRequestNetworkServiceDisconnect(network->service_path());
 }
 
 void NetworkLibraryImplCros::CallEnableNetworkDeviceType(
     ConnectionType device, bool enable) {
   busy_devices_ |= 1 << device;
-  CrosRequestNetworkDeviceEnable(
-      ConnectionTypeToString(device), enable);
+  CrosRequestNetworkDeviceEnable(ConnectionTypeToString(device), enable);
 }
 
 void NetworkLibraryImplCros::CallRemoveNetwork(const Network* network) {
-  const char* service_path = network->service_path().c_str();
+  const std::string& service_path = network->service_path();
   if (network->connected())
     CrosRequestNetworkServiceDisconnect(service_path);
   CrosRequestRemoveNetworkService(service_path);
 }
 
 void NetworkLibraryImplCros::EnableOfflineMode(bool enable) {
   // If network device is already enabled/disabled, then don't do anything.
   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 = CrosListIPConfigs(device_path.c_str());
+    IPConfigStatus* ipconfig_status = CrosListIPConfigs(device_path);
     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;
       CrosFreeIPConfigStatus(ipconfig_status);
@@ skipping 19 matching lines @@
 }
 
 void NetworkLibraryImplCros::SetIPConfig(const NetworkIPConfig& ipconfig) {
   if (ipconfig.device_path.empty())
     return;
 
   IPConfig* ipconfig_dhcp = NULL;
   IPConfig* ipconfig_static = NULL;
 
   IPConfigStatus* ipconfig_status =
-      CrosListIPConfigs(ipconfig.device_path.c_str());
+      CrosListIPConfigs(ipconfig.device_path);
   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)
-      CrosAddIPConfig(ipconfig.device_path.c_str(),
-                      chromeos::IPCONFIG_TYPE_DHCP);
+      CrosAddIPConfig(ipconfig.device_path, chromeos::IPCONFIG_TYPE_DHCP);
     // User wants DHCP now. So delete the static ip config.
     if (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) {
-      CrosAddIPConfig(ipconfig.device_path.c_str(),
-                      chromeos::IPCONFIG_TYPE_IPV4);
+      CrosAddIPConfig(ipconfig.device_path, chromeos::IPCONFIG_TYPE_IPV4);
       // Now find the newly created IP config.
       ipconfig_status2 =
-          CrosListIPConfigs(ipconfig.device_path.c_str());
+          CrosListIPConfigs(ipconfig.device_path);
       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) {
@@ skipping 139 matching lines @@
   }
   base::TimeDelta delta = base::TimeTicks::Now() - start;
   VLOG(2) << "NetworkManagerStatusChanged: time: "
           << delta.InMilliseconds() << " ms.";
   HISTOGRAM_TIMES("CROS_NETWORK_UPDATE", delta);
 }
 
 // static
 void NetworkLibraryImplCros::NetworkManagerUpdate(
     void* object,
-    const char* manager_path,
+    const std::string& manager_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (!properties) {
     LOG(ERROR) << "Error retrieving manager properties: " << manager_path;
     return;
   }
   VLOG(1) << "Received NetworkManagerUpdate.";
   networklib->ParseNetworkManager(*properties);
 }
 
 void NetworkLibraryImplCros::ParseNetworkManager(const DictionaryValue& dict) {
   for (DictionaryValue::key_iterator iter = dict.begin_keys();
        iter != dict.end_keys(); ++iter) {
     const std::string& key = *iter;
     Value* value;
     bool res = dict.GetWithoutPathExpansion(key, &value);
     CHECK(res);
-    NetworkManagerStatusChanged(key.c_str(), value);
+    NetworkManagerStatusChanged(key, value);
   }
   // If there is no Profiles entry, request remembered networks here.
   if (!dict.HasKey(flimflam::kProfilesProperty))
     RequestRememberedNetworksUpdate();
 }
 
 // static
 void NetworkLibraryImplCros::DataPlanUpdateHandler(
     void* object,
     const char* modem_service_path,
@@ skipping 95 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;
-      CrosRequestNetworkServiceProperties(service_path.c_str(),
+      CrosRequestNetworkServiceProperties(service_path,
                                           base::Bind(&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()
@@ skipping 25 matching lines @@
 // 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;
       CrosRequestNetworkServiceProperties(
-          service_path.c_str(),
+          service_path,
           base::Bind(&NetworkServiceUpdate, this));
     }
   }
 }
 
 // static
 void NetworkLibraryImplCros::NetworkServiceUpdate(
     void* object,
-    const char* service_path,
+    const std::string& service_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (service_path) {
-    if (!properties)
-      return;  // Network no longer in visible list, ignore.
-    networklib->ParseNetwork(std::string(service_path), *properties);
-  }
+  if (!properties)
+    return;  // Network no longer in visible list, ignore.
+  networklib->ParseNetwork(service_path, *properties);
 }
 
 // Called from NetworkServiceUpdate and WifiServiceUpdateAndConnect.
 Network* NetworkLibraryImplCros::ParseNetwork(
     const std::string& service_path, const DictionaryValue& info) {
   Network* network = FindNetworkByPath(service_path);
   if (!network) {
     NativeNetworkParser parser;
     network = parser.CreateNetworkFromInfo(service_path, info);
     AddNetwork(network);
@@ skipping 78 matching lines @@
   // 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;
     CrosRequestNetworkProfileProperties(
-        profile.path.c_str(), base::Bind(&ProfileUpdate, this));
+        profile.path, base::Bind(&ProfileUpdate, this));
   }
 }
 
 // static
 void NetworkLibraryImplCros::ProfileUpdate(
     void* object,
-    const char* profile_path,
+    const std::string& profile_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
   if (!properties) {
     LOG(ERROR) << "Error retrieving profile: " << profile_path;
     return;
   }
   VLOG(1) << "Received ProfileUpdate for: " << profile_path;
   ListValue* entries(NULL);
   properties->GetList(flimflam::kEntriesProperty, &entries);
   DCHECK(entries);
   networklib->UpdateRememberedServiceList(profile_path, entries);
 }
 
 void NetworkLibraryImplCros::UpdateRememberedServiceList(
-    const char* profile_path, const ListValue* profile_entries) {
-  DCHECK(profile_path);
+    const std::string& profile_path, const ListValue* profile_entries) {
   VLOG(1) << "UpdateRememberedServiceList for path: " << profile_path;
   NetworkProfileList::iterator iter1;
   for (iter1 = profile_list_.begin(); iter1 != profile_list_.end(); ++iter1) {
     if (iter1->path == profile_path)
       break;
   }
   if (iter1 == profile_list_.end()) {
     // This can happen if flimflam gets restarted while Chrome is running.
     LOG(WARNING) << "Profile not in list: " << profile_path;
     return;
   }
   NetworkProfile& profile = *iter1;
   // |profile_entries| is a list of remembered networks from |profile_path|.
   profile.services.clear();
   for (ListValue::const_iterator iter2 = profile_entries->begin();
        iter2 != profile_entries->end(); ++iter2) {
     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.
     CrosRequestNetworkProfileEntryProperties(
         profile_path,
-        service_path.c_str(),
+        service_path,
         base::Bind(&RememberedNetworkServiceUpdate, this));
   }
 }
 
 // static
 void NetworkLibraryImplCros::RememberedNetworkServiceUpdate(
     void* object,
-    const char* service_path,
+    const std::string& service_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (service_path) {
-    if (!properties) {
-      // Remembered network no longer exists.
-      networklib->DeleteRememberedNetwork(std::string(service_path));
-    } else {
-      networklib->ParseRememberedNetwork(
-          std::string(service_path), *properties);
-    }
+  if (!properties) {
+    // Remembered network no longer exists.
+    networklib->DeleteRememberedNetwork(service_path);
+  } else {
+    networklib->ParseRememberedNetwork(service_path, *properties);
   }
 }
 
 // Returns NULL if |service_path| refers to a network that is not a
 // remembered type. Called from RememberedNetworkServiceUpdate.
 Network* NetworkLibraryImplCros::ParseRememberedNetwork(
     const std::string& service_path, const DictionaryValue& info) {
   Network* remembered;
   NetworkMap::iterator found = remembered_network_map_.find(service_path);
   if (found != remembered_network_map_.end()) {
@@ skipping 30 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;
       CrosRequestVirtualNetworkProperties(
-          vpn->name().c_str(),
-          vpn->server_hostname().c_str(),
-          provider_type.c_str(),
+          vpn->name(),
+          vpn->server_hostname(),
+          provider_type,
           base::Bind(&NetworkServiceUpdate, this));
     }
   }
 
   return remembered;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // NetworkDevice list management functions.
 
 // Update device list, and request associated device updates.
 // |devices| represents a complete list of devices.
 void NetworkLibraryImplCros::UpdateNetworkDeviceList(const ListValue* devices) {
   NetworkDeviceMap old_device_map = device_map_;
   device_map_.clear();
   VLOG(2) << "Updating Device List.";
   for (ListValue::const_iterator iter = devices->begin();
        iter != devices->end(); ++iter) {
     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);
       }
       CrosRequestNetworkDeviceProperties(
-          device_path.c_str(),
+          device_path,
           base::Bind(&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;
   }
 }
 
 // static
 void NetworkLibraryImplCros::NetworkDeviceUpdate(
     void* object,
-    const char* device_path,
+    const std::string& device_path,
     const base::DictionaryValue* properties) {
   DCHECK(CrosLibrary::Get()->libcros_loaded());
   NetworkLibraryImplCros* networklib =
       static_cast<NetworkLibraryImplCros*>(object);
   DCHECK(networklib);
-  if (device_path) {
-    if (!properties) {
-      // device no longer exists.
-      networklib->DeleteDevice(std::string(device_path));
-    } else {
-      networklib->ParseNetworkDevice(std::string(device_path), *properties);
-    }
+  if (!properties) {
+    // device no longer exists.
+    networklib->DeleteDevice(device_path);
+  } else {
+    networklib->ParseNetworkDevice(device_path, *properties);
   }
 }
 
 void NetworkLibraryImplCros::ParseNetworkDevice(const std::string& device_path,
                                                 const DictionaryValue& info) {
   NetworkDeviceMap::iterator found = device_map_.find(device_path);
   NetworkDevice* device;
   if (found != device_map_.end()) {
     device = found->second;
     device->device_parser()->UpdateDeviceFromInfo(info, device);
@@ skipping 18 matching lines @@
         // Switch back to signed settings value.
         SetCellularDataRoamingAllowed(settings_value);
       }
     }
   }
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 }  // namespace chromeos