Convert Pass()→std::move() in //content/browser

content/browser/renderer_host/input/input_router_impl.cc

 // Copyright 2013 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 "content/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
+#include <utility>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/renderer_host/input/gesture_event_queue.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
@@ skipping 71 matching lines @@
 InputRouterImpl::~InputRouterImpl() {
   STLDeleteElements(&pending_select_messages_);
 }
 
 bool InputRouterImpl::SendInput(scoped_ptr<IPC::Message> message) {
   DCHECK(IPC_MESSAGE_ID_CLASS(message->type()) == InputMsgStart);
   switch (message->type()) {
     // Check for types that require an ACK.
     case InputMsg_SelectRange::ID:
     case InputMsg_MoveRangeSelectionExtent::ID:
-      return SendSelectMessage(message.Pass());
+      return SendSelectMessage(std::move(message));
     case InputMsg_MoveCaret::ID:
-      return SendMoveCaret(message.Pass());
+      return SendMoveCaret(std::move(message));
     case InputMsg_HandleInputEvent::ID:
       NOTREACHED() << "WebInputEvents should never be sent via SendInput.";
       return false;
     default:
       return Send(message.release());
   }
 }
 
 void InputRouterImpl::SendMouseEvent(
     const MouseEventWithLatencyInfo& mouse_event) {
@@ skipping 209 matching lines @@
     return true;
   }
 
   select_message_pending_ = true;
   return Send(message.release());
 }
 
 bool InputRouterImpl::SendMoveCaret(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_MoveCaret::ID);
   if (move_caret_pending_) {
-    next_move_caret_ = message.Pass();
+    next_move_caret_ = std::move(message);
     return true;
   }
 
   move_caret_pending_ = true;
   return Send(message.release());
 }
 
 bool InputRouterImpl::Send(IPC::Message* message) {
   return sender_->Send(message);
 }
@@ skipping 111 matching lines @@
                        ack.unique_touch_event_id, RENDERER);
 }
 
 void InputRouterImpl::OnDidOverscroll(const DidOverscrollParams& params) {
   client_->DidOverscroll(params);
 }
 
 void InputRouterImpl::OnMsgMoveCaretAck() {
   move_caret_pending_ = false;
   if (next_move_caret_)
-    SendMoveCaret(next_move_caret_.Pass());
+    SendMoveCaret(std::move(next_move_caret_));
 }
 
 void InputRouterImpl::OnSelectMessageAck() {
   select_message_pending_ = false;
   if (!pending_select_messages_.empty()) {
     scoped_ptr<IPC::Message> next_message =
         make_scoped_ptr(pending_select_messages_.front());
     pending_select_messages_.pop_front();
 
-    SendSelectMessage(next_message.Pass());
+    SendSelectMessage(std::move(next_message));
   }
 }
 
 void InputRouterImpl::OnHasTouchEventHandlers(bool has_handlers) {
   TRACE_EVENT1("input", "InputRouterImpl::OnHasTouchEventHandlers",
                "has_handlers", has_handlers);
 
   // Lack of a touch handler indicates that the page either has no touch-action
   // modifiers or that all its touch-action modifiers are auto. Resetting the
   // touch-action here allows forwarding of subsequent gestures even if the
@@ skipping 94 matching lines @@
     return;
 
   current_mouse_move_.latency.AddNewLatencyFrom(latency);
   ack_handler_->OnMouseEventAck(current_mouse_move_, ack_result);
 
   DCHECK(mouse_move_pending_);
   mouse_move_pending_ = false;
 
   if (next_mouse_move_) {
     DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
-    scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move
-        = next_mouse_move_.Pass();
+    scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move =
+        std::move(next_mouse_move_);
     SendMouseEvent(*next_mouse_move);
   }
 }
 
 void InputRouterImpl::ProcessWheelAck(InputEventAckState ack_result,
                                       const ui::LatencyInfo& latency) {
   // TODO(miletus): Add renderer side latency to each uncoalesced mouse
   // wheel event and add terminal component to each of them.
   current_wheel_event_.latency.AddNewLatencyFrom(latency);
 
@@ skipping 50 matching lines @@
     return;
 
   if (HasPendingEvents())
     return;
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
 }  // namespace content