Convert //cc from scoped_ptr to std::unique_ptr.

cc/input/page_scale_animation.h

 // Copyright 2011 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.
 
 #ifndef CC_INPUT_PAGE_SCALE_ANIMATION_H_
 #define CC_INPUT_PAGE_SCALE_ANIMATION_H_
 
+#include <memory>
+
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
 #include "ui/gfx/geometry/size_f.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/geometry/vector2d_f.h"
 
 namespace cc {
 
 class TimingFunction;
 
@@ skipping 19 matching lines @@
 // double-tap zoom. Initialize it with starting and ending scroll/page scale
 // positions and an animation length time, then call ...AtTime() at every frame
 // to obtain the current interpolated position. The supplied timing function
 // is used to ease the animation.
 //
 // All sizes and vectors in this class's public methods are in the root scroll
 // layer's coordinate space.
 class CC_EXPORT PageScaleAnimation {
  public:
   // Construct with the state at the beginning of the animation.
-  static scoped_ptr<PageScaleAnimation> Create(
+  static std::unique_ptr<PageScaleAnimation> Create(
       const gfx::Vector2dF& start_scroll_offset,
       float start_page_scale_factor,
       const gfx::SizeF& viewport_size,
       const gfx::SizeF& root_layer_size,
-      scoped_ptr<TimingFunction> timing_function);
+      std::unique_ptr<TimingFunction> timing_function);
 
   ~PageScaleAnimation();
 
   // The following methods initialize the animation. Call one of them
   // immediately after construction to set the final scroll and page scale.
 
   // Zoom while explicitly specifying the top-left scroll position.
   void ZoomTo(const gfx::Vector2dF& target_scroll_offset,
               float target_page_scale_factor,
               double duration);
@@ skipping 23 matching lines @@
   base::TimeDelta duration() const { return duration_; }
   base::TimeTicks end_time() const { return start_time_ + duration_; }
   gfx::Vector2dF target_scroll_offset() const { return target_scroll_offset_; }
   float target_page_scale_factor() const { return target_page_scale_factor_; }
 
  protected:
   PageScaleAnimation(const gfx::Vector2dF& start_scroll_offset,
                      float start_page_scale_factor,
                      const gfx::SizeF& viewport_size,
                      const gfx::SizeF& root_layer_size,
-                     scoped_ptr<TimingFunction> timing_function);
+                     std::unique_ptr<TimingFunction> timing_function);
 
  private:
   void ClampTargetScrollOffset();
   void InferTargetScrollOffsetFromStartAnchor();
   void InferTargetAnchorFromScrollOffsets();
 
   gfx::SizeF StartViewportSize() const;
   gfx::SizeF TargetViewportSize() const;
   float InterpAtTime(base::TimeTicks time) const;
   gfx::SizeF ViewportSizeAt(float interp) const;
   gfx::Vector2dF ScrollOffsetAt(float interp) const;
   gfx::Vector2dF AnchorAt(float interp) const;
   gfx::Vector2dF ViewportRelativeAnchorAt(float interp) const;
   float PageScaleFactorAt(float interp) const;
 
   float start_page_scale_factor_;
   float target_page_scale_factor_;
   gfx::Vector2dF start_scroll_offset_;
   gfx::Vector2dF target_scroll_offset_;
 
   gfx::Vector2dF start_anchor_;
   gfx::Vector2dF target_anchor_;
 
   gfx::SizeF viewport_size_;
   gfx::SizeF root_layer_size_;
 
   base::TimeTicks start_time_;
   base::TimeDelta duration_;
 
-  scoped_ptr<TimingFunction> timing_function_;
+  std::unique_ptr<TimingFunction> timing_function_;
 
   DISALLOW_COPY_AND_ASSIGN(PageScaleAnimation);
 };
 
 }  // namespace cc
 
 #endif  // CC_INPUT_PAGE_SCALE_ANIMATION_H_