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

chrome/browser/chromeos/input_method/input_method_manager_impl.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/chromeos/input_method/input_method_manager_impl.h"
 
 #include <stdint.h>
+
 #include <algorithm>  // std::find
+#include <memory>
 #include <sstream>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/hash.h"
 #include "base/location.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/input_method/candidate_window_controller.h"
 #include "chrome/browser/chromeos/input_method/component_extension_ime_manager_impl.h"
 #include "chrome/browser/chromeos/input_method/input_method_switch_recorder.h"
@@ skipping 140 matching lines @@
   return os.str();
 }
 
 scoped_refptr<InputMethodManager::State>
 InputMethodManagerImpl::StateImpl::Clone() const {
   scoped_refptr<StateImpl> new_state(new StateImpl(this->manager_, profile));
   new_state->InitFrom(*this);
   return scoped_refptr<InputMethodManager::State>(new_state.get());
 }
 
-scoped_ptr<InputMethodDescriptors>
+std::unique_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::StateImpl::GetActiveInputMethods() const {
-  scoped_ptr<InputMethodDescriptors> result(new InputMethodDescriptors);
+  std::unique_ptr<InputMethodDescriptors> result(new InputMethodDescriptors);
   // Build the active input method descriptors from the active input
   // methods cache |active_input_method_ids|.
   for (size_t i = 0; i < active_input_method_ids.size(); ++i) {
     const std::string& input_method_id = active_input_method_ids[i];
     const InputMethodDescriptor* descriptor =
         manager_->util_.GetInputMethodDescriptorFromId(input_method_id);
     if (descriptor) {
       result->push_back(*descriptor);
     } else {
       std::map<std::string, InputMethodDescriptor>::const_iterator ix =
@@ skipping 649 matching lines @@
                               false /* show_message */, true /* notify_menu */);
   }
 }
 
 scoped_refptr<InputMethodManager::State>
 InputMethodManagerImpl::GetActiveIMEState() {
   return scoped_refptr<InputMethodManager::State>(state_.get());
 }
 
 InputMethodManagerImpl::InputMethodManagerImpl(
-    scoped_ptr<InputMethodDelegate> delegate,
+    std::unique_ptr<InputMethodDelegate> delegate,
     bool enable_extension_loading)
     : delegate_(std::move(delegate)),
       ui_session_(STATE_LOGIN_SCREEN),
       state_(NULL),
       util_(delegate_.get()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
       enable_extension_loading_(enable_extension_loading),
       is_ime_menu_activated_(false) {
   if (base::SysInfo::IsRunningOnChromeOS())
     keyboard_.reset(ImeKeyboard::Create());
   else
     keyboard_.reset(new FakeImeKeyboard());
 
   // Initializes the system IME list.
-  scoped_ptr<ComponentExtensionIMEManagerDelegate> comp_delegate(
+  std::unique_ptr<ComponentExtensionIMEManagerDelegate> comp_delegate(
       new ComponentExtensionIMEManagerImpl());
   component_extension_ime_manager_->Initialize(std::move(comp_delegate));
   const InputMethodDescriptors& descriptors =
       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
   util_.ResetInputMethods(descriptors);
   chromeos::UserAddingScreen::Get()->AddObserver(this);
 }
 
 InputMethodManagerImpl::~InputMethodManagerImpl() {
   if (candidate_window_controller_.get())
@@ skipping 62 matching lines @@
 void InputMethodManagerImpl::OnUserAddingStarted() {
   if (ui_session_ == STATE_BROWSER_SCREEN)
     SetUISessionState(STATE_SECONDARY_LOGIN_SCREEN);
 }
 
 void InputMethodManagerImpl::OnUserAddingFinished() {
   if (ui_session_ == STATE_SECONDARY_LOGIN_SCREEN)
     SetUISessionState(STATE_BROWSER_SCREEN);
 }
 
-scoped_ptr<InputMethodDescriptors>
+std::unique_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetSupportedInputMethods() const {
-  return scoped_ptr<InputMethodDescriptors>(new InputMethodDescriptors);
+  return std::unique_ptr<InputMethodDescriptors>(new InputMethodDescriptors);
 }
 
 const InputMethodDescriptor* InputMethodManagerImpl::LookupInputMethod(
     const std::string& input_method_id,
     InputMethodManagerImpl::StateImpl* state) {
   DCHECK(state);
 
   std::string input_method_id_to_switch = input_method_id;
 
   // Sanity check
   if (!state->InputMethodIsActivated(input_method_id)) {
-    scoped_ptr<InputMethodDescriptors> input_methods(
+    std::unique_ptr<InputMethodDescriptors> input_methods(
         state->GetActiveInputMethods());
     DCHECK(!input_methods->empty());
     input_method_id_to_switch = input_methods->at(0).id();
     if (!input_method_id.empty()) {
       DVLOG(1) << "Can't change the current input method to "
                << input_method_id << " since the engine is not enabled. "
                << "Switch to " << input_method_id_to_switch << " instead.";
     }
   }
 
@@ skipping 175 matching lines @@
     CandidateWindowController* candidate_window_controller) {
   candidate_window_controller_.reset(candidate_window_controller);
   candidate_window_controller_->AddObserver(this);
 }
 
 void InputMethodManagerImpl::SetImeKeyboardForTesting(ImeKeyboard* keyboard) {
   keyboard_.reset(keyboard);
 }
 
 void InputMethodManagerImpl::InitializeComponentExtensionForTesting(
-    scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
+    std::unique_ptr<ComponentExtensionIMEManagerDelegate> delegate) {
   component_extension_ime_manager_->Initialize(std::move(delegate));
   util_.ResetInputMethods(
       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor());
 }
 
 void InputMethodManagerImpl::CandidateClicked(int index) {
   ui::IMEEngineHandlerInterface* engine =
       ui::IMEBridge::Get()->GetCurrentEngineHandler();
   if (engine)
     engine->CandidateClicked(index);
@@ skipping 35 matching lines @@
 
 void InputMethodManagerImpl::NotifyImeMenuItemsChanged(
     const std::string& engine_id,
     const std::vector<InputMethodManager::MenuItem>& items) {
   FOR_EACH_OBSERVER(InputMethodManager::ImeMenuObserver, ime_menu_observers_,
                     ImeMenuItemsChanged(engine_id, items));
 }
 
 }  // namespace input_method
 }  // namespace chromeos