Replace scoped_ptr with std::unique_ptr in //ui

ui/events/gesture_detection/motion_event_generic.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.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/events/gesture_detection/motion_event_generic.h"
 
 #include <cmath>
 #include <utility>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "ui/events/base_event_utils.h"
 
 namespace ui {
 
 PointerProperties::PointerProperties()
     : PointerProperties(0, 0, 0) {
 }
 
 PointerProperties::PointerProperties(float x, float y, float touch_major)
     : id(0),
@@ skipping 197 matching lines @@
   return historical_events_[historical_index]->GetX(pointer_index);
 }
 
 float MotionEventGeneric::GetHistoricalY(size_t pointer_index,
                                          size_t historical_index) const {
   DCHECK_LT(historical_index, historical_events_.size());
   return historical_events_[historical_index]->GetY(pointer_index);
 }
 
 // static
-scoped_ptr<MotionEventGeneric> MotionEventGeneric::CloneEvent(
+std::unique_ptr<MotionEventGeneric> MotionEventGeneric::CloneEvent(
     const MotionEvent& event) {
   bool with_history = true;
-  return make_scoped_ptr(new MotionEventGeneric(event, with_history));
+  return base::WrapUnique(new MotionEventGeneric(event, with_history));
 }
 
 // static
-scoped_ptr<MotionEventGeneric> MotionEventGeneric::CancelEvent(
+std::unique_ptr<MotionEventGeneric> MotionEventGeneric::CancelEvent(
     const MotionEvent& event) {
   bool with_history = false;
-  scoped_ptr<MotionEventGeneric> cancel_event(
+  std::unique_ptr<MotionEventGeneric> cancel_event(
       new MotionEventGeneric(event, with_history));
   cancel_event->set_action(ACTION_CANCEL);
   cancel_event->set_unique_event_id(ui::GetNextTouchEventId());
   return cancel_event;
 }
 
 size_t MotionEventGeneric::PushPointer(const PointerProperties& pointer) {
   DCHECK_EQ(0U, GetHistorySize());
   pointers_->push_back(pointer);
   return pointers_->size() - 1;
 }
 
 void MotionEventGeneric::RemovePointerAt(size_t index) {
   DCHECK_LT(index, pointers_->size());
   pointers_->erase(pointers_->begin() + index);
 }
 
-void MotionEventGeneric::PushHistoricalEvent(scoped_ptr<MotionEvent> event) {
+void MotionEventGeneric::PushHistoricalEvent(
+    std::unique_ptr<MotionEvent> event) {
   DCHECK(event);
   DCHECK_EQ(event->GetAction(), ACTION_MOVE);
   DCHECK_EQ(event->GetPointerCount(), GetPointerCount());
   DCHECK_EQ(event->GetAction(), GetAction());
   DCHECK_LE(event->GetEventTime().ToInternalValue(),
             GetEventTime().ToInternalValue());
   historical_events_.push_back(std::move(event));
 }
 
 MotionEventGeneric::MotionEventGeneric()
@@ skipping 16 matching lines @@
       flags_(event.GetFlags()) {
   const size_t pointer_count = event.GetPointerCount();
   for (size_t i = 0; i < pointer_count; ++i)
     PushPointer(PointerProperties(event, i));
 
   if (!with_history)
     return;
 
   const size_t history_size = event.GetHistorySize();
   for (size_t h = 0; h < history_size; ++h) {
-    scoped_ptr<MotionEventGeneric> historical_event(new MotionEventGeneric());
+    std::unique_ptr<MotionEventGeneric> historical_event(
+        new MotionEventGeneric());
     historical_event->set_action(ACTION_MOVE);
     historical_event->set_event_time(event.GetHistoricalEventTime(h));
     for (size_t i = 0; i < pointer_count; ++i) {
       historical_event->PushPointer(
           PointerProperties(event.GetHistoricalX(i, h),
                             event.GetHistoricalY(i, h),
                             event.GetHistoricalTouchMajor(i, h)));
     }
     PushHistoricalEvent(std::move(historical_event));
   }
@@ skipping 13 matching lines @@
     PushHistoricalEvent(other.historical_events_[h]->Clone());
   return *this;
 }
 
 void MotionEventGeneric::PopPointer() {
   DCHECK_GT(pointers_->size(), 0U);
   pointers_->pop_back();
 }
 
 }  // namespace ui