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

chrome/browser/chromeos/cros/cros_network_functions_unittest.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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_network_functions.h"
 #include "chrome/browser/chromeos/cros/gvalue_util.h"
 #include "chrome/browser/chromeos/cros/mock_chromeos_network.h"
@@ skipping 20 matching lines @@
 namespace {
 
 const char kExamplePath[] = "/foo/bar/baz";
 
 // A mock to check arguments of NetworkPropertiesCallback and ensure that the
 // callback is called exactly once.
 class MockNetworkPropertiesCallback {
  public:
   // Creates a NetworkPropertiesCallback with expectations.
   static NetworkPropertiesCallback CreateCallback(
-      const char* expected_path,
+      const std::string& expected_path,
       const base::DictionaryValue& expected_result) {
     MockNetworkPropertiesCallback* mock_callback =
         new MockNetworkPropertiesCallback;
 
     EXPECT_CALL(*mock_callback,
-                Run(StrEq(expected_path), Pointee(IsEqualTo(&expected_result))))
+                Run(expected_path, Pointee(IsEqualTo(&expected_result))))
         .Times(1);
 
     return base::Bind(&MockNetworkPropertiesCallback::Run,
                       base::Owned(mock_callback));
   }
 
-  MOCK_METHOD2(Run, void(const char* path,
+  MOCK_METHOD2(Run, void(const std::string& path,
                          const base::DictionaryValue* result));
 };
 
 // A mock to check arguments of NetworkPropertiesWatcherCallback and ensure that
 // the callback is called exactly once.
 class MockNetworkPropertiesWatcherCallback {
  public:
   // Creates a NetworkPropertiesWatcherCallback with expectations.
   static NetworkPropertiesWatcherCallback CreateCallback(
       const std::string& expected_path,
@@ skipping 116 matching lines @@
   base::Callback<void(const char* path,
                       const char* key,
                       const GValue* gvalue)> property_changed_callback_;
 };
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosSetNetworkServiceProperty) {
   const char service_path[] = "/";
   const char property[] = "property";
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      SetNetworkServicePropertyGValue(service_path, property, _))
+      SetNetworkServicePropertyGValue(StrEq(service_path), StrEq(property), _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnSetNetworkPropertyGValue));
   const char key1[] = "key1";
   const std::string string1 = "string1";
   const char key2[] = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   CrosSetNetworkServiceProperty(service_path, property, value);
 
   // Check the argument GHashTable.
   GHashTable* ghash_table =
       static_cast<GHashTable*>(g_value_get_boxed(argument_gvalue_.get()));
   ASSERT_TRUE(ghash_table != NULL);
   EXPECT_EQ(string1, static_cast<const char*>(
       g_hash_table_lookup(ghash_table, key1)));
   EXPECT_EQ(string2, static_cast<const char*>(
       g_hash_table_lookup(ghash_table, key2)));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosClearNetworkServiceProperty) {
   const char service_path[] = "/";
   const char property[] = "property";

[stevenjb, 2012/04/20 17:18:28]

Shouldn't we use std::string here and elsewhere?

[hashimoto, 2012/04/22 05:44:50]

Sounds good.
Done.

   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              ClearNetworkServiceProperty(service_path, property)).Times(1);
+              ClearNetworkServiceProperty(StrEq(service_path),
+                                          StrEq(property))).Times(1);
   CrosClearNetworkServiceProperty(service_path, property);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosSetNetworkDeviceProperty) {
   const char device_path[] = "/";
   const char property[] = "property";
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      SetNetworkDevicePropertyGValue(device_path, property, _))
+      SetNetworkDevicePropertyGValue(StrEq(device_path), StrEq(property), _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnSetNetworkPropertyGValue));
   const bool kBool = true;
   const base::FundamentalValue value(kBool);
   CrosSetNetworkDeviceProperty(device_path, property, value);
   EXPECT_EQ(kBool, g_value_get_boolean(argument_gvalue_.get()));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosSetNetworkIPConfigProperty) {
   const char ipconfig_path[] = "/";
   const char property[] = "property";
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      SetNetworkIPConfigPropertyGValue(ipconfig_path, property, _))
+      SetNetworkIPConfigPropertyGValue(StrEq(ipconfig_path),
+                                       StrEq(property), _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnSetNetworkPropertyGValue));
   const int kInt = 1234;
   const base::FundamentalValue value(kInt);
   CrosSetNetworkIPConfigProperty(ipconfig_path, property, value);
   EXPECT_EQ(kInt, g_value_get_int(argument_gvalue_.get()));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosSetNetworkManagerProperty) {
   const char property[] = "property";
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      SetNetworkManagerPropertyGValue(property, _))
+      SetNetworkManagerPropertyGValue(StrEq(property), _))
       .WillOnce(Invoke(
           this,
           &CrosNetworkFunctionsLibcrosTest::OnSetNetworkManagerPropertyGValue));
   const std::string kString = "string";
   const base::StringValue value(kString);
   CrosSetNetworkManagerProperty(property, value);
   EXPECT_EQ(kString, g_value_get_string(argument_gvalue_.get()));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestCellularDataPlanUpdate) {
   const char kModemServicePath[] = "/modem/service/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestCellularDataPlanUpdate(kModemServicePath)).Times(1);
+              RequestCellularDataPlanUpdate(StrEq(kModemServicePath))).Times(1);
   CrosRequestCellularDataPlanUpdate(kModemServicePath);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosMonitorNetworkManagerProperties) {
   const std::string path = "path";
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
 
   // Start monitoring.
@@ skipping 18 matching lines @@
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosMonitorNetworkServiceProperties) {
   const std::string path = "path";
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
 
   // Start monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              MonitorNetworkServiceProperties(_, path.c_str(), _))
+              MonitorNetworkServiceProperties(_, StrEq(path.c_str()), _))

[stevenjb, 2012/04/20 17:18:28]

Do we need to use StrEq and .c_str() here and elsewhere?

[hashimoto, 2012/04/22 05:44:50]

I didn't know that StrEq can take a std::string as an argument, thanks.
Done.

       .WillOnce(Invoke(
           this,
           &CrosNetworkFunctionsLibcrosTest::OnMonitorNetworkProperties));
   CrosNetworkWatcher* watcher = CrosMonitorNetworkServiceProperties(
       MockNetworkPropertiesWatcherCallback::CreateCallback(path, key, value),
       path);
 
   // Call callback.
   ScopedGValue gvalue(new GValue());
   g_value_init(gvalue.get(), G_TYPE_INT);
   g_value_set_int(gvalue.get(), kValue);
   property_changed_callback_.Run(path.c_str(), key.c_str(), gvalue.get());
 
   // Stop monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               DisconnectNetworkPropertiesMonitor(_)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosMonitorNetworkDeviceProperties) {
   const std::string path = "path";
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
 
   // Start monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              MonitorNetworkDeviceProperties(_, path.c_str(), _))
+              MonitorNetworkDeviceProperties(_, StrEq(path.c_str()), _))
       .WillOnce(Invoke(
           this,
           &CrosNetworkFunctionsLibcrosTest::OnMonitorNetworkProperties));
   CrosNetworkWatcher* watcher = CrosMonitorNetworkDeviceProperties(
       MockNetworkPropertiesWatcherCallback::CreateCallback(path, key, value),
       path);
 
   // Call callback.
   ScopedGValue gvalue(new GValue());
   g_value_init(gvalue.get(), G_TYPE_INT);
@@ skipping 23 matching lines @@
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosMonitorSMS) {
   const std::string modem_device_path = "/modem/device/path";
   MonitorSMSCallback callback =
       reinterpret_cast<MonitorSMSCallback>(42);  // Dummy value.
   void* object = reinterpret_cast<void*>(84);  // Dummy value.
 
   // Start monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              MonitorSMS(modem_device_path.c_str(), callback, object)).Times(1);
+              MonitorSMS(StrEq(modem_device_path.c_str()), callback, object))
+      .Times(1);
   CrosNetworkWatcher* watcher = CrosMonitorSMS(
       modem_device_path, callback, object);
 
   // Stop monitoring.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               DisconnectSMSMonitor(_)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkManagerProperties) {
@@ skipping 26 matching lines @@
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
       ConvertDictionaryValueToStringValueGHashTable(result));
   // Set expectations.
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      RequestNetworkServiceProperties(service_path.c_str(), _, _))
+      RequestNetworkServiceProperties(StrEq(service_path.c_str()), _, _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnRequestNetworkProperties3));
 
   CrosRequestNetworkServiceProperties(
-      service_path.c_str(),
+      service_path,
       MockNetworkPropertiesCallback::CreateCallback(kExamplePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkDeviceProperties) {
   const std::string device_path = "device path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
       ConvertDictionaryValueToStringValueGHashTable(result));
   // Set expectations.
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      RequestNetworkDeviceProperties(device_path.c_str(), _, _))
+      RequestNetworkDeviceProperties(StrEq(device_path.c_str()), _, _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnRequestNetworkProperties3));
 
   CrosRequestNetworkDeviceProperties(
-      device_path.c_str(),
+      device_path,
       MockNetworkPropertiesCallback::CreateCallback(kExamplePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkProfileProperties) {
   const std::string profile_path = "profile path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
       ConvertDictionaryValueToStringValueGHashTable(result));
   // Set expectations.
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      RequestNetworkProfileProperties(profile_path.c_str(), _, _))
+      RequestNetworkProfileProperties(StrEq(profile_path.c_str()), _, _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnRequestNetworkProperties3));
 
   CrosRequestNetworkProfileProperties(
-      profile_path.c_str(),
+      profile_path,
       MockNetworkPropertiesCallback::CreateCallback(kExamplePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest,
        CrosRequestNetworkProfileEntryProperties) {
   const std::string profile_path = "profile path";
   const std::string profile_entry_path = "profile entry path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
       ConvertDictionaryValueToStringValueGHashTable(result));
   // Set expectations.
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      RequestNetworkProfileEntryProperties(profile_path.c_str(),
-                                           profile_entry_path.c_str(), _, _))
+      RequestNetworkProfileEntryProperties(
+          StrEq(profile_path.c_str()), StrEq(profile_entry_path.c_str()), _, _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnRequestNetworkProperties4));
 
   CrosRequestNetworkProfileEntryProperties(
-      profile_path.c_str(),
-      profile_entry_path.c_str(),
+      profile_path,
+      profile_entry_path,
       MockNetworkPropertiesCallback::CreateCallback(kExamplePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest,
        CrosRequestHiddenWifiNetworkProperties) {
   const std::string ssid = "ssid";
   const std::string security = "security";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
       ConvertDictionaryValueToStringValueGHashTable(result));
   // Set expectations.
   EXPECT_CALL(
       *MockChromeOSNetwork::Get(),
-      RequestHiddenWifiNetworkProperties(ssid.c_str(), security.c_str(), _, _))
+      RequestHiddenWifiNetworkProperties(
+          StrEq(ssid.c_str()), StrEq(security.c_str()), _, _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnRequestNetworkProperties4));
 
   CrosRequestHiddenWifiNetworkProperties(
-      ssid.c_str(), security.c_str(),
+      ssid, security,
       MockNetworkPropertiesCallback::CreateCallback(kExamplePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestVirtualNetworkProperties) {
   const std::string service_name = "service name";
   const std::string server_hostname = "server hostname";
   const std::string provider_name = "provider name";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   result_ghash_table_.reset(
       ConvertDictionaryValueToStringValueGHashTable(result));
   // Set expectations.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestVirtualNetworkProperties(service_name.c_str(),
-                                              server_hostname.c_str(),
-                                              provider_name.c_str(), _, _))
+              RequestVirtualNetworkProperties(
+                  StrEq(service_name.c_str()), StrEq(server_hostname.c_str()),
+                  StrEq(provider_name.c_str()), _, _))
       .WillOnce(Invoke(
           this, &CrosNetworkFunctionsLibcrosTest::OnRequestNetworkProperties5));
 
   CrosRequestVirtualNetworkProperties(
-      service_name.c_str(),
-      server_hostname.c_str(),
-      provider_name.c_str(),
+      service_name,
+      server_hostname,
+      provider_name,
       MockNetworkPropertiesCallback::CreateCallback(kExamplePath, result));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkServiceDisconnect) {
   const char kServicePath[] = "/service/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestNetworkServiceDisconnect(kServicePath)).Times(1);
+              RequestNetworkServiceDisconnect(StrEq(kServicePath))).Times(1);
   CrosRequestNetworkServiceDisconnect(kServicePath);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestRemoveNetworkService) {
   const char kServicePath[] = "/service/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestRemoveNetworkService(kServicePath)).Times(1);
+              RequestRemoveNetworkService(StrEq(kServicePath))).Times(1);
   CrosRequestRemoveNetworkService(kServicePath);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkScan) {
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestNetworkScan(flimflam::kTypeWifi)).Times(1);
+              RequestNetworkScan(StrEq(flimflam::kTypeWifi))).Times(1);
   CrosRequestNetworkScan(flimflam::kTypeWifi);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestNetworkDeviceEnable) {
   const bool kEnable = true;
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestNetworkDeviceEnable(flimflam::kTypeWifi, kEnable))
+              RequestNetworkDeviceEnable(StrEq(flimflam::kTypeWifi), kEnable))
       .Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kEnable);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosConfigureService) {
   const char identifier[] = "identifier";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              ConfigureService(identifier, _, &OnNetworkAction, this))
+              ConfigureService(StrEq(identifier), _, &OnNetworkAction, this))
               .WillOnce(Invoke(
                   this, &CrosNetworkFunctionsLibcrosTest::OnConfigureService));
   const char key1[] = "key1";
   const std::string string1 = "string1";
   const char key2[] = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   CrosConfigureService(identifier, value, &OnNetworkAction, this);
@@ skipping 89 matching lines @@
 
   CrosClearNetworkServiceProperty(service_path, property);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkDeviceProperty) {
   const char device_path[] = "/";
   const char property[] = "property";
   const bool kBool = true;
   const base::FundamentalValue value(kBool);
   EXPECT_CALL(*mock_device_client_,
-              SetProperty(dbus::ObjectPath(device_path), property,
+              SetProperty(dbus::ObjectPath(device_path), StrEq(property),
                           IsEqualTo(&value), _)).Times(1);
 
   CrosSetNetworkDeviceProperty(device_path, property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkManagerProperty) {
   const char property[] = "property";
   const std::string kString = "string";
   const base::StringValue value(kString);
   EXPECT_CALL(*mock_manager_client_,
               SetProperty(property, IsEqualTo(&value), _)).Times(1);
 
   CrosSetNetworkManagerProperty(property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosDeleteServiceFromProfile) {
   const std::string profile_path("/profile/path");
   const std::string service_path("/service/path");
   EXPECT_CALL(*mock_profile_client_,
               DeleteEntry(dbus::ObjectPath(profile_path), service_path, _))
       .Times(1);
-  CrosDeleteServiceFromProfile(profile_path.c_str(), service_path.c_str());
+  CrosDeleteServiceFromProfile(profile_path, service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestCellularDataPlanUpdate) {
   const char kModemServicePath[] = "/modem/service/path";
   EXPECT_CALL(*mock_cashew_client_,
               RequestDataPlansUpdate(kModemServicePath)).Times(1);
   CrosRequestCellularDataPlanUpdate(kModemServicePath);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkManagerProperties) {
@@ skipping 17 matching lines @@
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkServiceProperties) {
   const dbus::ObjectPath path("/path");
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
   // Start monitoring.
   FlimflamClientHelper::PropertyChangedHandler handler;
   EXPECT_CALL(*mock_service_client_, SetPropertyChangedHandler(path, _))
       .WillOnce(SaveArg<1>(&handler));
   NetworkPropertiesWatcherCallback callback =
-      MockNetworkPropertiesWatcherCallback::CreateCallback(path.value().c_str(),
+      MockNetworkPropertiesWatcherCallback::CreateCallback(path.value(),
                                                            key, value);
   CrosNetworkWatcher* watcher = CrosMonitorNetworkServiceProperties(
-      callback, path.value().c_str());
+      callback, path.value());
   // Call callback.
   handler.Run(key, value);
   // Stop monitoring.
   EXPECT_CALL(*mock_service_client_,
               ResetPropertyChangedHandler(path)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkDeviceProperties) {
   const dbus::ObjectPath path("/path");
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
   // Start monitoring.
   FlimflamClientHelper::PropertyChangedHandler handler;
   EXPECT_CALL(*mock_device_client_, SetPropertyChangedHandler(path, _))
       .WillOnce(SaveArg<1>(&handler));
   NetworkPropertiesWatcherCallback callback =
-      MockNetworkPropertiesWatcherCallback::CreateCallback(path.value().c_str(),
+      MockNetworkPropertiesWatcherCallback::CreateCallback(path.value(),
                                                            key, value);
   CrosNetworkWatcher* watcher = CrosMonitorNetworkDeviceProperties(
-      callback, path.value().c_str());
+      callback, path.value());
   // Call callback.
   handler.Run(key, value);
   // Stop monitoring.
   EXPECT_CALL(*mock_device_client_,
               ResetPropertyChangedHandler(path)).Times(1);
   delete watcher;
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkManagerProperties) {
   const std::string key1 = "key1";
@@ skipping 26 matching lines @@
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_service_client_,
               GetProperties(dbus::ObjectPath(service_path), _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   CrosRequestNetworkServiceProperties(
-      service_path.c_str(),
-      MockNetworkPropertiesCallback::CreateCallback(service_path.c_str(),
-                                                    result));
+      service_path,
+      MockNetworkPropertiesCallback::CreateCallback(service_path, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkDeviceProperties) {
   const std::string device_path = "/device/path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_device_client_,
               GetProperties(dbus::ObjectPath(device_path), _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   CrosRequestNetworkDeviceProperties(
-      device_path.c_str(),
-      MockNetworkPropertiesCallback::CreateCallback(device_path.c_str(),
-                                                    result));
+      device_path,
+      MockNetworkPropertiesCallback::CreateCallback(device_path, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkProfileProperties) {
   const std::string profile_path = "/profile/path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(profile_path), _)).WillOnce(
                   Invoke(this, &CrosNetworkFunctionsTest::OnGetProperties));
 
   CrosRequestNetworkProfileProperties(
-      profile_path.c_str(),
-      MockNetworkPropertiesCallback::CreateCallback(profile_path.c_str(),
-                                                    result));
+      profile_path,
+      MockNetworkPropertiesCallback::CreateCallback(profile_path, result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkProfileEntryProperties) {
   const std::string profile_path = "profile path";
   const std::string profile_entry_path = "profile entry path";
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
   dictionary_value_result_ = &result;
   EXPECT_CALL(*mock_profile_client_,
               GetEntry(dbus::ObjectPath(profile_path), profile_entry_path, _))
       .WillOnce(Invoke(this, &CrosNetworkFunctionsTest::OnGetEntry));
 
   CrosRequestNetworkProfileEntryProperties(
-      profile_path.c_str(), profile_entry_path.c_str(),
-      MockNetworkPropertiesCallback::CreateCallback(profile_entry_path.c_str(),
+      profile_path, profile_entry_path,
+      MockNetworkPropertiesCallback::CreateCallback(profile_entry_path,
                                                     result));
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkServiceDisconnect) {
   const char kServicePath[] = "/service/path";
   EXPECT_CALL(*mock_service_client_,
               Disconnect(dbus::ObjectPath(kServicePath), _)).Times(1);
   CrosRequestNetworkServiceDisconnect(kServicePath);
 }
 
@@ skipping 16 matching lines @@
               EnableTechnology(flimflam::kTypeWifi, _)).Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kEnable);
 
   const bool kDisable = false;
   EXPECT_CALL(*mock_manager_client_,
               DisableTechnology(flimflam::kTypeWifi, _)).Times(1);
   CrosRequestNetworkDeviceEnable(flimflam::kTypeWifi, kDisable);
 }
 
 }  // namespace chromeos