Remove base::StringValue

chrome/browser/extensions/api/networking_private/networking_private_chromeos_apitest.cc

 // Copyright 2013 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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 213 matching lines @@
   }
 
   void SetupCellular() {
     UIDelegateStub::s_show_account_details_called_ = 0;
 
     // Add a Cellular GSM Device.
     device_test_->AddDevice(kCellularDevicePath, shill::kTypeCellular,
                             "stub_cellular_device1");
     device_test_->SetDeviceProperty(kCellularDevicePath,
                                     shill::kCarrierProperty,
-                                    base::StringValue("Cellular1_Carrier"));
+                                    base::Value("Cellular1_Carrier"));
     base::DictionaryValue home_provider;
     home_provider.SetString("name", "Cellular1_Provider");
     home_provider.SetString("code", "000000");
     home_provider.SetString("country", "us");
     device_test_->SetDeviceProperty(
         kCellularDevicePath, shill::kHomeProviderProperty, home_provider);
-    device_test_->SetDeviceProperty(
-        kCellularDevicePath, shill::kTechnologyFamilyProperty,
-        base::StringValue(shill::kNetworkTechnologyGsm));
+    device_test_->SetDeviceProperty(kCellularDevicePath,
+                                    shill::kTechnologyFamilyProperty,
+                                    base::Value(shill::kNetworkTechnologyGsm));
     device_test_->SetSimLocked(kCellularDevicePath, false);
 
     // Add the Cellular Service.
     AddService(kCellular1ServicePath, "cellular1", shill::kTypeCellular,
                shill::kStateIdle);
     service_test_->SetServiceProperty(
         kCellular1ServicePath, shill::kAutoConnectProperty, base::Value(true));
     service_test_->SetServiceProperty(
         kCellular1ServicePath, shill::kNetworkTechnologyProperty,
-        base::StringValue(shill::kNetworkTechnologyGsm));
+        base::Value(shill::kNetworkTechnologyGsm));
     service_test_->SetServiceProperty(
         kCellular1ServicePath, shill::kActivationStateProperty,
-        base::StringValue(shill::kActivationStateNotActivated));
-    service_test_->SetServiceProperty(
-        kCellular1ServicePath, shill::kRoamingStateProperty,
-        base::StringValue(shill::kRoamingStateHome));
+        base::Value(shill::kActivationStateNotActivated));
+    service_test_->SetServiceProperty(kCellular1ServicePath,
+                                      shill::kRoamingStateProperty,
+                                      base::Value(shill::kRoamingStateHome));
 
     profile_test_->AddService(kUser1ProfilePath, kCellular1ServicePath);
     content::RunAllPendingInMessageLoop();
   }
 
   void AddService(const std::string& service_path,
                   const std::string& name,
                   const std::string& type,
                   const std::string& state) {
     service_test_->AddService(service_path, service_path + "_guid", name, type,
@@ skipping 54 matching lines @@
     device_test_->AddDevice(kEthernetDevicePath, shill::kTypeEthernet,
                             "stub_ethernet_device1");
 
     device_test_->AddDevice(kWifiDevicePath, shill::kTypeWifi,
                             "stub_wifi_device1");
     base::ListValue wifi_ip_configs;
     wifi_ip_configs.AppendString(kIPConfigPath);
     device_test_->SetDeviceProperty(kWifiDevicePath, shill::kIPConfigsProperty,
                                     wifi_ip_configs);
     device_test_->SetDeviceProperty(kWifiDevicePath, shill::kAddressProperty,
-                                    base::StringValue("001122aabbcc"));
+                                    base::Value("001122aabbcc"));
 
     // Add Services
     AddService("stub_ethernet", "eth0", shill::kTypeEthernet,
                shill::kStateOnline);
     service_test_->SetServiceProperty(
         "stub_ethernet", shill::kProfileProperty,
-        base::StringValue(ShillProfileClient::GetSharedProfilePath()));
+        base::Value(ShillProfileClient::GetSharedProfilePath()));
     profile_test_->AddService(ShillProfileClient::GetSharedProfilePath(),
                               "stub_ethernet");
 
     AddService(kWifi1ServicePath, "wifi1", shill::kTypeWifi,
                shill::kStateOnline);
     service_test_->SetServiceProperty(kWifi1ServicePath,
                                       shill::kSecurityClassProperty,
-                                      base::StringValue(shill::kSecurityWep));
-    service_test_->SetServiceProperty(kWifi1ServicePath,
-                                      shill::kWifiBSsid,
-                                      base::StringValue("00:01:02:03:04:05"));
+                                      base::Value(shill::kSecurityWep));
+    service_test_->SetServiceProperty(kWifi1ServicePath, shill::kWifiBSsid,
+                                      base::Value("00:01:02:03:04:05"));
     service_test_->SetServiceProperty(
         kWifi1ServicePath, shill::kSignalStrengthProperty, base::Value(40));
     service_test_->SetServiceProperty(kWifi1ServicePath,
                                       shill::kProfileProperty,
-                                      base::StringValue(kUser1ProfilePath));
+                                      base::Value(kUser1ProfilePath));
     service_test_->SetServiceProperty(
         kWifi1ServicePath, shill::kConnectableProperty, base::Value(true));
     service_test_->SetServiceProperty(kWifi1ServicePath, shill::kDeviceProperty,
-                                      base::StringValue(kWifiDevicePath));
+                                      base::Value(kWifiDevicePath));
     base::DictionaryValue static_ipconfig;
     static_ipconfig.SetStringWithoutPathExpansion(shill::kAddressProperty,
                                                   "1.2.3.4");
     service_test_->SetServiceProperty(
         kWifi1ServicePath, shill::kStaticIPConfigProperty, static_ipconfig);
     base::ListValue frequencies1;
     frequencies1.AppendInteger(2400);
     service_test_->SetServiceProperty(
         kWifi1ServicePath, shill::kWifiFrequencyListProperty, frequencies1);
     service_test_->SetServiceProperty(kWifi1ServicePath, shill::kWifiFrequency,
                                       base::Value(2400));
     profile_test_->AddService(kUser1ProfilePath, kWifi1ServicePath);
 
     AddService(kWifi2ServicePath, "wifi2_PSK", shill::kTypeWifi,
                shill::kStateIdle);
     service_test_->SetServiceProperty(kWifi2ServicePath,
                                       shill::kSecurityClassProperty,
-                                      base::StringValue(shill::kSecurityPsk));
+                                      base::Value(shill::kSecurityPsk));
     service_test_->SetServiceProperty(
         kWifi2ServicePath, shill::kSignalStrengthProperty, base::Value(80));
     service_test_->SetServiceProperty(
         kWifi2ServicePath, shill::kConnectableProperty, base::Value(true));
 
     AddService("stub_wimax", "wimax", shill::kTypeWimax, shill::kStateOnline);
     service_test_->SetServiceProperty(
         "stub_wimax", shill::kSignalStrengthProperty, base::Value(40));
     service_test_->SetServiceProperty("stub_wimax", shill::kProfileProperty,
-                                      base::StringValue(kUser1ProfilePath));
+                                      base::Value(kUser1ProfilePath));
     service_test_->SetServiceProperty("stub_wimax", shill::kConnectableProperty,
                                       base::Value(true));
     profile_test_->AddService(kUser1ProfilePath, "stub_wimax");
 
     base::ListValue frequencies2;
     frequencies2.AppendInteger(2400);
     frequencies2.AppendInteger(5000);
     service_test_->SetServiceProperty(
         kWifi2ServicePath, shill::kWifiFrequencyListProperty, frequencies2);
     service_test_->SetServiceProperty(kWifi2ServicePath, shill::kWifiFrequency,
                                       base::Value(5000));
     service_test_->SetServiceProperty(kWifi2ServicePath,
                                       shill::kProfileProperty,
-                                      base::StringValue(kUser1ProfilePath));
+                                      base::Value(kUser1ProfilePath));
     profile_test_->AddService(kUser1ProfilePath, kWifi2ServicePath);
 
     AddService("stub_vpn1", "vpn1", shill::kTypeVPN, shill::kStateOnline);
-    service_test_->SetServiceProperty(
-        "stub_vpn1", shill::kProviderTypeProperty,
-        base::StringValue(shill::kProviderOpenVpn));
+    service_test_->SetServiceProperty("stub_vpn1", shill::kProviderTypeProperty,
+                                      base::Value(shill::kProviderOpenVpn));
     profile_test_->AddService(kUser1ProfilePath, "stub_vpn1");
 
     AddService("stub_vpn2", "vpn2", shill::kTypeVPN, shill::kStateOffline);
     service_test_->SetServiceProperty(
         "stub_vpn2", shill::kProviderTypeProperty,
-        base::StringValue(shill::kProviderThirdPartyVpn));
+        base::Value(shill::kProviderThirdPartyVpn));
     service_test_->SetServiceProperty(
         "stub_vpn2", shill::kProviderHostProperty,
-        base::StringValue("third_party_provider_extension_id"));
+        base::Value("third_party_provider_extension_id"));
     profile_test_->AddService(kUser1ProfilePath, "stub_vpn2");
 
     content::RunAllPendingInMessageLoop();
   }
 
  protected:
   NetworkPortalDetectorTestImpl* detector() { return detector_; }
 
   NetworkPortalDetectorTestImpl* detector_;
   ShillManagerClient::TestInterface* manager_test_;
@@ skipping 18 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, StartActivate) {
   SetupCellular();
   EXPECT_TRUE(RunNetworkingSubtest("startActivate")) << message_;
   EXPECT_EQ(1, UIDelegateStub::s_show_account_details_called_);
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, StartActivateSprint) {
   SetupCellular();
   // Set the carrier to Sprint.
-  device_test_->SetDeviceProperty(kCellularDevicePath,
-                                  shill::kCarrierProperty,
-                                  base::StringValue(shill::kCarrierSprint));
+  device_test_->SetDeviceProperty(kCellularDevicePath, shill::kCarrierProperty,
+                                  base::Value(shill::kCarrierSprint));
   EXPECT_TRUE(RunNetworkingSubtest("startActivateSprint")) << message_;
   EXPECT_EQ(0, UIDelegateStub::s_show_account_details_called_);
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
                        StartConnectNonexistent) {
   EXPECT_TRUE(RunNetworkingSubtest("startConnectNonexistent")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest,
@@ skipping 89 matching lines @@
 
 // TODO(stevenjb): Find a better way to set this up on Chrome OS.
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetManagedProperties) {
   const std::string uidata_blob =
       "{ \"user_settings\": {"
       "      \"WiFi\": {"
       "        \"Passphrase\": \"FAKE_CREDENTIAL_VPaJDV9x\" }"
       "    }"
       "}";
   service_test_->SetServiceProperty(kWifi2ServicePath, shill::kUIDataProperty,
-                                    base::StringValue(uidata_blob));
+                                    base::Value(uidata_blob));
   service_test_->SetServiceProperty(
       kWifi2ServicePath, shill::kAutoConnectProperty, base::Value(false));
 
   // Update the profile entry.
   profile_test_->AddService(kUser1ProfilePath, kWifi2ServicePath);
 
   content::RunAllPendingInMessageLoop();
 
   const std::string user_policy_blob =
       "{ \"NetworkConfigurations\": ["
       "    { \"GUID\": \"stub_wifi2\","
       "      \"Type\": \"WiFi\","
       "      \"Name\": \"My WiFi Network\","
       "      \"WiFi\": {"
       "        \"HexSSID\": \"77696669325F50534B\","  // "wifi2_PSK"
       "        \"Passphrase\": \"passphrase\","
       "        \"Recommended\": [ \"AutoConnect\", \"Passphrase\" ],"
       "        \"Security\": \"WPA-PSK\" }"
       "    }"
       "  ],"
       "  \"Certificates\": [],"
       "  \"Type\": \"UnencryptedConfiguration\""
       "}";
 
   policy::PolicyMap policy;
-  policy.Set(
-      policy::key::kOpenNetworkConfiguration, policy::POLICY_LEVEL_MANDATORY,
-      policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-      base::WrapUnique(new base::StringValue(user_policy_blob)), nullptr);
+  policy.Set(policy::key::kOpenNetworkConfiguration,
+             policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
+             policy::POLICY_SOURCE_CLOUD,
+             base::WrapUnique(new base::Value(user_policy_blob)), nullptr);
   provider_.UpdateChromePolicy(policy);
 
   content::RunAllPendingInMessageLoop();
 
   EXPECT_TRUE(RunNetworkingSubtest("getManagedProperties")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, GetErrorState) {
   chromeos::NetworkHandler::Get()->network_state_handler()->SetLastErrorForTest(
       kWifi1ServicePath, "TestErrorState");
@@ skipping 120 matching lines @@
 }
 
 // Tests subset of networking API for the networking API alias - to verify that
 // using API methods and event does not cause access exceptions (due to
 // missing permissions).
 IN_PROC_BROWSER_TEST_F(NetworkingPrivateChromeOSApiTest, Alias) {
   EXPECT_TRUE(RunPlatformAppTest("networking_private/alias")) << message_;
 }
 
 }  // namespace