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

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 60 matching lines @@
     std::vector<input_ime::Bounds> bounds_list;
     for (const auto& bound : bounds) {
       input_ime::Bounds bounds_value;
       bounds_value.left = bound.x();
       bounds_value.top = bound.y();
       bounds_value.width = bound.width();
       bounds_value.height = bound.height();
       bounds_list.push_back(std::move(bounds_value));
     }
 
-    scoped_ptr<base::ListValue> args(
+    std::unique_ptr<base::ListValue> args(
         OnCompositionBoundsChanged::Create(bounds_list));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_COMPOSITION_BOUNDS_CHANGED,
         OnCompositionBoundsChanged::kEventName, std::move(args));
   }
 
  private:
   // 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 (!IsInputImeEnabled()) {
       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));
   }
 
   std::string GetCurrentScreenType() override { return "normal"; }
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserverNonChromeOS);
 };
@@ skipping 54 matching lines @@
 void InputImeEventRouter::SetActiveEngine(const std::string& extension_id) {
   if (active_engine_) {
     if (active_engine_->GetExtensionId() == extension_id) {
       active_engine_->Enable(std::string());
       ui::IMEBridge::Get()->SetCurrentEngineHandler(active_engine_);
       return;
     }
     DeleteInputMethodEngine(active_engine_->GetExtensionId());
   }
 
-  scoped_ptr<input_method::InputMethodEngine> engine(
+  std::unique_ptr<input_method::InputMethodEngine> engine(
       new input_method::InputMethodEngine());
-  scoped_ptr<InputMethodEngineBase::Observer> observer(
+  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();
   ui::IMEBridge::Get()->SetCurrentEngineHandler(active_engine_);
 }
 
 void InputImeEventRouter::DeleteInputMethodEngine(
     const std::string& extension_id) {
   if (active_engine_ && active_engine_->GetExtensionId() == extension_id) {
@@ skipping 145 matching lines @@
   int frame_id = engine->CreateImeWindow(
       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_));
 
-  scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->Set("frameId", new base::FundamentalValue(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());
   if (!engine)
     return RespondNow(Error(kErrorNoActiveEngine));
 
-  scoped_ptr<api::input_ime::ShowWindow::Params> params(
+  std::unique_ptr<api::input_ime::ShowWindow::Params> params(
       api::input_ime::ShowWindow::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   engine->ShowImeWindow(params->window_id);
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction InputImeHideWindowFunction::Run() {
   if (!IsInputImeEnabled())
     return RespondNow(Error(kErrorAPIDisabled));
 
   InputMethodEngine* engine =
       GetActiveEngine(browser_context(), extension_id());
   if (!engine)
     return RespondNow(Error(kErrorNoActiveEngine));
 
-  scoped_ptr<api::input_ime::HideWindow::Params> params(
+  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