Replace scoped_ptr with std::unique_ptr in //ui

ui/events/gestures/blink/web_gesture_curve_impl.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/gestures/blink/web_gesture_curve_impl.h"
 
 #include <limits.h>
 
 #include <utility>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "build/build_config.h"
 #include "third_party/WebKit/public/platform/WebFloatSize.h"
 #include "third_party/WebKit/public/platform/WebGestureCurveTarget.h"
 #include "ui/events/gestures/fling_curve.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/geometry/vector2d.h"
 
 #if defined(OS_ANDROID)
 #include "ui/events/android/scroller.h"
 #endif
 
 using blink::WebGestureCurve;
 
 namespace ui {
 namespace {
 
-scoped_ptr<GestureCurve> CreateDefaultPlatformCurve(
+std::unique_ptr<GestureCurve> CreateDefaultPlatformCurve(
     const gfx::Vector2dF& initial_velocity) {
   DCHECK(!initial_velocity.IsZero());
 #if defined(OS_ANDROID)
-  auto scroller = make_scoped_ptr(new Scroller(Scroller::Config()));
+  auto scroller = base::WrapUnique(new Scroller(Scroller::Config()));
   scroller->Fling(0,
                   0,
                   initial_velocity.x(),
                   initial_velocity.y(),
                   INT_MIN,
                   INT_MAX,
                   INT_MIN,
                   INT_MAX,
                   base::TimeTicks());
   return std::move(scroller);
 #else
-  return make_scoped_ptr(
-      new FlingCurve(initial_velocity, base::TimeTicks()));
+  return base::WrapUnique(new FlingCurve(initial_velocity, base::TimeTicks()));
 #endif
 }
 
 }  // namespace
 
 // static
-scoped_ptr<WebGestureCurve> WebGestureCurveImpl::CreateFromDefaultPlatformCurve(
+std::unique_ptr<WebGestureCurve>
+WebGestureCurveImpl::CreateFromDefaultPlatformCurve(
     const gfx::Vector2dF& initial_velocity,
     const gfx::Vector2dF& initial_offset,
     bool on_main_thread) {
-  return scoped_ptr<WebGestureCurve>(new WebGestureCurveImpl(
+  return std::unique_ptr<WebGestureCurve>(new WebGestureCurveImpl(
       CreateDefaultPlatformCurve(initial_velocity), initial_offset,
       on_main_thread ? ThreadType::MAIN : ThreadType::IMPL));
 }
 
 // static
-scoped_ptr<WebGestureCurve> WebGestureCurveImpl::CreateFromUICurveForTesting(
-    scoped_ptr<GestureCurve> curve,
+std::unique_ptr<WebGestureCurve>
+WebGestureCurveImpl::CreateFromUICurveForTesting(
+    std::unique_ptr<GestureCurve> curve,
     const gfx::Vector2dF& initial_offset) {
-  return scoped_ptr<WebGestureCurve>(new WebGestureCurveImpl(
+  return std::unique_ptr<WebGestureCurve>(new WebGestureCurveImpl(
       std::move(curve), initial_offset, ThreadType::TEST));
 }
 
-WebGestureCurveImpl::WebGestureCurveImpl(scoped_ptr<GestureCurve> curve,
+WebGestureCurveImpl::WebGestureCurveImpl(std::unique_ptr<GestureCurve> curve,
                                          const gfx::Vector2dF& initial_offset,
                                          ThreadType animating_thread_type)
     : curve_(std::move(curve)),
       last_offset_(initial_offset),
       animating_thread_type_(animating_thread_type),
       ticks_since_first_animate_(0),
       first_animate_time_(0),
       last_animate_time_(0) {}
 
 WebGestureCurveImpl::~WebGestureCurveImpl() {
@@ skipping 55 matching lines @@
     return still_active;
 
   // scrollBy() could delete this curve if the animation is over, so don't touch
   // any member variables after making that call.
   bool did_scroll = target->scrollBy(blink::WebFloatSize(delta),
                                      blink::WebFloatSize(velocity));
   return did_scroll && still_active;
 }
 
 }  // namespace ui