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

chrome/browser/extensions/api/input_ime/input_ime_api.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/extensions/api/input_ime/input_ime_api.h"
 
 #include "base/lazy_instance.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "content/public/browser/notification_registrar.h"
@@ skipping 14 matching lines @@
 }
 namespace ui {
 
 ImeObserver::ImeObserver(const std::string& extension_id, Profile* profile)
     : extension_id_(extension_id), profile_(profile) {}
 
 void ImeObserver::OnActivate(const std::string& component_id) {
   if (extension_id_.empty() || !HasListener(input_ime::OnActivate::kEventName))
     return;
 
-  scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
-    component_id,
-    input_ime::ParseScreenType(GetCurrentScreenType())));
+  std::unique_ptr<base::ListValue> args(input_ime::OnActivate::Create(
+      component_id, input_ime::ParseScreenType(GetCurrentScreenType())));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_ACTIVATE,
                            input_ime::OnActivate::kEventName,
                            std::move(args));
 }
 
 void ImeObserver::OnFocus(
     const IMEEngineHandlerInterface::InputContext& context) {
   if (extension_id_.empty() || !HasListener(input_ime::OnFocus::kEventName))
     return;
 
   input_ime::InputContext context_value;
   context_value.context_id = context.id;
   context_value.type =
       input_ime::ParseInputContextType(ConvertInputContextType(context));
   context_value.auto_correct = ConvertInputContextAutoCorrect(context);
   context_value.auto_complete = ConvertInputContextAutoComplete(context);
   context_value.spell_check = ConvertInputContextSpellCheck(context);
 
-  scoped_ptr<base::ListValue> args(input_ime::OnFocus::Create(context_value));
+  std::unique_ptr<base::ListValue> args(
+      input_ime::OnFocus::Create(context_value));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_FOCUS,
                            input_ime::OnFocus::kEventName, std::move(args));
 }
 
 void ImeObserver::OnBlur(int context_id) {
   if (extension_id_.empty() || !HasListener(input_ime::OnBlur::kEventName))
     return;
 
-  scoped_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
+  std::unique_ptr<base::ListValue> args(input_ime::OnBlur::Create(context_id));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_BLUR,
                            input_ime::OnBlur::kEventName, std::move(args));
 }
 
 void ImeObserver::OnKeyEvent(
     const std::string& component_id,
     const InputMethodEngineBase::KeyboardEvent& event,
     IMEEngineHandlerInterface::KeyEventDoneCallback& key_data) {
   if (extension_id_.empty())
@@ skipping 20 matching lines @@
   key_data_value.request_id = request_id;
   if (!event.extension_id.empty())
       key_data_value.extension_id.reset(new std::string(event.extension_id));
   key_data_value.key = event.key;
   key_data_value.code = event.code;
   key_data_value.alt_key.reset(new bool(event.alt_key));
   key_data_value.ctrl_key.reset(new bool(event.ctrl_key));
   key_data_value.shift_key.reset(new bool(event.shift_key));
   key_data_value.caps_lock.reset(new bool(event.caps_lock));
 
-  scoped_ptr<base::ListValue> args(
+  std::unique_ptr<base::ListValue> args(
       input_ime::OnKeyEvent::Create(component_id, key_data_value));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_KEY_EVENT,
                            input_ime::OnKeyEvent::kEventName, std::move(args));
 }
 
 void ImeObserver::OnReset(const std::string& component_id) {
   if (extension_id_.empty() || !HasListener(input_ime::OnReset::kEventName))
     return;
 
-  scoped_ptr<base::ListValue> args(input_ime::OnReset::Create(component_id));
+  std::unique_ptr<base::ListValue> args(
+      input_ime::OnReset::Create(component_id));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_RESET,
                            input_ime::OnReset::kEventName, std::move(args));
 }
 
 void ImeObserver::OnDeactivated(const std::string& component_id) {
   if (extension_id_.empty() ||
       !HasListener(input_ime::OnDeactivated::kEventName))
     return;
 
-  scoped_ptr<base::ListValue> args(
+  std::unique_ptr<base::ListValue> args(
       input_ime::OnDeactivated::Create(component_id));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_DEACTIVATED,
                            input_ime::OnDeactivated::kEventName,
                            std::move(args));
 }
 
 // TODO(azurewei): This function implementation should be shared on all
 // platforms, while with some changing on the current code on ChromeOS.
 void ImeObserver::OnCompositionBoundsChanged(
@@ skipping 10 matching lines @@
                                            int offset_pos) {
   if (extension_id_.empty() ||
       !HasListener(input_ime::OnSurroundingTextChanged::kEventName))
     return;
 
   input_ime::OnSurroundingTextChanged::SurroundingInfo info;
   info.text = text;
   info.focus = cursor_pos;
   info.anchor = anchor_pos;
   info.offset = offset_pos;
-  scoped_ptr<base::ListValue> args(
-    input_ime::OnSurroundingTextChanged::Create(component_id, info));
+  std::unique_ptr<base::ListValue> args(
+      input_ime::OnSurroundingTextChanged::Create(component_id, info));
 
   DispatchEventToExtension(
     extensions::events::INPUT_IME_ON_SURROUNDING_TEXT_CHANGED,
     input_ime::OnSurroundingTextChanged::kEventName, std::move(args));
 }
 
 bool ImeObserver::ShouldForwardKeyEvent() const {
   // Only forward key events to extension if there are non-lazy listeners
   // for onKeyEvent. Because if something wrong with the lazy background
   // page which doesn't register listener for onKeyEvent, it will not handle
@@ skipping 90 matching lines @@
   if (!profile || router_map_.empty())
     return;
   auto it = router_map_.find(profile);
   if (it != router_map_.end()) {
     delete it->second;
     router_map_.erase(it);
   }
 }
 
 ExtensionFunction::ResponseAction InputImeKeyEventHandledFunction::Run() {
-  scoped_ptr<KeyEventHandled::Params> params(
+  std::unique_ptr<KeyEventHandled::Params> params(
       KeyEventHandled::Params::Create(*args_));
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
   InputMethodEngineBase* engine =
       event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
   if (engine) {
     engine->KeyEventHandled(extension_id(), params->request_id,
                             params->response);
   }
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction InputImeSetCompositionFunction::Run() {
   bool success = false;
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
   InputMethodEngineBase* engine =
       event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
   if (engine) {
-    scoped_ptr<SetComposition::Params> parent_params(
+    std::unique_ptr<SetComposition::Params> parent_params(
         SetComposition::Params::Create(*args_));
     const SetComposition::Params::Parameters& params =
         parent_params->parameters;
     std::vector<InputMethodEngineBase::SegmentInfo> segments;
     if (params.segments) {
       for (const auto& segments_arg : *params.segments) {
         EXTENSION_FUNCTION_VALIDATE(segments_arg.style !=
                                     input_ime::UNDERLINE_STYLE_NONE);
         InputMethodEngineBase::SegmentInfo segment_info;
         segment_info.start = segments_arg.start;
@@ skipping 12 matching lines @@
       }
     }
     int selection_start =
         params.selection_start ? *params.selection_start : params.cursor;
     int selection_end =
         params.selection_end ? *params.selection_end : params.cursor;
     success = engine->SetComposition(params.context_id, params.text.c_str(),
                                      selection_start, selection_end,
                                      params.cursor, segments, &error_);
   }
-  scoped_ptr<base::ListValue> output = SetComposition::Results::Create(success);
+  std::unique_ptr<base::ListValue> output =
+      SetComposition::Results::Create(success);
   return RespondNow(ArgumentList(std::move(output)));
 }
 
 ExtensionFunction::ResponseAction InputImeCommitTextFunction::Run() {
   bool success = false;
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
   InputMethodEngineBase* engine =
       event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
   if (engine) {
-    scoped_ptr<CommitText::Params> parent_params(
+    std::unique_ptr<CommitText::Params> parent_params(
         CommitText::Params::Create(*args_));
     const CommitText::Params::Parameters& params = parent_params->parameters;
     success =
         engine->CommitText(params.context_id, params.text.c_str(), &error_);
   }
-  scoped_ptr<base::ListValue> output = CommitText::Results::Create(success);
+  std::unique_ptr<base::ListValue> output =
+      CommitText::Results::Create(success);
   return RespondNow(ArgumentList(std::move(output)));
 }
 
 ExtensionFunction::ResponseAction InputImeSendKeyEventsFunction::Run() {
   InputImeEventRouter* event_router =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()));
   InputMethodEngineBase* engine =
       event_router ? event_router->GetActiveEngine(extension_id()) : nullptr;
   if (!engine)
     return RespondNow(Error(kErrorEngineNotAvailable));
 
-  scoped_ptr<SendKeyEvents::Params> parent_params(
+  std::unique_ptr<SendKeyEvents::Params> parent_params(
       SendKeyEvents::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(parent_params);
   const SendKeyEvents::Params::Parameters& params = parent_params->parameters;
   std::vector<InputMethodEngineBase::KeyboardEvent> key_data_out;
 
   for (const auto& key_event : params.key_data) {
     key_data_out.push_back(InputMethodEngineBase::KeyboardEvent());
     InputMethodEngineBase::KeyboardEvent& event = key_data_out.back();
     event.type = input_ime::ToString(key_event.type);
     event.key = key_event.key;
@@ skipping 44 matching lines @@
 InputImeEventRouter* GetInputImeEventRouter(Profile* profile) {
   if (!profile)
     return nullptr;
   if (profile->HasOffTheRecordProfile())
     profile = profile->GetOffTheRecordProfile();
   return extensions::InputImeEventRouterFactory::GetInstance()->GetRouter(
       profile);
 }
 
 }  // namespace extensions