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 21 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 112 matching lines @@
  protected:
   ScopedGValue argument_gvalue_;
   ScopedGHashTable argument_ghash_table_;
   ScopedGHashTable result_ghash_table_;
   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";
+  const std::string service_path = "/";
+  const std::string 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 key1= "key1";
   const std::string string1 = "string1";
-  const char key2[] = "key2";
+  const std::string 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)));
+      g_hash_table_lookup(ghash_table, key1.c_str())));
   EXPECT_EQ(string2, static_cast<const char*>(
-      g_hash_table_lookup(ghash_table, key2)));
+      g_hash_table_lookup(ghash_table, key2.c_str())));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosClearNetworkServiceProperty) {
-  const char service_path[] = "/";
-  const char property[] = "property";
+  const std::string service_path = "/";
+  const std::string property = "property";
   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";
+  const std::string device_path = "/";
+  const std::string 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";
+  const std::string ipconfig_path = "/";
+  const std::string 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";
+  const std::string 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);
+  const std::string str = "string";
+  const base::StringValue value(str);
   CrosSetNetworkManagerProperty(property, value);
-  EXPECT_EQ(kString, g_value_get_string(argument_gvalue_.get()));
+  EXPECT_EQ(str, g_value_get_string(argument_gvalue_.get()));
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestCellularDataPlanUpdate) {
-  const char kModemServicePath[] = "/modem/service/path";
+  const std::string modem_service_path = "/modem/service/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestCellularDataPlanUpdate(kModemServicePath)).Times(1);
-  CrosRequestCellularDataPlanUpdate(kModemServicePath);
+              RequestCellularDataPlanUpdate(StrEq(modem_service_path)))
+      .Times(1);
+  CrosRequestCellularDataPlanUpdate(modem_service_path);
 }
 
 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.
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
@@ skipping 17 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), _))
       .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), _))
       .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), 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), _, _))
       .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), _, _))
       .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), _, _))
       .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), StrEq(profile_entry_path), _, _))
       .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), StrEq(security), _, _))
       .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), StrEq(server_hostname),
+                  StrEq(provider_name), _, _))
       .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";
+  const std::string service_path = "/service/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestNetworkServiceDisconnect(kServicePath)).Times(1);
-  CrosRequestNetworkServiceDisconnect(kServicePath);
+              RequestNetworkServiceDisconnect(StrEq(service_path))).Times(1);
+  CrosRequestNetworkServiceDisconnect(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosRequestRemoveNetworkService) {
-  const char kServicePath[] = "/service/path";
+  const std::string service_path = "/service/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
-              RequestRemoveNetworkService(kServicePath)).Times(1);
-  CrosRequestRemoveNetworkService(kServicePath);
+              RequestRemoveNetworkService(StrEq(service_path))).Times(1);
+  CrosRequestRemoveNetworkService(service_path);
 }
 
 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, CrosRemoveIPConfig) {
   IPConfig config = {};
   config.path = "/path";
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               RemoveIPConfig(&config)).Times(1);
   CrosRemoveIPConfig(&config);
 }
 
 TEST_F(CrosNetworkFunctionsLibcrosTest, CrosConfigureService) {
   EXPECT_CALL(*MockChromeOSNetwork::Get(),
               ConfigureService(_, _, _, _))
               .WillOnce(Invoke(
                   this, &CrosNetworkFunctionsLibcrosTest::OnConfigureService));
-  const char key1[] = "key1";
+  const std::string key1 = "key1";
   const std::string string1 = "string1";
-  const char key2[] = "key2";
+  const std::string key2 = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   CrosConfigureService(value);
 
   // Check the argument GHashTable.
   const GValue* string1_gvalue = static_cast<const GValue*>(
-      g_hash_table_lookup(argument_ghash_table_.get(), key1));
+      g_hash_table_lookup(argument_ghash_table_.get(), key1.c_str()));
   EXPECT_EQ(string1, g_value_get_string(string1_gvalue));
   const GValue* string2_gvalue = static_cast<const GValue*>(
-      g_hash_table_lookup(argument_ghash_table_.get(), key2));
+      g_hash_table_lookup(argument_ghash_table_.get(), key2.c_str()));
   EXPECT_EQ(string2, g_value_get_string(string2_gvalue));
 }
 
 // Test for cros_network_functions.cc without Libcros.
 class CrosNetworkFunctionsTest : public testing::Test {
  public:
   CrosNetworkFunctionsTest() : mock_profile_client_(NULL),
                                dictionary_value_result_(NULL) {}
 
   virtual void SetUp() {
@@ skipping 43 matching lines @@
   MockCashewClient* mock_cashew_client_;
   MockFlimflamDeviceClient* mock_device_client_;
   MockFlimflamIPConfigClient* mock_ipconfig_client_;
   MockFlimflamManagerClient* mock_manager_client_;
   MockFlimflamProfileClient* mock_profile_client_;
   MockFlimflamServiceClient* mock_service_client_;
   const base::DictionaryValue* dictionary_value_result_;
 };
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkServiceProperty) {
-  const char service_path[] = "/";
-  const char property[] = "property";
-  const char key1[] = "key1";
+  const std::string service_path = "/";
+  const std::string property = "property";
+  const std::string key1 = "key1";
   const std::string string1 = "string1";
-  const char key2[] = "key2";
+  const std::string key2 = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   EXPECT_CALL(*mock_service_client_,
               SetProperty(dbus::ObjectPath(service_path), property,
                           IsEqualTo(&value), _)).Times(1);
 
   CrosSetNetworkServiceProperty(service_path, property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosClearNetworkServiceProperty) {
-  const char service_path[] = "/";
-  const char property[] = "property";
+  const std::string service_path = "/";
+  const std::string property = "property";
   EXPECT_CALL(*mock_service_client_,
               ClearProperty(dbus::ObjectPath(service_path), property, _))
       .Times(1);
 
   CrosClearNetworkServiceProperty(service_path, property);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkDeviceProperty) {
-  const char device_path[] = "/";
-  const char property[] = "property";
+  const std::string device_path = "/";
+  const std::string 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, CrosSetNetworkIPConfigProperty) {
-  const char ipconfig_path[] = "/";
-  const char property[] = "property";
+  const std::string ipconfig_path = "/";
+  const std::string property = "property";
   const int kInt = 1234;
   const base::FundamentalValue value(kInt);
   EXPECT_CALL(*mock_ipconfig_client_,
               SetProperty(dbus::ObjectPath(ipconfig_path), property,
                           IsEqualTo(&value), _)).Times(1);
   CrosSetNetworkIPConfigProperty(ipconfig_path, property, value);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosSetNetworkManagerProperty) {
-  const char property[] = "property";
-  const std::string kString = "string";
-  const base::StringValue value(kString);
+  const std::string property = "property";
+  const base::StringValue value("string");
   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";
+  const std::string modem_service_path = "/modem/service/path";
   EXPECT_CALL(*mock_cashew_client_,
-              RequestDataPlansUpdate(kModemServicePath)).Times(1);
-  CrosRequestCellularDataPlanUpdate(kModemServicePath);
+              RequestDataPlansUpdate(modem_service_path)).Times(1);
+  CrosRequestCellularDataPlanUpdate(modem_service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosMonitorNetworkManagerProperties) {
   const std::string key = "key";
   const int kValue = 42;
   const base::FundamentalValue value(kValue);
   // Start monitoring.
   FlimflamClientHelper::PropertyChangedHandler handler;
   EXPECT_CALL(*mock_manager_client_, SetPropertyChangedHandler(_))
       .WillOnce(SaveArg<0>(&handler));
@@ skipping 10 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";
+  const std::string service_path = "/service/path";
   EXPECT_CALL(*mock_service_client_,
-              Disconnect(dbus::ObjectPath(kServicePath), _)).Times(1);
-  CrosRequestNetworkServiceDisconnect(kServicePath);
+              Disconnect(dbus::ObjectPath(service_path), _)).Times(1);
+  CrosRequestNetworkServiceDisconnect(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestRemoveNetworkService) {
-  const char kServicePath[] = "/service/path";
+  const std::string service_path = "/service/path";
   EXPECT_CALL(*mock_service_client_,
-              Remove(dbus::ObjectPath(kServicePath), _)).Times(1);
-  CrosRequestRemoveNetworkService(kServicePath);
+              Remove(dbus::ObjectPath(service_path), _)).Times(1);
+  CrosRequestRemoveNetworkService(service_path);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkScan) {
   EXPECT_CALL(*mock_manager_client_,
               RequestScan(flimflam::kTypeWifi, _)).Times(1);
   CrosRequestNetworkScan(flimflam::kTypeWifi);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkDeviceEnable) {
   const bool kEnable = true;
   EXPECT_CALL(*mock_manager_client_,
               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);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosRemoveIPConfig) {
   IPConfig config = {};
   config.path = "/path";
   EXPECT_CALL(*mock_ipconfig_client_,
               CallRemoveAndBlock(dbus::ObjectPath(config.path))).Times(1);
   CrosRemoveIPConfig(&config);
 }
 
 TEST_F(CrosNetworkFunctionsTest, CrosConfigureService) {
-  const char key1[] = "key1";
+  const std::string key1 = "key1";
   const std::string string1 = "string1";
-  const char key2[] = "key2";
+  const std::string key2 = "key2";
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   EXPECT_CALL(*mock_manager_client_, ConfigureService(IsEqualTo(&value), _))
       .Times(1);
   CrosConfigureService(value);
 }
 
 }  // namespace chromeos