Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

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 <utility>
 
 #include "base/macros.h"
@@ skipping 79 matching lines @@
       const IMEEngineHandlerInterface::InputContext& context) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnInputContextUpdate::kEventName))
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type =
         input_ime::ParseInputContextType(ConvertInputContextType(context));
 
-    scoped_ptr<base::ListValue> args(
+    std::unique_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_INPUT_CONTEXT_UPDATE,
         input_ime::OnInputContextUpdate::kEventName, std::move(args));
   }
 
   void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
@@ skipping 12 matching lines @@
         button_enum = input_ime::MOUSE_BUTTON_RIGHT;
         break;
 
       case InputMethodEngineBase::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         button_enum = input_ime::MOUSE_BUTTON_LEFT;
         break;
     }
 
-    scoped_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
+    std::unique_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
         component_id, candidate_id, button_enum));
 
     DispatchEventToExtension(extensions::events::INPUT_IME_ON_CANDIDATE_CLICKED,
                              input_ime::OnCandidateClicked::kEventName,
                              std::move(args));
   }
 
   void OnMenuItemActivated(const std::string& component_id,
                            const std::string& menu_id) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnMenuItemActivated::kEventName))
       return;
 
-    scoped_ptr<base::ListValue> args(
+    std::unique_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_MENU_ITEM_ACTIVATED,
         input_ime::OnMenuItemActivated::kEventName, std::move(args));
   }
 
   void OnCompositionBoundsChanged(
       const std::vector<gfx::Rect>& bounds) override {
     if (extension_id_.empty() ||
         !HasListener(OnCompositionBoundsChanged::kEventName))
       return;
 
     // Note: this is a private API event.
     base::ListValue* bounds_list = new base::ListValue();
     for (size_t i = 0; i < bounds.size(); ++i) {
       base::DictionaryValue* bounds_value = new base::DictionaryValue();
       bounds_value->SetInteger("x", bounds[i].x());
       bounds_value->SetInteger("y", bounds[i].y());
       bounds_value->SetInteger("w", bounds[i].width());
       bounds_value->SetInteger("h", bounds[i].height());
       bounds_list->Append(bounds_value);
     }
 
     if (bounds_list->GetSize() <= 0)
       return;
-    scoped_ptr<base::ListValue> args(new base::ListValue());
+    std::unique_ptr<base::ListValue> args(new base::ListValue());
 
     // The old extension code uses the first parameter to get the bounds of the
     // first composition character, so for backward compatibility, add it here.
     base::Value* first_value = NULL;
     if (bounds_list->Get(0, &first_value))
       args->Append(first_value->DeepCopy());
     args->Append(bounds_list);
 
     DispatchEventToExtension(
         extensions::events::INPUT_METHOD_PRIVATE_ON_COMPOSITION_BOUNDS_CHANGED,
         OnCompositionBoundsChanged::kEventName, std::move(args));
   }
 
  private:
   // ui::ImeObserver overrides.
   void DispatchEventToExtension(
       extensions::events::HistogramValue histogram_value,
       const std::string& event_name,
-      scoped_ptr<base::ListValue> args) override {
+      std::unique_ptr<base::ListValue> args) override {
     if (event_name != input_ime::OnActivate::kEventName) {
       // For suspended IME extension (e.g. XKB extension), don't awake it by IME
       // events except onActivate. The IME extension should be awake by other
       // events (e.g. runtime.onMessage) from its other pages.
       // This is to save memory for steady state Chrome OS on which the users
       // don't want any IME features.
       extensions::ExtensionSystem* extension_system =
           extensions::ExtensionSystem::Get(profile_);
       if (extension_system) {
         const extensions::Extension* extension =
             extension_system->extension_service()->GetExtensionById(
                 extension_id_, false /* include_disabled */);
         if (!extension)
           return;
         extensions::ProcessManager* process_manager =
             extensions::ProcessManager::Get(profile_);
         if (extensions::BackgroundInfo::HasBackgroundPage(extension) &&
             !process_manager->GetBackgroundHostForExtension(extension_id_)) {
           return;
         }
       }
     }
 
-    scoped_ptr<extensions::Event> event(
+    std::unique_ptr<extensions::Event> event(
         new extensions::Event(histogram_value, event_name, std::move(args)));
     event->restrict_to_browser_context = profile_;
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, std::move(event));
   }
 
   // The component IME extensions need to know the current screen type (e.g.
   // lock screen, login screen, etc.) so that its on-screen keyboard page
   // won't open new windows/pages. See crbug.com/395621.
   std::string GetCurrentScreenType() override {
@@ skipping 81 matching lines @@
   }
 
   Profile* profile = GetProfile();
 
   if (chromeos::input_method::InputMethodManager::Get()->GetUISessionState() ==
           chromeos::input_method::InputMethodManager::STATE_LOGIN_SCREEN &&
       profile->HasOffTheRecordProfile()) {
     profile = profile->GetOffTheRecordProfile();
   }
 
-  scoped_ptr<InputMethodEngineBase::Observer> observer(
+  std::unique_ptr<InputMethodEngineBase::Observer> observer(
       new ImeObserverChromeOS(extension_id, profile));
   chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
   engine->Initialize(std::move(observer), extension_id.c_str(), profile);
   engine_map_[extension_id] = engine;
   chromeos::UserSessionManager::GetInstance()
       ->GetDefaultIMEState(profile)
       ->AddInputMethodExtension(extension_id, descriptors, engine);
 
   return true;
 }
@@ skipping 27 matching lines @@
 }
 
 bool InputImeClearCompositionFunction::RunSync() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
-  scoped_ptr<ClearComposition::Params> parent_params(
+  std::unique_ptr<ClearComposition::Params> parent_params(
       ClearComposition::Params::Create(*args_));
   const ClearComposition::Params::Parameters& params =
       parent_params->parameters;
 
   SetResult(new base::FundamentalValue(
       engine->ClearComposition(params.context_id, &error_)));
   return true;
 }
 
 bool InputImeHideInputViewFunction::RunAsync() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     return true;
   }
   engine->HideInputView();
   return true;
 }
 
 bool InputImeSetCandidateWindowPropertiesFunction::RunSync() {
-  scoped_ptr<SetCandidateWindowProperties::Params> parent_params(
+  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) {
@@ skipping 58 matching lines @@
 }
 
 bool InputImeSetCandidatesFunction::RunSync() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
-  scoped_ptr<SetCandidates::Params> parent_params(
+  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)
@@ skipping 12 matching lines @@
 }
 
 bool InputImeSetCursorPositionFunction::RunSync() {
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
-  scoped_ptr<SetCursorPosition::Params> parent_params(
+  std::unique_ptr<SetCursorPosition::Params> parent_params(
       SetCursorPosition::Params::Create(*args_));
   const SetCursorPosition::Params::Parameters& params =
       parent_params->parameters;
 
   SetResult(new base::FundamentalValue(
       engine->SetCursorPosition(params.context_id, params.candidate_id,
                                 &error_)));
   return true;
 }
 
 bool InputImeSetMenuItemsFunction::RunSync() {
-  scoped_ptr<SetMenuItems::Params> parent_params(
+  std::unique_ptr<SetMenuItems::Params> parent_params(
       SetMenuItems::Params::Create(*args_));
   const SetMenuItems::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) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   std::vector<chromeos::input_method::InputMethodManager::MenuItem> items_out;
   for (const input_ime::MenuItem& item_in : params.items) {
     items_out.push_back(chromeos::input_method::InputMethodManager::MenuItem());
     SetMenuItemToMenu(item_in, &items_out.back());
   }
 
   if (!engine->SetMenuItems(items_out))
     error_ = kErrorSetMenuItemsFail;
   return true;
 }
 
 bool InputImeUpdateMenuItemsFunction::RunSync() {
-  scoped_ptr<UpdateMenuItems::Params> parent_params(
+  std::unique_ptr<UpdateMenuItems::Params> parent_params(
       UpdateMenuItems::Params::Create(*args_));
   const UpdateMenuItems::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) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   std::vector<chromeos::input_method::InputMethodManager::MenuItem> items_out;
   for (const input_ime::MenuItem& item_in : params.items) {
     items_out.push_back(chromeos::input_method::InputMethodManager::MenuItem());
     SetMenuItemToMenu(item_in, &items_out.back());
   }
 
   if (!engine->UpdateMenuItems(items_out))
     error_ = kErrorUpdateMenuItemsFail;
   return true;
 }
 
 bool InputImeDeleteSurroundingTextFunction::RunSync() {
-  scoped_ptr<DeleteSurroundingText::Params> parent_params(
+  std::unique_ptr<DeleteSurroundingText::Params> parent_params(
       DeleteSurroundingText::Params::Create(*args_));
   const DeleteSurroundingText::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) {
@@ skipping 13 matching lines @@
           ->GetActiveIMEState()
           ->GetCurrentInputMethod();
   std::string active_extension_id =
       chromeos::extension_ime_util::GetExtensionIDFromInputMethodID(
           current_input_method.id());
   InputMethodEngine* engine = GetActiveEngine(
       Profile::FromBrowserContext(browser_context()), active_extension_id);
   if (!engine)
     return RespondNow(Error(kErrorEngineNotAvailable));
 
-  scoped_ptr<NotifyImeMenuItemActivated::Params> params(
+  std::unique_ptr<NotifyImeMenuItemActivated::Params> params(
       NotifyImeMenuItemActivated::Params::Create(*args_));
   if (params->engine_id != engine->GetActiveComponentId())
     return RespondNow(Error(kErrorEngineNotActive));
   engine->PropertyActivate(params->name);
   return RespondNow(NoArguments());
 }
 
 void InputImeAPI::OnExtensionLoaded(content::BrowserContext* browser_context,
                                     const Extension* extension) {
   const std::vector<InputComponentInfo>* input_components =
@@ skipping 24 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