Remove FundamentalValue

chrome/browser/ui/webui/options/browser_options_handler.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/browser_options_handler.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <utility>
@@ skipping 1147 matching lines @@
           ->GetPolicies(policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME,
                                                 std::string()))
           .Get(policy::key::kUserAvatarImage));
 
   OnWallpaperManagedChanged(
       chromeos::WallpaperManager::Get()->IsPolicyControlled(
           user->GetAccountId()));
 
   if (arc::ArcSessionManager::IsAllowedForProfile(profile) &&
       !arc::ArcSessionManager::IsOptInVerificationDisabled()) {
-    base::FundamentalValue is_arc_enabled(
-        arc::ArcSessionManager::Get()->IsArcEnabled());
+    base::Value is_arc_enabled(arc::ArcSessionManager::Get()->IsArcEnabled());
     web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.showAndroidAppsSection",
         is_arc_enabled);
     // Get the initial state of Android Settings app readiness.
     std::unique_ptr<ArcAppListPrefs::AppInfo> app_info =
         ArcAppListPrefs::Get(profile)->GetApp(arc::kSettingsAppId);
     if (app_info && app_info->ready)
       UpdateAndroidSettingsAppState(app_info->ready);
   }
 
@@ skipping 76 matching lines @@
   }
 
   SetDefaultBrowserUIString(status_string_id);
 }
 
 void BrowserOptionsHandler::SetDefaultBrowserUIString(int status_string_id) {
   base::StringValue status_string(
       l10n_util::GetStringFUTF16(status_string_id,
                                  l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)));
 
-  base::FundamentalValue is_default(
+  base::Value is_default(
       status_string_id == IDS_OPTIONS_DEFAULTBROWSER_DEFAULT);
 
-  base::FundamentalValue can_be_default(
+  base::Value can_be_default(
       !IsDisabledByPolicy(default_browser_policy_) &&
       (status_string_id == IDS_OPTIONS_DEFAULTBROWSER_DEFAULT ||
        status_string_id == IDS_OPTIONS_DEFAULTBROWSER_NOTDEFAULT));
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.updateDefaultBrowserState", status_string, is_default,
       can_be_default);
 }
 #endif  // !defined(OS_CHROMEOS)
 
@@ skipping 16 matching lines @@
     std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue());
     entry->SetString("name", t_url->short_name());
     entry->SetInteger("index", i);
     search_engines.Append(std::move(entry));
     if (t_url == default_url)
       default_index = i;
   }
 
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.updateSearchEngines", search_engines,
-      base::FundamentalValue(default_index),
-      base::FundamentalValue(
+      base::Value(default_index),
+      base::Value(
           template_url_service_->is_default_search_managed() ||
           template_url_service_->IsExtensionControlledDefaultSearch()));
 
   SetupExtensionControlledIndicators();
 
   HandleRequestHotwordAvailable(nullptr);
   HandleRequestGoogleNowAvailable(nullptr);
 }
 
 void BrowserOptionsHandler::SetDefaultSearchEngine(
@@ skipping 152 matching lines @@
 }
 
 void BrowserOptionsHandler::ObserveThemeChanged() {
   Profile* profile = Profile::FromWebUI(web_ui());
   ThemeService* theme_service = ThemeServiceFactory::GetForProfile(profile);
   bool is_system_theme = false;
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   bool profile_is_supervised = profile->IsSupervised();
   is_system_theme = theme_service->UsingSystemTheme();
-  base::FundamentalValue native_theme_enabled(!is_system_theme &&
+  base::Value native_theme_enabled(!is_system_theme &&
                                               !profile_is_supervised);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setNativeThemeButtonEnabled", native_theme_enabled);
 #endif
 
   bool is_classic_theme = !is_system_theme &&
                           theme_service->UsingDefaultTheme();
-  base::FundamentalValue enabled(!is_classic_theme);
+  base::Value enabled(!is_classic_theme);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setThemesResetButtonEnabled", enabled);
 }
 
 void BrowserOptionsHandler::ThemesReset(const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   content::RecordAction(UserMetricsAction("Options_ThemesReset"));
   ThemeServiceFactory::GetForProfile(profile)->UseDefaultTheme();
 }
 
@@ skipping 18 matching lines @@
     web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.updateAccountPicture", email_value);
     web_ui()->CallJavascriptFunctionUnsafe(
         "AccountsOptions.getInstance().updateAccountPicture", email_value);
   }
 }
 
 void BrowserOptionsHandler::OnAccountPictureManagedChanged(bool managed) {
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAccountPictureManaged",
-      base::FundamentalValue(managed));
+      base::Value(managed));
 }
 
 void BrowserOptionsHandler::OnWallpaperManagedChanged(bool managed) {
   web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setWallpaperManaged",
-                                         base::FundamentalValue(managed));
+                                         base::Value(managed));
 }
 
 void BrowserOptionsHandler::OnSystemTimezonePolicyChanged() {
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setSystemTimezoneManaged",
-      base::FundamentalValue(chromeos::system::HasSystemTimezonePolicy()));
+      base::Value(chromeos::system::HasSystemTimezonePolicy()));
 }
 
 void BrowserOptionsHandler::OnSystemTimezoneAutomaticDetectionPolicyChanged() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDisableSystemTimezoneAutomaticDetectionPolicy)) {
     return;
   }
 
   PrefService* prefs = g_browser_process->local_state();
   const bool is_managed = prefs->IsManagedPreference(
       prefs::kSystemTimezoneAutomaticDetectionPolicy);
   const int value =
       prefs->GetInteger(prefs::kSystemTimezoneAutomaticDetectionPolicy);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setSystemTimezoneAutomaticDetectionManaged",
-      base::FundamentalValue(is_managed), base::FundamentalValue(value));
+      base::Value(is_managed), base::Value(value));
 }
 #endif
 
 std::unique_ptr<base::DictionaryValue>
 BrowserOptionsHandler::GetSyncStateDictionary() {
   // The items which are to be written into |sync_status| are also described in
   // chrome/browser/resources/options/browser_options.js in @typedef
   // for SyncStatus. Please update it whenever you add or remove any keys here.
   std::unique_ptr<base::DictionaryValue> sync_status(new base::DictionaryValue);
   Profile* profile = Profile::FromWebUI(web_ui());
@@ skipping 71 matching lines @@
 void BrowserOptionsHandler::FileSelected(const base::FilePath& path, int index,
                                          void* params) {
   content::RecordAction(UserMetricsAction("Options_SetDownloadDirectory"));
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   pref_service->SetFilePath(prefs::kDownloadDefaultDirectory, path);
   pref_service->SetFilePath(prefs::kSaveFileDefaultDirectory, path);
 }
 
 #if defined(OS_CHROMEOS)
 void BrowserOptionsHandler::TouchpadExists(bool exists) {
-  base::FundamentalValue val(exists);
+  base::Value val(exists);
   web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.showTouchpadControls",
                                          val);
 }
 
 void BrowserOptionsHandler::MouseExists(bool exists) {
-  base::FundamentalValue val(exists);
+  base::Value val(exists);
   web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.showMouseControls",
                                          val);
 }
 
 void BrowserOptionsHandler::OnUserImagePolicyChanged(
     const base::Value* previous_policy,
     const base::Value* current_policy) {
   const bool had_policy = previous_policy;
   const bool has_policy = current_policy;
   if (had_policy != has_policy)
@@ skipping 20 matching lines @@
 #endif  // defined(OS_CHROMEOS)
 
 void BrowserOptionsHandler::UpdateSyncState() {
   web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.updateSyncState",
                                          *GetSyncStateDictionary());
 
   // A change in sign-in state also affects how hotwording and audio history are
   // displayed. Hide all hotwording and re-display properly.
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAllHotwordSectionsVisible",
-      base::FundamentalValue(false));
+      base::Value(false));
   HandleRequestHotwordAvailable(nullptr);
 }
 
 void BrowserOptionsHandler::OnSigninAllowedPrefChange() {
   UpdateSyncState();
 }
 
 void BrowserOptionsHandler::HandleAutoOpenButton(const base::ListValue* args) {
   content::RecordAction(UserMetricsAction("Options_ResetAutoOpenFiles"));
   DownloadManager* manager = BrowserContext::GetDownloadManager(
@@ skipping 72 matching lines @@
   web_ui()->GetWebContents()->OpenURL(params);
 }
 #endif
 
 void BrowserOptionsHandler::SetHotwordAudioHistorySectionVisible(
     const base::string16& audio_history_state,
     bool success, bool logging_enabled) {
   bool visible = logging_enabled && success;
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAudioHistorySectionVisible",
-      base::FundamentalValue(visible), base::StringValue(audio_history_state));
+      base::Value(visible), base::StringValue(audio_history_state));
 }
 
 void BrowserOptionsHandler::HandleRequestGoogleNowAvailable(
     const base::ListValue* args) {
   bool is_search_provider_google = false;
   if (template_url_service_ && template_url_service_->loaded()) {
     const TemplateURL* default_url =
         template_url_service_->GetDefaultSearchProvider();
     if (default_url && default_url->HasGoogleBaseURLs(
             template_url_service_->search_terms_data())) {
       is_search_provider_google = true;
     }
   }
 
   std::string group = base::FieldTrialList::FindFullName("GoogleNowExtension");
   bool has_field_trial = !group.empty() && group != "Disabled";
 
   bool should_show = is_search_provider_google && has_field_trial;
   web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.setNowSectionVisible",
-                                         base::FundamentalValue(should_show));
+                                         base::Value(should_show));
 }
 
 void BrowserOptionsHandler::HandleRequestHotwordAvailable(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   bool is_search_provider_google = false;
   // The check for default search provider is only valid if the
   // |template_url_service_| has loaded already.
   if (template_url_service_ && template_url_service_->loaded()) {
@@ skipping 12 matching lines @@
     }
   }
 
   // |is_search_provider_google| may be false because |template_url_service_|
   // does not exist yet or because the user selected a different search
   // provider. In either case it does not make sense to show the hotwording
   // options.
   if (!is_search_provider_google) {
     web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.setAllHotwordSectionsVisible",
-        base::FundamentalValue(false));
+        base::Value(false));
     return;
   }
 
   // Don't need to check the field trial here since |IsHotwordAllowed| also
   // checks it.
   if (HotwordServiceFactory::IsHotwordAllowed(profile)) {
     // Update the current error value.
     HotwordServiceFactory::IsServiceAvailable(profile);
     int error = HotwordServiceFactory::GetCurrentError(profile);
 
     std::string function_name;
     bool always_on = false;
     SigninManagerBase* signin = SigninManagerFactory::GetForProfile(profile);
     bool authenticated = signin && signin->IsAuthenticated();
     if (HotwordServiceFactory::IsAlwaysOnAvailable() && authenticated) {
       function_name = "BrowserOptions.showHotwordAlwaysOnSection";
       always_on = true;
       // Show the retrain link if always-on is enabled.
       if (profile->GetPrefs()->GetBoolean(
               prefs::kHotwordAlwaysOnSearchEnabled)) {
         web_ui()->CallJavascriptFunctionUnsafe(
             "BrowserOptions.setHotwordRetrainLinkVisible",
-            base::FundamentalValue(true));
+            base::Value(true));
       }
     } else {
       function_name = "BrowserOptions.showHotwordNoDspSection";
     }
 
     // Audio history should be displayed if it's enabled regardless of the
     // hotword error state if the user is signed in. If the user is not signed
     // in, audio history is meaningless. This is only displayed if always-on
     // hotwording is available.
     if (authenticated && always_on) {
@@ skipping 114 matching lines @@
 
 void BrowserOptionsHandler::OnAppReadyChanged(
     const std::string& app_id,
     bool ready) {
   if (app_id == arc::kSettingsAppId) {
     UpdateAndroidSettingsAppState(ready);
   }
 }
 
 void BrowserOptionsHandler::UpdateAndroidSettingsAppState(bool visible) {
-  base::FundamentalValue is_visible(visible);
+  base::Value is_visible(visible);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAndroidAppsSettingsVisibility", is_visible);
 }
 
 void BrowserOptionsHandler::ShowAndroidAppsSettings(
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   // Settings in secondary profile cannot access ARC.
   if (!arc::ArcSessionManager::IsAllowedForProfile(profile)) {
     LOG(ERROR) << "Settings can't be invoked for non-primary profile";
@@ skipping 10 matching lines @@
   if (!arc::ArcSessionManager::IsAllowedForProfile(profile)) {
     LOG(WARNING) << "Settings can't be invoked for non-primary profile";
     return;
   }
 
   arc::ShowTalkBackSettings();
 }
 
 void BrowserOptionsHandler::SetupAccessibilityFeatures() {
   PrefService* pref_service = g_browser_process->local_state();
-  base::FundamentalValue virtual_keyboard_enabled(
+  base::Value virtual_keyboard_enabled(
       pref_service->GetBoolean(prefs::kAccessibilityVirtualKeyboardEnabled));
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setVirtualKeyboardCheckboxState",
       virtual_keyboard_enabled);
 }
 #endif
 
 void BrowserOptionsHandler::SetupMetricsReportingSettingVisibility() {
 #if defined(GOOGLE_CHROME_BUILD)
   // Don't show the reporting setting if we are in the guest mode.
   if (Profile::FromWebUI(web_ui())->IsGuestSession()) {
-    base::FundamentalValue visible(false);
+    base::Value visible(false);
     web_ui()->CallJavascriptFunctionUnsafe(
         "BrowserOptions.setMetricsReportingSettingVisibility", visible);
   }
 #endif
 }
 
 void BrowserOptionsHandler::SetupNetworkPredictionControl() {
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
 
   base::DictionaryValue dict;
@@ skipping 74 matching lines @@
                                          zoom_factors_value);
 }
 
 void BrowserOptionsHandler::SetupAutoOpenFileTypes() {
   // Set the hidden state for the AutoOpenFileTypesResetToDefault button.
   // We show the button if the user has any auto-open file types registered.
   DownloadManager* manager = BrowserContext::GetDownloadManager(
       web_ui()->GetWebContents()->GetBrowserContext());
   bool display = manager &&
       DownloadPrefs::FromDownloadManager(manager)->IsAutoOpenUsed();
-  base::FundamentalValue value(display);
+  base::Value value(display);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setAutoOpenFileTypesDisplayed", value);
 }
 
 void BrowserOptionsHandler::SetupProxySettingsSection() {
 #if !defined(OS_CHROMEOS)
   PrefService* pref_service = Profile::FromWebUI(web_ui())->GetPrefs();
   const PrefService::Preference* proxy_config =
       pref_service->FindPreference(proxy_config::prefs::kProxy);
   bool is_extension_controlled = (proxy_config &&
                                   proxy_config->IsExtensionControlled());
 
-  base::FundamentalValue disabled(proxy_config &&
+  base::Value disabled(proxy_config &&
                                   !proxy_config->IsUserModifiable());
-  base::FundamentalValue extension_controlled(is_extension_controlled);
+  base::Value extension_controlled(is_extension_controlled);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setupProxySettingsButton", disabled,
       extension_controlled);
 
 #if defined(OS_WIN)
   SetupExtensionControlledIndicators();
 #endif  // defined(OS_WIN)
 
 #endif  // !defined(OS_CHROMEOS)
 }
 
 void BrowserOptionsHandler::SetupManagingSupervisedUsers() {
   bool has_users = !Profile::FromWebUI(web_ui())->
       GetPrefs()->GetDictionary(prefs::kSupervisedUsers)->empty();
-  base::FundamentalValue has_users_value(has_users);
+  base::Value has_users_value(has_users);
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.updateManagesSupervisedUsers", has_users_value);
 }
 
 void BrowserOptionsHandler::SetupEasyUnlock() {
-  base::FundamentalValue is_enabled(
+  base::Value is_enabled(
       EasyUnlockService::Get(Profile::FromWebUI(web_ui()))->IsEnabled());
   web_ui()->CallJavascriptFunctionUnsafe("BrowserOptions.updateEasyUnlock",
                                          is_enabled);
 }
 
 void BrowserOptionsHandler::SetupExtensionControlledIndicators() {
   base::DictionaryValue extension_controlled;
 
   Profile* profile = Profile::FromWebUI(web_ui());
 
@@ skipping 70 matching lines @@
 void BrowserOptionsHandler::NotifyUIOfMetricsReportingChange(bool enabled) {
   SetMetricsReportingCheckbox(enabled, IsMetricsReportingPolicyManaged(),
                               !IsDeviceOwnerProfile());
 }
 
 void BrowserOptionsHandler::SetMetricsReportingCheckbox(bool checked,
                                                         bool policy_managed,
                                                         bool owner_managed) {
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setMetricsReportingCheckboxState",
-      base::FundamentalValue(checked), base::FundamentalValue(policy_managed),
-      base::FundamentalValue(owner_managed));
+      base::Value(checked), base::Value(policy_managed),
+      base::Value(owner_managed));
 }
 
 void BrowserOptionsHandler::SetupSafeBrowsingExtendedReporting() {
-  base::FundamentalValue is_enabled(safe_browsing::IsExtendedReportingEnabled(
+  base::Value is_enabled(safe_browsing::IsExtendedReportingEnabled(
       *Profile::FromWebUI(web_ui())->GetPrefs()));
   web_ui()->CallJavascriptFunctionUnsafe(
       "BrowserOptions.setExtendedReportingEnabledCheckboxState", is_enabled);
 }
 
 void BrowserOptionsHandler::HandleSafeBrowsingExtendedReporting(
     const base::ListValue* args) {
   bool checked;
   if (args->GetBoolean(0, &checked)) {
     safe_browsing::SetExtendedReportingPref(
@@ skipping 12 matching lines @@
 
 bool BrowserOptionsHandler::IsDeviceOwnerProfile() {
 #if defined(OS_CHROMEOS)
   return chromeos::ProfileHelper::IsOwnerProfile(Profile::FromWebUI(web_ui()));
 #else
   return true;
 #endif
 }
 
 }  // namespace options