Replace scoped_ptr with std::unique_ptr in //ui

ui/events/gesture_detection/motion_event_buffer.cc

 // Copyright 2014 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 "ui/events/gesture_detection/motion_event_buffer.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 99 matching lines @@
   PointerProperties p(event0, event0_pointer_index);
   p.x = Lerp(p.x, event1.GetX(event1_pointer_index), alpha);
   p.y = Lerp(p.y, event1.GetY(event1_pointer_index), alpha);
   p.raw_x = Lerp(p.raw_x, event1.GetRawX(event1_pointer_index), alpha);
   p.raw_y = Lerp(p.raw_y, event1.GetRawY(event1_pointer_index), alpha);
   return p;
 }
 
 // Linearly interpolate the pointers between two event samples using the
 // provided |resample_time|.
-scoped_ptr<MotionEventGeneric> ResampleMotionEvent(
+std::unique_ptr<MotionEventGeneric> ResampleMotionEvent(
     const MotionEvent& event0,
     const MotionEvent& event1,
     base::TimeTicks resample_time) {
   DCHECK_EQ(MotionEvent::ACTION_MOVE, event0.GetAction());
   DCHECK_EQ(event0.GetPointerCount(), event1.GetPointerCount());
 
   const base::TimeTicks time0 = event0.GetEventTime();
   const base::TimeTicks time1 = event1.GetEventTime();
   DCHECK(time0 < time1);
   DCHECK(time0 <= resample_time);
 
   const float alpha = (resample_time - time0).InMillisecondsF() /
                       (time1 - time0).InMillisecondsF();
 
-  scoped_ptr<MotionEventGeneric> event;
+  std::unique_ptr<MotionEventGeneric> event;
   const size_t pointer_count = event0.GetPointerCount();
   DCHECK_EQ(pointer_count, event1.GetPointerCount());
   for (size_t event0_i = 0; event0_i < pointer_count; ++event0_i) {
     int event1_i = event1.FindPointerIndexOfId(event0.GetPointerId(event0_i));
     DCHECK_NE(event1_i, -1);
     PointerProperties pointer = ResamplePointer(
         event0, event1, event0_i, static_cast<size_t>(event1_i), alpha);
 
     if (event0_i == 0) {
       event.reset(new MotionEventGeneric(
           MotionEvent::ACTION_MOVE, resample_time, pointer));
     } else {
       event->PushPointer(pointer);
     }
   }
 
   DCHECK(event);
   event->set_button_state(event0.GetButtonState());
   return event;
 }
 
 // Synthesize a compound MotionEventGeneric event from a sequence of events.
 // Events must be in non-decreasing (time) order.
-scoped_ptr<MotionEventGeneric> ConsumeSamples(MotionEventVector events) {
+std::unique_ptr<MotionEventGeneric> ConsumeSamples(MotionEventVector events) {
   DCHECK(!events.empty());
-  scoped_ptr<MotionEventGeneric> event(events.back());
+  std::unique_ptr<MotionEventGeneric> event(events.back());
   for (size_t i = 0; i + 1 < events.size(); ++i)
-    event->PushHistoricalEvent(scoped_ptr<MotionEvent>(events[i]));
+    event->PushHistoricalEvent(std::unique_ptr<MotionEvent>(events[i]));
   events.weak_clear();
   return event;
 }
 
 // Consume a series of event samples, attempting to synthesize a new, synthetic
 // event if the samples and sample time meet certain interpolation/extrapolation
 // conditions. If such conditions are met, the provided samples will be added
 // to the synthetic event's history, otherwise, the samples will be used to
 // generate a basic, compound event.
 // TODO(jdduke): Revisit resampling to handle cases where alternating frames
 // are resampled or resampling is otherwise inconsistent, e.g., a 90hz input
 // and 60hz frame signal could phase-align such that even frames yield an
 // extrapolated event and odd frames are not resampled, crbug.com/399381.
-scoped_ptr<MotionEventGeneric> ConsumeSamplesAndTryResampling(
+std::unique_ptr<MotionEventGeneric> ConsumeSamplesAndTryResampling(
     base::TimeTicks resample_time,
     MotionEventVector events,
     const MotionEvent* next) {
   const ui::MotionEvent* event0 = nullptr;
   const ui::MotionEvent* event1 = nullptr;
   if (next) {
     DCHECK(resample_time < next->GetEventTime());
     // Interpolate between current sample and future sample.
     event0 = events.back();
     event1 = next;
@@ skipping 31 matching lines @@
   base::TimeDelta delta = time1 - time0;
   if (delta < base::TimeDelta::FromMilliseconds(kResampleMinDeltaMs)) {
     TRACE_EVENT_INSTANT1("input",
                          "MotionEventBuffer::TryResample failure",
                          TRACE_EVENT_SCOPE_THREAD,
                          "event_delta_too_small(ms)",
                          delta.InMilliseconds());
     return ConsumeSamples(std::move(events));
   }
 
-  scoped_ptr<MotionEventGeneric> resampled_event =
+  std::unique_ptr<MotionEventGeneric> resampled_event =
       ResampleMotionEvent(*event0, *event1, resample_time);
   for (size_t i = 0; i < events.size(); ++i)
-    resampled_event->PushHistoricalEvent(scoped_ptr<MotionEvent>(events[i]));
+    resampled_event->PushHistoricalEvent(
+        std::unique_ptr<MotionEvent>(events[i]));
   events.weak_clear();
   return resampled_event;
 }
 
 }  // namespace
 
 MotionEventBuffer::MotionEventBuffer(MotionEventBufferClient* client,
                                      bool enable_resampling)
     : client_(client), resample_(enable_resampling) {
 }
@@ skipping 13 matching lines @@
 
   // Guard against events that are *older* than the last one that may have been
   // artificially synthesized.
   if (!last_extrapolated_event_time_.is_null()) {
     DCHECK(buffered_events_.empty());
     if (event.GetEventTime() < last_extrapolated_event_time_)
       return;
     last_extrapolated_event_time_ = base::TimeTicks();
   }
 
-  scoped_ptr<MotionEventGeneric> clone = MotionEventGeneric::CloneEvent(event);
+  std::unique_ptr<MotionEventGeneric> clone =
+      MotionEventGeneric::CloneEvent(event);
   if (buffered_events_.empty()) {
     buffered_events_.push_back(std::move(clone));
     client_->SetNeedsFlush();
     return;
   }
 
   if (CanAddSample(*buffered_events_.front(), *clone)) {
     DCHECK(buffered_events_.back()->GetEventTime() <= clone->GetEventTime());
   } else {
     FlushWithoutResampling(std::move(buffered_events_));
@@ skipping 32 matching lines @@
   FlushWithResampling(std::move(events), frame_time);
 }
 
 void MotionEventBuffer::FlushWithResampling(MotionEventVector events,
                                             base::TimeTicks resample_time) {
   DCHECK(!events.empty());
   base::TimeTicks original_event_time = events.back()->GetEventTime();
   const MotionEvent* next_event =
       !buffered_events_.empty() ? buffered_events_.front() : nullptr;
 
-  scoped_ptr<MotionEventGeneric> resampled_event =
+  std::unique_ptr<MotionEventGeneric> resampled_event =
       ConsumeSamplesAndTryResampling(resample_time, std::move(events),
                                      next_event);
   DCHECK(resampled_event);
 
   // Log the extrapolated event time, guarding against subsequently queued
   // events that might have an earlier timestamp.
   if (!next_event && resampled_event->GetEventTime() > original_event_time) {
     last_extrapolated_event_time_ = resampled_event->GetEventTime();
   } else {
     last_extrapolated_event_time_ = base::TimeTicks();
   }
 
   client_->ForwardMotionEvent(*resampled_event);
   if (!buffered_events_.empty())
     client_->SetNeedsFlush();
 }
 
 void MotionEventBuffer::FlushWithoutResampling(MotionEventVector events) {
   last_extrapolated_event_time_ = base::TimeTicks();
   if (events.empty())
     return;
 
   client_->ForwardMotionEvent(*ConsumeSamples(std::move(events)));
 }
 
 }  // namespace ui