Remove base::FundamentalValue

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 247 matching lines @@
   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));
   else
     EXPECT_FALSE(dict->HasKey("controlledBy"));
 
   if (disabled)
-    VerifyKeyValue(*dict, "disabled", base::FundamentalValue(true));
+    VerifyKeyValue(*dict, "disabled", base::Value(true));
   else if (dict->HasKey("disabled"))
-    VerifyKeyValue(*dict, "disabled", base::FundamentalValue(false));
+    VerifyKeyValue(*dict, "disabled", base::Value(false));
 
   if (uncommitted)
-    VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(true));
+    VerifyKeyValue(*dict, "uncommitted", base::Value(true));
   else if (dict->HasKey("uncommitted"))
-    VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(false));
+    VerifyKeyValue(*dict, "uncommitted", base::Value(false));
 }
 
 void PreferencesBrowserTest::VerifyObservedPref(
     const std::string& json,
     const std::string& name,
     const std::unique_ptr<base::Value>& value,
     const std::string& controlledBy,
     bool disabled,
     bool uncommitted) {
   std::unique_ptr<base::Value> observed_value_ptr =
@@ skipping 75 matching lines @@
     observed_json = &temp_observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
 
 void PreferencesBrowserTest::SetPref(const std::string& name,
                                      const std::string& type,
                                      const std::unique_ptr<base::Value>& value,
                                      bool commit,
                                      std::string* observed_json) {
-  std::unique_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
+  std::unique_ptr<base::Value> commit_ptr(new base::Value(commit));
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "  Preferences.set" << type << "Pref("
              << "      '" << name << "',"
              << "      " << *value << ","
              << "      " << *commit_ptr << ");"
              << "});";
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
@@ skipping 15 matching lines @@
 
 void PreferencesBrowserTest::VerifyClearPref(
     const std::string& name,
     const std::unique_ptr<base::Value>& value,
     bool commit) {
   if (commit)
     ExpectClearCommit(name);
   else
     ExpectNoCommit(name);
   std::string commit_json;
-  base::JSONWriter::Write(base::FundamentalValue(commit), &commit_json);
+  base::JSONWriter::Write(base::Value(commit), &commit_json);
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "    Preferences.clearPref("
              << "      '" << name.c_str() << "',"
              << "      " << commit_json.c_str() << ");});";
   std::string observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), &observed_json));
   VerifyObservedPref(observed_json, name, value, "recommended", false, !commit);
   VerifyAndClearExpectations();
@@ skipping 55 matching lines @@
       render_view_host_,
       "testEnv.finishObservingAndReply();",
       observed_json));
 }
 
 void PreferencesBrowserTest::UseDefaultTestPrefs(bool includeListPref) {
   // Boolean pref.
   types_.push_back("Boolean");
   pref_names_.push_back(prefs::kAlternateErrorPagesEnabled);
   policy_names_.push_back(policy::key::kAlternateErrorPagesEnabled);
-  non_default_values_.push_back(
-      base::MakeUnique<base::FundamentalValue>(false));
+  non_default_values_.push_back(base::MakeUnique<base::Value>(false));
 
   // Integer pref.
   types_.push_back("Integer");
   pref_names_.push_back(prefs::kRestoreOnStartup);
   policy_names_.push_back(policy::key::kRestoreOnStartup);
-  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(4));
+  non_default_values_.push_back(base::MakeUnique<base::Value>(4));
 
   // List pref.
   if (includeListPref) {
     types_.push_back("List");
     pref_names_.push_back(prefs::kURLsToRestoreOnStartup);
     policy_names_.push_back(policy::key::kRestoreOnStartupURLs);
     auto list = base::MakeUnique<base::ListValue>();
     list->AppendString("http://www.example.com");
     list->AppendString("http://example.com");
     non_default_values_.push_back(std::move(list));
@@ skipping 178 matching lines @@
 #if defined(OS_CHROMEOS)
 
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the
 // 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::FundamentalValue>(true));
+  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>(""));
 
   // List pref.
   pref_names_.push_back(chromeos::kAccountsPrefUsers);
   default_values_.push_back(base::MakeUnique<base::ListValue>());
 
   // Verify notifications when default values are in effect.
@@ skipping 51 matching lines @@
 // Verifies that initializing the JavaScript Preferences class fires the correct
 // notifications in JavaScript for pref values handled by the
 // CoreChromeOSOptionsHandler class for a managed device.
 IN_PROC_BROWSER_TEST_F(ManagedPreferencesBrowserTest,
                        ChromeOSDeviceFetchPrefs) {
   std::vector<std::unique_ptr<base::Value>> decorated_non_default_values;
   std::string observed_json;
 
   // Boolean pref.
   pref_names_.push_back(chromeos::kAccountsPrefAllowGuest);
-  non_default_values_.push_back(
-      base::MakeUnique<base::FundamentalValue>(false));
+  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"));
   decorated_non_default_values.push_back(
       non_default_values_.back()->CreateDeepCopy());
 
@@ skipping 173 matching lines @@
     EXPECT_EQ(expected_server, actual_proxy_server);
     EXPECT_EQ(expected_source, actual_source);
   }
 };
 
 // Verifies that proxy settings are correctly pushed to JavaScript during
 // initialization of the proxy settings page.
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ChromeOSInitializeProxy) {
   // Boolean pref.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxySingle);
-  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(true));
+  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::FundamentalValue>(8080));
+  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"));
 
   // 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.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
-  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(2));
+  non_default_values_.push_back(base::MakeUnique<base::Value>(2));
 
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(
-      base::MakeUnique<base::FundamentalValue>(false));
+  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_, "",
                       false, false);
 }
 
 IN_PROC_BROWSER_TEST_F(ProxyPreferencesBrowserTest, ONCPolicy) {
   SetONCPolicy(policy::key::kOpenNetworkConfiguration,
                policy::POLICY_SCOPE_USER);
 
   // Verify that per-network policy is presented to the UI. This must be
   // verified on the kProxyType.
   pref_names_.push_back(chromeos::proxy_cros_settings_parser::kProxyType);
-  non_default_values_.push_back(base::MakeUnique<base::FundamentalValue>(3));
+  non_default_values_.push_back(base::MakeUnique<base::Value>(3));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
                       true, false);
 
   // Verify that 'use-shared-proxies' is not affected by per-network policy.
   pref_names_.clear();
   non_default_values_.clear();
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(
-      base::MakeUnique<base::FundamentalValue>(false));
+  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, DeviceONCPolicy) {
   SetONCPolicy(policy::key::kDeviceOpenNetworkConfiguration,
                policy::POLICY_SCOPE_MACHINE);
 
   // 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::FundamentalValue>(3));
+  non_default_values_.push_back(base::MakeUnique<base::Value>(3));
 
   std::string observed_json;
   SetupJavaScriptTestEnvironment(pref_names_, &observed_json);
   VerifyObservedPrefs(observed_json, pref_names_, non_default_values_, "policy",
                       true, false);
 
   // Verify that 'use-shared-proxies' is not affected by per-network policy.
   pref_names_.clear();
   non_default_values_.clear();
   pref_names_.push_back(proxy_config::prefs::kUseSharedProxies);
-  non_default_values_.push_back(
-      base::MakeUnique<base::FundamentalValue>(false));
+  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));
   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::FundamentalValue>(3));
+  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::FundamentalValue>(false));
+  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::FundamentalValue(123));
+               base::Value(123));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySingleHttp,
                base::StringValue("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::FundamentalValue(false));
+               base::Value(false));
 
   // Set hosts but no ports.
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpUrl,
                base::StringValue("a.com"));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpsUrl,
                base::StringValue("4.3.2.1"));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyFtpUrl,
                base::StringValue("c.com"));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySocks,
                base::StringValue("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::FundamentalValue(1));
+               base::Value(1));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyHttpsPort,
-               base::FundamentalValue(2));
+               base::Value(2));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxyFtpPort,
-               base::FundamentalValue(3));
+               base::Value(3));
   SetProxyPref(chromeos::proxy_cros_settings_parser::kProxySocksPort,
-               base::FundamentalValue(4));
+               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