Remove base::StringValue

chrome/browser/chromeos/arc/intent_helper/arc_settings_service_browsertest.cc

 // Copyright 2016 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 <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 238 matching lines @@
     provider_.UpdateChromePolicy(policy);
     RunUntilIdle();
   }
 
  protected:
   void DisconnectNetworkService(const std::string& service_path) {
     chromeos::ShillServiceClient::TestInterface* service_test =
         chromeos::DBusThreadManager::Get()
             ->GetShillServiceClient()
             ->GetTestInterface();
-    base::StringValue value(shill::kStateIdle);
+    base::Value value(shill::kStateIdle);
     service_test->SetServiceProperty(service_path, shill::kStateProperty,
                                      value);
     RunUntilIdle();
   }
 
   void ConnectWifiNetworkService(const std::string& service_path,
                                  const std::string& guid,
                                  const std::string& ssid) {
     chromeos::ShillServiceClient::TestInterface* service_test =
         chromeos::DBusThreadManager::Get()
             ->GetShillServiceClient()
             ->GetTestInterface();
 
     service_test->AddService(service_path, guid, ssid, shill::kTypeWifi,
                              shill::kStateOnline, true /* add_to_visible */);
 
     service_test->SetServiceProperty(service_path, shill::kProfileProperty,
-                                     base::StringValue(kUserProfilePath));
+                                     base::Value(kUserProfilePath));
     RunUntilIdle();
   }
 
   void SetProxyConfigForNetworkService(
       const std::string& service_path,
       const base::DictionaryValue* proxy_config) {
     ProxyConfigDictionary proxy_config_dict(proxy_config);
     const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
                                                 ->network_state_handler()
                                                 ->GetNetworkState(service_path);
@@ skipping 17 matching lines @@
 
     profile_test->AddProfile(kUserProfilePath, "user");
 
     service_test->ClearServices();
 
     service_test->AddService(kDefaultServicePath, "stub_ethernet_guid", "eth0",
                              shill::kTypeEthernet, shill::kStateOnline,
                              true /* add_to_visible */);
     service_test->SetServiceProperty(kDefaultServicePath,
                                      shill::kProfileProperty,
-                                     base::StringValue(kUserProfilePath));
+                                     base::Value(kUserProfilePath));
   }
 
   policy::MockConfigurationPolicyProvider provider_;
 
   DISALLOW_COPY_AND_ASSIGN(ArcSettingsServiceTest);
 };
 
 IN_PROC_BROWSER_TEST_F(ArcSettingsServiceTest, BackupRestorePolicyTest) {
   PrefService* const prefs = browser()->profile()->GetPrefs();
 
@@ skipping 123 matching lines @@
             1);
 }
 
 IN_PROC_BROWSER_TEST_F(ArcSettingsServiceTest, ProxyModePolicyTest) {
   fake_intent_helper_instance_->clear_broadcasts();
 
   policy::PolicyMap policy;
   policy.Set(
       policy::key::kProxyMode, policy::POLICY_LEVEL_MANDATORY,
       policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-      base::MakeUnique<base::StringValue>(ProxyPrefs::kAutoDetectProxyModeName),
+      base::MakeUnique<base::Value>(ProxyPrefs::kAutoDetectProxyModeName),
       nullptr);
   UpdatePolicy(policy);
 
   std::unique_ptr<base::DictionaryValue> expected_proxy_config(
       base::MakeUnique<base::DictionaryValue>());
   expected_proxy_config->SetString("mode",
                                    ProxyPrefs::kAutoDetectProxyModeName);
   expected_proxy_config->SetString("pacUrl", "http://wpad/wpad.dat");
   EXPECT_EQ(CountProxyBroadcasts(fake_intent_helper_instance_->broadcasts(),
                                  expected_proxy_config.get()),
             1);
 }
 
 IN_PROC_BROWSER_TEST_F(ArcSettingsServiceTest, ONCProxyPolicyTest) {
   fake_intent_helper_instance_->clear_broadcasts();
 
   policy::PolicyMap policy;
   policy.Set(policy::key::kOpenNetworkConfiguration,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
              policy::POLICY_SOURCE_CLOUD,
-             base::MakeUnique<base::StringValue>(kONCPolicy), nullptr);
+             base::MakeUnique<base::Value>(kONCPolicy), nullptr);
   UpdatePolicy(policy);
 
   std::unique_ptr<base::DictionaryValue> expected_proxy_config(
       base::MakeUnique<base::DictionaryValue>());
   expected_proxy_config->SetString("mode", ProxyPrefs::kPacScriptProxyModeName);
   expected_proxy_config->SetString("pacUrl", kONCPacUrl);
 
   EXPECT_EQ(CountProxyBroadcasts(fake_intent_helper_instance_->broadcasts(),
                                  expected_proxy_config.get()),
             1);
 }
 
 // Proxy policy has a higher priority than proxy default settings.
 IN_PROC_BROWSER_TEST_F(ArcSettingsServiceTest, TwoSourcesTest) {
   fake_intent_helper_instance_->clear_broadcasts();
 
   policy::PolicyMap policy;
   // Proxy policy.
-  policy.Set(policy::key::kProxyMode, policy::POLICY_LEVEL_MANDATORY,
-             policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-             base::MakeUnique<base::StringValue>(
-                 ProxyPrefs::kFixedServersProxyModeName),
-             nullptr);
+  policy.Set(
+      policy::key::kProxyMode, policy::POLICY_LEVEL_MANDATORY,
+      policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
+      base::MakeUnique<base::Value>(ProxyPrefs::kFixedServersProxyModeName),
+      nullptr);
   policy.Set(policy::key::kProxyServer, policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-             base::MakeUnique<base::StringValue>("proxy:8888"), nullptr);
+             base::MakeUnique<base::Value>("proxy:8888"), nullptr);
   UpdatePolicy(policy);
 
   std::unique_ptr<base::DictionaryValue> proxy_config(
       base::MakeUnique<base::DictionaryValue>());
   proxy_config->SetString("mode", ProxyPrefs::kAutoDetectProxyModeName);
   ProxyConfigDictionary proxy_config_dict(proxy_config.get());
   const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
                                               ->network_state_handler()
                                               ->DefaultNetwork();
   ASSERT_TRUE(network);
@@ skipping 117 matching lines @@
 
   // Disconnect default network.
   DisconnectNetworkService(kDefaultServicePath);
 
   fake_intent_helper_instance_->clear_broadcasts();
 
   policy::PolicyMap policy;
   policy.Set(policy::key::kOpenNetworkConfiguration,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER,
              policy::POLICY_SOURCE_CLOUD,
-             base::MakeUnique<base::StringValue>(kUserONCPolicy), nullptr);
+             base::MakeUnique<base::Value>(kUserONCPolicy), nullptr);
   policy.Set(policy::key::kDeviceOpenNetworkConfiguration,
              policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_MACHINE,
              policy::POLICY_SOURCE_CLOUD,
-             base::MakeUnique<base::StringValue>(kDeviceONCPolicy), nullptr);
+             base::MakeUnique<base::Value>(kDeviceONCPolicy), nullptr);
   UpdatePolicy(policy);
 
   std::unique_ptr<base::DictionaryValue> expected_proxy_config(
       base::MakeUnique<base::DictionaryValue>());
   expected_proxy_config->SetString("mode",
                                    ProxyPrefs::kFixedServersProxyModeName);
   expected_proxy_config->SetString("host", "proxy");
   expected_proxy_config->SetInteger("port", 5000);
 
   EXPECT_EQ(CountProxyBroadcasts(fake_intent_helper_instance_->broadcasts(),
@@ skipping 10 matching lines @@
                                    ProxyPrefs::kFixedServersProxyModeName);
   expected_proxy_config->SetString("host", "proxy-n300");
   expected_proxy_config->SetInteger("port", 3000);
 
   EXPECT_EQ(CountProxyBroadcasts(fake_intent_helper_instance_->broadcasts(),
                                  expected_proxy_config.get()),
             1);
 }
 
 }  // namespace arc