Remove base::FundamentalValue

chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.cc

 // Copyright 2015 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.
 
 // This file is for non-chromeos (win & linux) functions, such as
 // chrome.input.ime.activate, chrome.input.ime.createWindow and
 // chrome.input.ime.onSelectionChanged.
 // TODO(azurewei): May refactor the code structure by using delegate or
 // redesign the API to remove this platform-specific file in the future.
 
@@ skipping 130 matching lines @@
 
 void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
                                     const Extension* extension) {
   // No-op if called multiple times.
   ui::IMEBridge::Initialize();
 
   // Set the preference kPrefNeverActivatedSinceLoaded true to indicate
   // input.ime.activate API has been never called since loaded.
   Profile* profile = Profile::FromBrowserContext(browser_context);
   ExtensionPrefs::Get(profile)->UpdateExtensionPref(
-      extension->id(), kPrefNeverActivatedSinceLoaded,
-      new base::FundamentalValue(true));
+      extension->id(), kPrefNeverActivatedSinceLoaded, new base::Value(true));
 }
 
 void InputImeAPI::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionInfo::Reason reason) {
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context));
   if (event_router) {
     // Records the extension is not the last active IME engine.
     ExtensionPrefs::Get(Profile::FromBrowserContext(browser_context))
         ->UpdateExtensionPref(extension->id(), kPrefLastActiveEngine,
-                              new base::FundamentalValue(false));
+                              new base::Value(false));
     event_router->DeleteInputMethodEngine(extension->id());
   }
 }
 
 void InputImeAPI::OnListenerAdded(const EventListenerInfo& details) {}
 
 InputImeEventRouter::InputImeEventRouter(Profile* profile)
     : InputImeEventRouterBase(profile), active_engine_(nullptr) {}
 
 InputImeEventRouter::~InputImeEventRouter() {
   if (active_engine_)
     DeleteInputMethodEngine(active_engine_->GetExtensionId());
 }
 
 InputMethodEngineBase* InputImeEventRouter::GetActiveEngine(
     const std::string& extension_id) {
   return (ui::IMEBridge::Get()->GetCurrentEngineHandler() &&
           active_engine_ &&
           active_engine_->GetExtensionId() == extension_id)
              ? active_engine_
              : nullptr;
 }
 
 void InputImeEventRouter::SetActiveEngine(const std::string& extension_id) {
   // Records the extension is the last active IME engine.
   ExtensionPrefs::Get(GetProfile())
       ->UpdateExtensionPref(extension_id, kPrefLastActiveEngine,
-                            new base::FundamentalValue(true));
+                            new base::Value(true));
   if (active_engine_) {
     if (active_engine_->GetExtensionId() == extension_id) {
       active_engine_->Enable(std::string());
       ui::IMEBridge::Get()->SetCurrentEngineHandler(active_engine_);
       return;
     }
     // Records the extension is not the last active IME engine.
     ExtensionPrefs::Get(GetProfile())
         ->UpdateExtensionPref(active_engine_->GetExtensionId(),
-                              kPrefLastActiveEngine,
-                              new base::FundamentalValue(false));
+                              kPrefLastActiveEngine, new base::Value(false));
     DeleteInputMethodEngine(active_engine_->GetExtensionId());
   }
 
   std::unique_ptr<input_method::InputMethodEngine> engine(
       new input_method::InputMethodEngine());
   std::unique_ptr<InputMethodEngineBase::Observer> observer(
       new ImeObserverNonChromeOS(extension_id, GetProfile()));
   engine->Initialize(std::move(observer), extension_id.c_str(), GetProfile());
   engine->Enable(std::string());
   active_engine_ = engine.release();
@@ skipping 30 matching lines @@
                                &never_activated_since_loaded) &&
       never_activated_since_loaded &&
       prefs->ReadPrefAsBoolean(extension_id(), kPrefLastActiveEngine,
                                &last_active_ime_engine) &&
       last_active_ime_engine) {
     // If the extension is the last active IME engine, and the API is called at
     // loading the extension, we can tell the API is called from restarting
     // chrome. No need for user gesture checking.
     event_router->SetActiveEngine(extension_id());
     ExtensionPrefs::Get(profile)->UpdateExtensionPref(
-        extension_id(), kPrefNeverActivatedSinceLoaded,
-        new base::FundamentalValue(false));
+        extension_id(), kPrefNeverActivatedSinceLoaded, new base::Value(false));
     return RespondNow(NoArguments());
   }
   // The API has already been called at least once.
   ExtensionPrefs::Get(profile)->UpdateExtensionPref(
-      extension_id(), kPrefNeverActivatedSinceLoaded,
-      new base::FundamentalValue(false));
+      extension_id(), kPrefNeverActivatedSinceLoaded, new base::Value(false));
 
   // Otherwise, this API is only allowed to be called from a user action.
   if (!user_gesture())
     return RespondNow(Error(kErrorNotCalledFromUserAction));
 
   // Disable using the warning bubble for testing.
   if (disable_bubble_for_testing_) {
     event_router->SetActiveEngine(extension_id());
     return RespondNow(NoArguments());
   }
@@ skipping 40 matching lines @@
   if (!event_router) {
     Respond(Error(kErrorNoActiveEngine));
     return;
   }
   event_router->SetActiveEngine(extension_id());
 
   if (status == ImeWarningBubblePermissionStatus::GRANTED_AND_NEVER_SHOW) {
     // Updates the extension preference if user checks the 'Never show this
     // again' check box. So we can activate the extension directly next time.
     ExtensionPrefs::Get(profile)->UpdateExtensionPref(
-        extension_id(), kPrefWarningBubbleNeverShow,
-        new base::FundamentalValue(true));
+        extension_id(), kPrefWarningBubbleNeverShow, new base::Value(true));
   }
 
   Respond(NoArguments());
 }
 
 ExtensionFunction::ResponseAction InputImeDeactivateFunction::Run() {
   if (!IsInputImeEnabled())
     return RespondNow(Error(kErrorAPIDisabled));
 
   InputMethodEngine* engine =
@@ skipping 37 matching lines @@
       extension(), render_frame_host(),
       options.url.get() ? *options.url : url::kAboutBlankURL,
       options.window_type == input_ime::WINDOW_TYPE_FOLLOWCURSOR
           ? ui::ImeWindow::FOLLOW_CURSOR
           : ui::ImeWindow::NORMAL,
       bounds, &error);
   if (!frame_id)
     return RespondNow(Error(error));
 
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
-  result->Set("frameId", new base::FundamentalValue(frame_id));
+  result->Set("frameId", new base::Value(frame_id));
 
   return RespondNow(OneArgument(std::move(result)));
 }
 
 ExtensionFunction::ResponseAction InputImeShowWindowFunction::Run() {
   if (!IsInputImeEnabled())
     return RespondNow(Error(kErrorAPIDisabled));
 
   InputMethodEngine* engine =
       GetActiveEngine(browser_context(), extension_id());
@@ skipping 17 matching lines @@
     return RespondNow(Error(kErrorNoActiveEngine));
 
   std::unique_ptr<api::input_ime::HideWindow::Params> params(
       api::input_ime::HideWindow::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   engine->HideImeWindow(params->window_id);
   return RespondNow(NoArguments());
 }
 
 }  // namespace extensions