Remove base::StringValue

chrome/browser/ui/webui/options/preferences_browsertest.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/ui/webui/options/preferences_browsertest.h"
 
 #include <stddef.h>
 
 #include <iostream>
 #include <memory>
@@ skipping 242 matching lines @@
     const std::unique_ptr<base::Value>& value,
     const std::string& controlledBy,
     bool disabled,
     bool uncommitted) {
   const base::Value* pref = NULL;
   const base::DictionaryValue* dict = NULL;
   ASSERT_TRUE(prefs->GetWithoutPathExpansion(name, &pref));
   ASSERT_TRUE(pref->GetAsDictionary(&dict));
   VerifyKeyValue(*dict, "value", *value);
   if (!controlledBy.empty())
-    VerifyKeyValue(*dict, "controlledBy", base::StringValue(controlledBy));
+    VerifyKeyValue(*dict, "controlledBy", base::Value(controlledBy));
   else
     EXPECT_FALSE(dict->HasKey("controlledBy"));
 
   if (disabled)
     VerifyKeyValue(*dict, "disabled", base::Value(true));
   else if (dict->HasKey("disabled"))
     VerifyKeyValue(*dict, "disabled", base::Value(false));
 
   if (uncommitted)
     VerifyKeyValue(*dict, "uncommitted", base::Value(true));
@@ skipping 408 matching lines @@
 // CoreChromeOSOptionsHandler class.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest, ChromeOSDeviceFetchPrefs) {
   std::string observed_json;
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kAccountsPrefAllowGuest);
   default_values_.push_back(base::MakeUnique<base::Value>(true));
 
   // String pref.
   pref_names_.push_back(chromeos::kReleaseChannel);
-  default_values_.push_back(base::MakeUnique<base::StringValue>(""));
+  default_values_.push_back(base::MakeUnique<base::Value>(""));
 
   // List pref.
   pref_names_.push_back(chromeos::kAccountsPrefUsers);
   default_values_.push_back(base::MakeUnique<base::ListValue>());
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, default_values_, "owner",
                       true, false);
 }
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for non-privileged pref values handled by the
 // CoreChromeOSOptionsHandler class.
 IN_PROC_BROWSER_TEST_F(PreferencesBrowserTest,
                        ChromeOSDeviceFetchNonPrivilegedPrefs) {
   std::vector<std::unique_ptr<base::Value>> decorated_non_default_values;
   std::string observed_json;
 
   // Non-privileged string pref.
   pref_names_.push_back(chromeos::kSystemTimezone);
   default_values_.push_back(
-      base::MakeUnique<base::StringValue>("America/Los_Angeles"));
+      base::MakeUnique<base::Value>("America/Los_Angeles"));
   non_default_values_.push_back(
-      base::MakeUnique<base::StringValue>("America/New_York"));
+      base::MakeUnique<base::Value>("America/New_York"));
   decorated_non_default_values.push_back(
       non_default_values_.back()->CreateDeepCopy());
 
   // Verify notifications when default values are in effect.
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, default_values_,
                       std::string(), false, false);
 
   chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
   cros_settings->Set(pref_names_[0], *non_default_values_[0]);
@@ skipping 29 matching lines @@
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kAccountsPrefAllowGuest);
   non_default_values_.push_back(base::MakeUnique<base::Value>(false));
   decorated_non_default_values.push_back(
       non_default_values_.back()->CreateDeepCopy());
 
   // String pref.
   pref_names_.push_back(chromeos::kReleaseChannel);
   non_default_values_.push_back(
-      base::MakeUnique<base::StringValue>("stable-channel"));
+      base::MakeUnique<base::Value>("stable-channel"));
   decorated_non_default_values.push_back(
       non_default_values_.back()->CreateDeepCopy());
 
   // List pref.
   pref_names_.push_back(chromeos::kAccountsPrefUsers);
   auto list = base::MakeUnique<base::ListValue>();
   list->AppendString("me@google.com");
   list->AppendString("you@google.com");
   non_default_values_.push_back(std::move(list));
   list = base::MakeUnique<base::ListValue>();
@@ skipping 26 matching lines @@
 // notifications in JavaScript for non-privileged pref values handled by the
 // CoreChromeOSOptionsHandler class for a managed device.
 IN_PROC_BROWSER_TEST_F(ManagedPreferencesBrowserTest,
                        ChromeOSDeviceFetchNonPrivilegedPrefs) {
   std::vector<std::unique_ptr<base::Value>> decorated_non_default_values;
   std::string observed_json;
 
   // Non-privileged string pref.
   pref_names_.push_back(chromeos::kSystemTimezone);
   non_default_values_.push_back(
-      base::MakeUnique<base::StringValue>("America/New_York"));
+      base::MakeUnique<base::Value>("America/New_York"));
   decorated_non_default_values.push_back(
       non_default_values_.back()->CreateDeepCopy());
 
   // Verify notifications when mandatory values are in effect.
   chromeos::CrosSettings* cros_settings = chromeos::CrosSettings::Get();
   cros_settings->Set(pref_names_[0], *non_default_values_[0]);
 
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, decorated_non_default_values,
                       std::string(), false, false);
@@ skipping 40 matching lines @@
 
     profile_test->AddProfile(kUserProfilePath, "user");
 
     service_test->ClearServices();
     service_test->AddService("stub_ethernet",
                              "stub_ethernet_guid",
                              "eth0",
                              shill::kTypeEthernet,
                              shill::kStateOnline,
                              true /* add_to_visible */ );
-    service_test->SetServiceProperty("stub_ethernet",
-                                     shill::kProfileProperty,
-                                     base::StringValue(kUserProfilePath));
+    service_test->SetServiceProperty("stub_ethernet", shill::kProfileProperty,
+                                     base::Value(kUserProfilePath));
     profile_test->AddService(kUserProfilePath, "stub_wifi2");
   }
 
   void SetONCPolicy(const char* policy_name, policy::PolicyScope scope) {
     std::string onc_policy =
         "{ \"NetworkConfigurations\": ["
         "    { \"GUID\": \"stub_ethernet_guid\","
         "      \"Type\": \"Ethernet\","
         "      \"Name\": \"My Ethernet\","
         "      \"Ethernet\": {"
         "        \"Authentication\": \"None\" },"
         "      \"ProxySettings\": {"
         "        \"PAC\": \"http://domain.com/x\","
         "        \"Type\": \"PAC\" }"
         "    }"
         "  ],"
         "  \"Type\": \"UnencryptedConfiguration\""
         "}";
 
     policy::PolicyMap map;
     map.Set(policy_name, policy::POLICY_LEVEL_MANDATORY, scope,
             policy::POLICY_SOURCE_CLOUD,
-            base::MakeUnique<base::StringValue>(onc_policy), nullptr);
+            base::MakeUnique<base::Value>(onc_policy), nullptr);
     policy_provider_.UpdateChromePolicy(map);
 
     content::RunAllPendingInMessageLoop();
   }
 
   const chromeos::NetworkState* GetDefaultNetwork() {
     chromeos::NetworkStateHandler* handler =
         chromeos::NetworkHandler::Get()->network_state_handler();
     return handler->DefaultNetwork();
   }
@@ skipping 42 matching lines @@
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxySingle);
   non_default_values_.push_back(base::MakeUnique<base::Value>(true));
 
   // Integer prefs.
   pref_names_.push_back(
       chromeos::proxy_cros_settings_parser::kProxySingleHttpPort);
   non_default_values_.push_back(base::MakeUnique<base::Value>(8080));
 
   // String pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxySingleHttp);
-  non_default_values_.push_back(
-      base::MakeUnique<base::StringValue>("127.0.0.1"));
+  non_default_values_.push_back(base::MakeUnique<base::Value>("127.0.0.1"));
 
   // List pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyIgnoreList);
   auto list = base::MakeUnique<base::ListValue>();
   list->AppendString("*.google.com");
   list->AppendString("1.2.3.4:22");
   non_default_values_.push_back(std::move(list));
 
   // Verify that no policy is presented to the UI. This must be verified on the
   // kProxyType and the kUseSharedProxies prefs.
@@ skipping 54 matching lines @@
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
   non_default_values_.push_back(base::MakeUnique<base::Value>(false));
 
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "",
                       false, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, UserProxyPolicy) {
   policy_names_.push_back(policy::key::kProxyMode);
-  default_values_.push_back(base::MakeUnique<base::StringValue>(
-      ProxyPrefs::kAutoDetectProxyModeName));
+  default_values_.push_back(
+      base::MakeUnique<base::Value>(ProxyPrefs::kAutoDetectProxyModeName));
   SetUserPolicies(policy_names_, default_values_,
                   policy::POLICY_LEVEL_MANDATORY);
   content::RunAllPendingInMessageLoop();
 
   // Verify that the policy is presented to the UI. This verification must be
   // done on the kProxyType pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
   non_default_values_.push_back(base::MakeUnique<base::Value>(3));
 
   // Verify that 'use-shared-proxies' is controlled by the policy.
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
   non_default_values_.push_back(base::MakeUnique<base::Value>(false));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
                       true, false);
 }
 
 // Verifies that modifications to the proxy settings are correctly pushed from
 // JavaScript to the ProxyConfig property stored in the network configuration.
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSSetProxy) {
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
 
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySingleHttpPort,
                base::Value(123));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySingleHttp,
-               base::StringValue("www.adomain.xy"));
+               base::Value("www.adomain.xy"));
 
   VerifyCurrentProxyServer("www.adomain.xy:123",
                            onc::ONC_SOURCE_NONE);
 }
 
 // Verify that default proxy ports are used and that ports can be updated
 // without affecting the previously set hosts.
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSProxyDefaultPorts) {
   ASSERT_NO_FATAL_FAILURE(SetupJavaScriptTestEnvironment(pref_names_, NULL));
 
   // Set to manual, per scheme proxy.
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySingle,
                base::Value(false));
 
   // Set hosts but no ports.
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpUrl,
-               base::StringValue("a.com"));
+               base::Value("a.com"));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpsUrl,
-               base::StringValue("4.3.2.1"));
+               base::Value("4.3.2.1"));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyFtpUrl,
-               base::StringValue("c.com"));
+               base::Value("c.com"));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySocks,
-               base::StringValue("d.com"));
+               base::Value("d.com"));
 
   // Verify default ports.
   VerifyCurrentProxyServer(
       "http=a.com:80;https=4.3.2.1:80;ftp=c.com:80;socks=socks4://d.com:1080",
       onc::ONC_SOURCE_NONE);
 
   // Set and verify the ports.
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpPort,
                base::Value(1));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpsPort,
                base::Value(2));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyFtpPort,
                base::Value(3));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySocksPort,
                base::Value(4));
 
   VerifyCurrentProxyServer(
       "http=a.com:1;https=4.3.2.1:2;ftp=c.com:3;socks=socks4://d.com:4",
       onc::ONC_SOURCE_NONE);
 }
 
 #endif