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

chrome/browser/chromeos/extensions/input_method_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/chromeos/extensions/input_method_api.h"
 
 #include <stddef.h>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 84 matching lines @@
   return RespondNow(OneArgument(new base::StringValue(
       manager->GetActiveIMEState()->GetCurrentInputMethod().id())));
 #endif
 }
 
 ExtensionFunction::ResponseAction
 InputMethodPrivateSetCurrentInputMethodFunction::Run() {
 #if !defined(OS_CHROMEOS)
   EXTENSION_FUNCTION_VALIDATE(false);
 #else
-  scoped_ptr<SetCurrentInputMethod::Params> params(
+  std::unique_ptr<SetCurrentInputMethod::Params> params(
       SetCurrentInputMethod::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   scoped_refptr<chromeos::input_method::InputMethodManager::State> ime_state =
       chromeos::input_method::InputMethodManager::Get()->GetActiveIMEState();
   const std::vector<std::string>& input_methods =
       ime_state->GetActiveInputMethodIds();
   for (size_t i = 0; i < input_methods.size(); ++i) {
     const std::string& input_method = input_methods[i];
     if (input_method == params->input_method_id) {
       ime_state->ChangeInputMethod(params->input_method_id,
                                    false /* show_message */);
       return RespondNow(NoArguments());
     }
   }
   return RespondNow(Error("Invalid input method id."));
 #endif
 }
 
 ExtensionFunction::ResponseAction
 InputMethodPrivateGetInputMethodsFunction::Run() {
 #if !defined(OS_CHROMEOS)
   EXTENSION_FUNCTION_VALIDATE(false);
 #else
   base::ListValue* output = new base::ListValue();
   chromeos::input_method::InputMethodManager* manager =
       chromeos::input_method::InputMethodManager::Get();
   chromeos::input_method::InputMethodUtil* util = manager->GetInputMethodUtil();
   scoped_refptr<chromeos::input_method::InputMethodManager::State> ime_state =
       manager->GetActiveIMEState();
-  scoped_ptr<chromeos::input_method::InputMethodDescriptors> input_methods =
-      ime_state->GetActiveInputMethods();
+  std::unique_ptr<chromeos::input_method::InputMethodDescriptors>
+      input_methods = ime_state->GetActiveInputMethods();
   for (size_t i = 0; i < input_methods->size(); ++i) {
     const chromeos::input_method::InputMethodDescriptor& input_method =
         (*input_methods)[i];
     base::DictionaryValue* val = new base::DictionaryValue();
     val->SetString("id", input_method.id());
     val->SetString("name", util->GetInputMethodLongName(input_method));
     val->SetString("indicator", util->GetInputMethodShortName(input_method));
     output->Append(val);
   }
   return RespondNow(OneArgument(output));
@@ skipping 22 matching lines @@
   }
   return RespondNow(OneArgument(output));
 #endif
 }
 
 ExtensionFunction::ResponseAction
 InputMethodPrivateAddWordToDictionaryFunction::Run() {
 #if !defined(OS_CHROMEOS)
   EXTENSION_FUNCTION_VALIDATE(false);
 #else
-  scoped_ptr<AddWordToDictionary::Params> params(
+  std::unique_ptr<AddWordToDictionary::Params> params(
       AddWordToDictionary::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   SpellcheckService* spellcheck = SpellcheckServiceFactory::GetForContext(
       context_);
   if (!spellcheck) {
     return RespondNow(Error("Spellcheck service not available."));
   }
   SpellcheckCustomDictionary* dictionary = spellcheck->GetCustomDictionary();
   if (!dictionary->IsLoaded()) {
     return RespondNow(Error("Custom dictionary not loaded yet."));
@@ skipping 14 matching lines @@
 ExtensionFunction::ResponseAction
 InputMethodPrivateGetEncryptSyncEnabledFunction::Run() {
 #if !defined(OS_CHROMEOS)
   EXTENSION_FUNCTION_VALIDATE(false);
 #else
   ProfileSyncService* profile_sync_service =
       ProfileSyncServiceFactory::GetForProfile(
           Profile::FromBrowserContext(browser_context()));
   if (!profile_sync_service)
     return RespondNow(Error("Sync service is not ready for current profile."));
-  scoped_ptr<base::Value> ret(new base::FundamentalValue(
+  std::unique_ptr<base::Value> ret(new base::FundamentalValue(
       profile_sync_service->IsEncryptEverythingEnabled()));
   return RespondNow(OneArgument(std::move(ret)));
 #endif
 }
 
 ExtensionFunction::ResponseAction
 InputMethodPrivateSetXkbLayoutFunction::Run() {
 #if !defined(OS_CHROMEOS)
   EXTENSION_FUNCTION_VALIDATE(false);
 #else
-  scoped_ptr<SetXkbLayout::Params> params(SetXkbLayout::Params::Create(*args_));
+  std::unique_ptr<SetXkbLayout::Params> params(
+      SetXkbLayout::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   chromeos::input_method::InputMethodManager* manager =
       chromeos::input_method::InputMethodManager::Get();
   chromeos::input_method::ImeKeyboard* keyboard = manager->GetImeKeyboard();
   keyboard->SetCurrentKeyboardLayoutByName(params->xkb_name);
   return RespondNow(NoArguments());
 #endif
 }
 
 ExtensionFunction::ResponseAction
@@ skipping 96 matching lines @@
 static base::LazyInstance<BrowserContextKeyedAPIFactory<InputMethodAPI> >
     g_factory = LAZY_INSTANCE_INITIALIZER;
 
 // static
 BrowserContextKeyedAPIFactory<InputMethodAPI>*
 InputMethodAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 }  // namespace extensions