Remove FundamentalValue

chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.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.
 
 #include "chrome/browser/extensions/api/input_ime/input_ime_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 346 matching lines @@
       engine_map_.find(extension_id);
   return (it != engine_map_.end() && it->second->IsActive()) ? it->second
                                                              : nullptr;
 }
 
 ExtensionFunction::ResponseAction InputImeClearCompositionFunction::Run() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     return RespondNow(
-        OneArgument(base::MakeUnique<base::FundamentalValue>(false)));
+        OneArgument(base::MakeUnique<base::Value>(false)));
   }
 
   std::unique_ptr<ClearComposition::Params> parent_params(
       ClearComposition::Params::Create(*args_));
   const ClearComposition::Params::Parameters& params =
       parent_params->parameters;
 
   std::string error;
   bool success = engine->ClearComposition(params.context_id, &error);
   std::unique_ptr<base::ListValue> results =
       base::MakeUnique<base::ListValue>();
-  results->Append(base::MakeUnique<base::FundamentalValue>(success));
+  results->Append(base::MakeUnique<base::Value>(success));
   return RespondNow(success ? ArgumentList(std::move(results))
                             : ErrorWithArguments(std::move(results), error));
 }
 
 bool InputImeHideInputViewFunction::RunAsync() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     return true;
   }
   engine->HideInputView();
   return true;
 }
 
 ExtensionFunction::ResponseAction
 InputImeSetCandidateWindowPropertiesFunction::Run() {
   std::unique_ptr<SetCandidateWindowProperties::Params> parent_params(
       SetCandidateWindowProperties::Params::Create(*args_));
   const SetCandidateWindowProperties::Params::Parameters&
       params = parent_params->parameters;
 
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
   InputMethodEngine* engine =
       event_router ? event_router->GetEngine(extension_id(), params.engine_id)
                    : nullptr;
   if (!engine) {
     return RespondNow(
-        OneArgument(base::MakeUnique<base::FundamentalValue>(false)));
+        OneArgument(base::MakeUnique<base::Value>(false)));
   }
 
   const SetCandidateWindowProperties::Params::Parameters::Properties&
       properties = params.properties;
 
   std::string error;
   if (properties.visible &&
       !engine->SetCandidateWindowVisible(*properties.visible, &error)) {
     std::unique_ptr<base::ListValue> results =
         base::MakeUnique<base::ListValue>();
-    results->Append(base::MakeUnique<base::FundamentalValue>(false));
+    results->Append(base::MakeUnique<base::Value>(false));
     return RespondNow(ErrorWithArguments(std::move(results), error));
   }
 
   InputMethodEngine::CandidateWindowProperty properties_out =
       engine->GetCandidateWindowProperty();
   bool modified = false;
 
   if (properties.cursor_visible) {
     properties_out.is_cursor_visible = *properties.cursor_visible;
     modified = true;
@@ skipping 26 matching lines @@
     properties_out.is_auxiliary_text_visible =
         *properties.auxiliary_text_visible;
     modified = true;
   }
 
   if (modified) {
     engine->SetCandidateWindowProperty(properties_out);
   }
 
   return RespondNow(
-      OneArgument(base::MakeUnique<base::FundamentalValue>(true)));
+      OneArgument(base::MakeUnique<base::Value>(true)));
 }
 
 ExtensionFunction::ResponseAction InputImeSetCandidatesFunction::Run() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     return RespondNow(
-        OneArgument(base::MakeUnique<base::FundamentalValue>(true)));
+        OneArgument(base::MakeUnique<base::Value>(true)));
   }
 
   std::unique_ptr<SetCandidates::Params> parent_params(
       SetCandidates::Params::Create(*args_));
   const SetCandidates::Params::Parameters& params =
       parent_params->parameters;
 
   std::vector<InputMethodEngine::Candidate> candidates_out;
   for (const auto& candidate_in : params.candidates) {
     candidates_out.push_back(InputMethodEngine::Candidate());
     candidates_out.back().value = candidate_in.candidate;
     candidates_out.back().id = candidate_in.id;
     if (candidate_in.label)
       candidates_out.back().label = *candidate_in.label;
     if (candidate_in.annotation)
       candidates_out.back().annotation = *candidate_in.annotation;
     if (candidate_in.usage) {
       candidates_out.back().usage.title = candidate_in.usage->title;
       candidates_out.back().usage.body = candidate_in.usage->body;
     }
   }
 
   std::string error;
   bool success =
       engine->SetCandidates(params.context_id, candidates_out, &error);
   std::unique_ptr<base::ListValue> results =
       base::MakeUnique<base::ListValue>();
-  results->Append(base::MakeUnique<base::FundamentalValue>(success));
+  results->Append(base::MakeUnique<base::Value>(success));
   return RespondNow(success ? ArgumentList(std::move(results))
                             : ErrorWithArguments(std::move(results), error));
 }
 
 ExtensionFunction::ResponseAction InputImeSetCursorPositionFunction::Run() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     return RespondNow(
-        OneArgument(base::MakeUnique<base::FundamentalValue>(false)));
+        OneArgument(base::MakeUnique<base::Value>(false)));
   }
 
   std::unique_ptr<SetCursorPosition::Params> parent_params(
       SetCursorPosition::Params::Create(*args_));
   const SetCursorPosition::Params::Parameters& params =
       parent_params->parameters;
 
   std::string error;
   bool success =
       engine->SetCursorPosition(params.context_id, params.candidate_id, &error);
   std::unique_ptr<base::ListValue> results =
       base::MakeUnique<base::ListValue>();
-  results->Append(base::MakeUnique<base::FundamentalValue>(success));
+  results->Append(base::MakeUnique<base::Value>(success));
   return RespondNow(success ? ArgumentList(std::move(results))
                             : ErrorWithArguments(std::move(results), error));
 }
 
 ExtensionFunction::ResponseAction InputImeSetMenuItemsFunction::Run() {
   std::unique_ptr<SetMenuItems::Params> parent_params(
       SetMenuItems::Params::Create(*args_));
   const SetMenuItems::Params::Parameters& params =
       parent_params->parameters;
 
@@ skipping 113 matching lines @@
     return;
   InputMethodEngine* engine =
       GetActiveEngine(Profile::FromBrowserContext(details.browser_context),
                       details.extension_id);
   // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
     engine->Enable(engine->GetActiveComponentId());
 }
 
 }  // namespace extensions