Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/input/render_widget_input_handler.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 "content/renderer/input/render_widget_input_handler.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 170 matching lines @@
     const WebInputEvent& input_event,
     const ui::LatencyInfo& latency_info,
     InputEventDispatchType dispatch_type) {
   base::AutoReset<bool> handling_input_event_resetter(&handling_input_event_,
                                                       true);
   base::AutoReset<WebInputEvent::Type> handling_event_type_resetter(
       &handling_event_type_, input_event.type);
 
   // Calls into |didOverscroll()| while handling this event will populate
   // |event_overscroll|, which in turn will be bundled with the event ack.
-  scoped_ptr<DidOverscrollParams> event_overscroll;
-  base::AutoReset<scoped_ptr<DidOverscrollParams>*>
+  std::unique_ptr<DidOverscrollParams> event_overscroll;
+  base::AutoReset<std::unique_ptr<DidOverscrollParams>*>
       handling_event_overscroll_resetter(&handling_event_overscroll_,
                                          &event_overscroll);
 
 #if defined(OS_ANDROID)
   bool from_ime = false;
 
   // For most keyboard events, we want the change source to be FROM_IME because
   // we don't need to update IME states in ReplicaInputConnection.
   if (!widget_->IsUsingImeThread() &&
       WebInputEvent::isKeyboardEventType(input_event.type)) {
@@ skipping 31 matching lines @@
   TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
                          TRACE_ID_DONT_MANGLE(latency_info.trace_id()),
                          TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
                          "step", "HandleInputEventMain");
 
   // If we don't have a high res timer, these metrics won't be accurate enough
   // to be worth collecting. Note that this does introduce some sampling bias.
   if (!start_time.is_null())
     LogInputEventLatencyUma(input_event, start_time);
 
-  scoped_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
+  std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor;
   ui::LatencyInfo swap_latency_info(latency_info);
 
   if (widget_->compositor()) {
     latency_info_swap_promise_monitor =
         widget_->compositor()->CreateLatencyInfoSwapPromiseMonitor(
             &swap_latency_info);
   }
 
   bool prevent_default = false;
   if (WebInputEvent::isMouseEventType(input_event.type)) {
@@ skipping 149 matching lines @@
   if (dispatch_type == DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN ||
       dispatch_type == DISPATCH_TYPE_NON_BLOCKING_NOTIFY_MAIN) {
     // |non_blocking| means it was ack'd already by the InputHandlerProxy
     // so let the delegate know the event has been handled.
     delegate_->NotifyInputEventHandled(input_event.type);
   }
 
   if ((dispatch_type == DISPATCH_TYPE_BLOCKING ||
        dispatch_type == DISPATCH_TYPE_BLOCKING_NOTIFY_MAIN) &&
       can_send_ack) {
-    scoped_ptr<InputEventAck> response(new InputEventAck(
+    std::unique_ptr<InputEventAck> response(new InputEventAck(
         input_event.type, ack_result, swap_latency_info,
         std::move(event_overscroll),
         WebInputEventTraits::GetUniqueTouchEventId(input_event)));
     if (rate_limiting_wanted && frame_pending && !widget_->is_hidden()) {
       // We want to rate limit the input events in this case, so we'll wait for
       // painting to finish before ACKing this message.
       TRACE_EVENT_INSTANT0(
           "renderer",
           "RenderWidgetInputHandler::OnHandleInputEvent ack throttled",
           TRACE_EVENT_SCOPE_THREAD);
@@ skipping 57 matching lines @@
     delegate_->FocusChangeComplete();
   }
 #endif
 }
 
 void RenderWidgetInputHandler::DidOverscrollFromBlink(
     const WebFloatSize& unusedDelta,
     const WebFloatSize& accumulatedRootOverScroll,
     const WebFloatPoint& position,
     const WebFloatSize& velocity) {
-  scoped_ptr<DidOverscrollParams> params(new DidOverscrollParams());
+  std::unique_ptr<DidOverscrollParams> params(new DidOverscrollParams());
   params->accumulated_overscroll = gfx::Vector2dF(
       accumulatedRootOverScroll.width, accumulatedRootOverScroll.height);
   params->latest_overscroll_delta =
       gfx::Vector2dF(unusedDelta.width, unusedDelta.height);
   // TODO(sataya.m): don't negate velocity once http://crbug.com/499743 is
   // fixed.
   params->current_fling_velocity =
       gfx::Vector2dF(-velocity.width, -velocity.height);
   params->causal_event_viewport_point = gfx::PointF(position.x, position.y);
 
   // If we're currently handling an event, stash the overscroll data such that
   // it can be bundled in the event ack.
   if (handling_event_overscroll_) {
     *handling_event_overscroll_ = std::move(params);
     return;
   }
 
   delegate_->OnDidOverscroll(*params);
 }
 
 bool RenderWidgetInputHandler::SendAckForMouseMoveFromDebugger() {
   if (handling_event_type_ == WebInputEvent::MouseMove) {
     // If we pause multiple times during a single mouse move event, we should
     // only send ACK once.
     if (!ignore_ack_for_mouse_move_from_debugger_) {
-      scoped_ptr<InputEventAck> ack(new InputEventAck(
+      std::unique_ptr<InputEventAck> ack(new InputEventAck(
           handling_event_type_, INPUT_EVENT_ACK_STATE_CONSUMED));
       delegate_->OnInputEventAck(std::move(ack));
       return true;
     }
   }
   return false;
 }
 
 void RenderWidgetInputHandler::IgnoreAckForMouseMoveFromDebugger() {
   ignore_ack_for_mouse_move_from_debugger_ = true;
 }
 
 void RenderWidgetInputHandler::FlushPendingInputEventAck() {
   if (pending_input_event_ack_) {
     TRACE_EVENT_ASYNC_END0("input",
                            "RenderWidgetInputHandler::ThrottledInputEventAck",
                            pending_input_event_ack_.get());
     delegate_->OnInputEventAck(std::move(pending_input_event_ack_));
   }
   total_input_handling_time_this_frame_ = base::TimeDelta();
 }
 
 }  // namespace content