Global conversion of Pass()→std::move() on OS=linux (GYP edition)

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 <utility>
+
 #include "base/strings/string_number_conversions.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "chrome/common/extensions/api/input_ime/input_components_handler.h"
 #include "extensions/browser/extension_registry.h"
 
 namespace input_ime = extensions::api::input_ime;
 namespace KeyEventHandled = extensions::api::input_ime::KeyEventHandled;
 using ui::IMEEngineHandlerInterface;
 
 namespace ui {
@@ skipping 10 matching lines @@
   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));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_FOCUS,
-                           input_ime::OnFocus::kEventName, args.Pass());
+                           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));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_BLUR,
-                           input_ime::OnBlur::kEventName, args.Pass());
+                           input_ime::OnBlur::kEventName, std::move(args));
 }
 
 void ImeObserver::OnKeyEvent(
     const std::string& component_id,
     const IMEEngineHandlerInterface::KeyboardEvent& event,
     IMEEngineHandlerInterface::KeyEventDoneCallback& key_data) {
   if (extension_id_.empty())
     return;
 
   // If there is no listener for the event, no need to dispatch the event to
@@ skipping 17 matching lines @@
   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(
       input_ime::OnKeyEvent::Create(component_id, key_data_value));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_KEY_EVENT,
-                           input_ime::OnKeyEvent::kEventName, args.Pass());
+                           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));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_RESET,
-                           input_ime::OnReset::kEventName, args.Pass());
+                           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(
       input_ime::OnDeactivated::Create(component_id));
 
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_DEACTIVATED,
-                           input_ime::OnDeactivated::kEventName, args.Pass());
+                           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(
     const std::vector<gfx::Rect>& bounds) {}
 
 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
@@ skipping 200 matching lines @@
 }
 
 InputImeEventRouter* GetInputImeEventRouter(Profile* profile) {
   if (profile->HasOffTheRecordProfile())
     profile = profile->GetOffTheRecordProfile();
   return extensions::InputImeEventRouterFactory::GetInstance()->GetRouter(
       profile);
 }
 
 }  // namespace extensions