Convert Pass()→std::move() for CrOS extension code.

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"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/login/lock/screen_locker.h"
 #include "chrome/browser/chromeos/login/session/user_session_manager.h"
 #include "chrome/browser/chromeos/login/ui/user_adding_screen.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/input_ime.h"
@@ skipping 67 matching lines @@
   void OnActivate(const std::string& component_id) override {
     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())));
 
     DispatchEventToExtension(extensions::events::INPUT_IME_ON_ACTIVATE,
-                             input_ime::OnActivate::kEventName, args.Pass());
+                             input_ime::OnActivate::kEventName,
+                             std::move(args));
   }
 
   void OnInputContextUpdate(
       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(
         input_ime::OnInputContextUpdate::Create(context_value));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_INPUT_CONTEXT_UPDATE,
-        input_ime::OnInputContextUpdate::kEventName, args.Pass());
+        input_ime::OnInputContextUpdate::kEventName, std::move(args));
   }
 
   bool IsInterestedInKeyEvent() const override {
     return ShouldForwardKeyEvent();
   }
 
   void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
       ui::IMEEngineObserver::MouseButtonEvent button) override {
@@ skipping 16 matching lines @@
       default:
         button_enum = input_ime::MOUSE_BUTTON_LEFT;
         break;
     }
 
     scoped_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,
-                             args.Pass());
+                             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(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_MENU_ITEM_ACTIVATED,
-        input_ime::OnMenuItemActivated::kEventName, args.Pass());
+        input_ime::OnMenuItemActivated::kEventName, std::move(args));
   }
 
   void OnSurroundingTextChanged(const std::string& component_id,
                                 const std::string& text,
                                 int cursor_pos,
                                 int anchor_pos,
                                 int offset_pos) override {
     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));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_SURROUNDING_TEXT_CHANGED,
-        input_ime::OnSurroundingTextChanged::kEventName, args.Pass());
+        input_ime::OnSurroundingTextChanged::kEventName, std::move(args));
   }
 
   void OnCompositionBoundsChanged(
       const std::vector<gfx::Rect>& bounds) override {
     if (extension_id_.empty() ||
         !HasListener(kOnCompositionBoundsChangedEventName))
       return;
 
     // Note: this is a private API event.
     base::ListValue* bounds_list = new base::ListValue();
@@ skipping 12 matching lines @@
 
     // 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,
-        kOnCompositionBoundsChangedEventName, args.Pass());
+        kOnCompositionBoundsChangedEventName, 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 {
     if (event_name != input_ime::OnActivate::kEventName) {
       // For suspended IME extension (e.g. XKB extension), don't awake it by IME
@@ skipping 12 matching lines @@
         extensions::ProcessManager* process_manager =
             extensions::ProcessManager::Get(profile_);
         if (extensions::BackgroundInfo::HasBackgroundPage(extension) &&
             !process_manager->GetBackgroundHostForExtension(extension_id_)) {
           return;
         }
       }
     }
 
     scoped_ptr<extensions::Event> event(
-        new extensions::Event(histogram_value, event_name, args.Pass()));
+        new extensions::Event(histogram_value, event_name, std::move(args)));
     event->restrict_to_browser_context = profile_;
     extensions::EventRouter::Get(profile_)
-        ->DispatchEventToExtension(extension_id_, event.Pass());
+        ->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() {
     switch (chromeos::input_method::InputMethodManager::Get()
                 ->GetUISessionState()) {
       case chromeos::input_method::InputMethodManager::STATE_LOGIN_SCREEN:
         return "login";
@@ skipping 57 matching lines @@
           languages,
           false,  // 3rd party IMEs are always not for login.
           component.options_page_url,
           component.input_view_url));
     }
   }
 
   scoped_ptr<ui::IMEEngineObserver> observer(
       new ImeObserverChromeOS(extension_id, profile_));
   chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
-  engine->Initialize(observer.Pass(), extension_id.c_str(), profile_);
+  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;
 }
 
 void InputImeEventRouter::UnregisterAllImes(const std::string& extension_id) {
   std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
@@ skipping 339 matching lines @@
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   engine->DeleteSurroundingText(params.context_id, params.offset, params.length,
                                 &error_);
   return true;
 }
 
 }  // namespace extensions