Convert //media/blink from scoped_ptr to std::unique_ptr

media/blink/video_frame_compositor.h

 // 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.
 
 #ifndef MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_
 #define MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_
 
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 93 matching lines @@
   // does not receive a |client_|.  In this case, frame acquisition is driven by
   // the frequency of canvas or WebGL paints requested via JavaScript.
   scoped_refptr<VideoFrame> GetCurrentFrameAndUpdateIfStale();
 
   // Returns the timestamp of the current (possibly stale) frame, or
   // base::TimeDelta() if there is no current frame. This method may be called
   // from the media thread as long as the VFC is stopped. (Assuming that
   // PaintFrameUsingOldRenderingPath() is not also called while stopped.)
   base::TimeDelta GetCurrentFrameTimestamp() const;
 
-  void set_tick_clock_for_testing(scoped_ptr<base::TickClock> tick_clock) {
+  void set_tick_clock_for_testing(std::unique_ptr<base::TickClock> tick_clock) {
     tick_clock_ = std::move(tick_clock);
   }
 
   void clear_current_frame_for_testing() { current_frame_ = nullptr; }
 
   // Enables or disables background rendering. If |enabled|, |timeout| is the
   // amount of time to wait after the last Render() call before starting the
   // background rendering mode.  Note, this can not disable the background
   // rendering call issues when a sink is started.
   void set_background_rendering_for_testing(bool enabled) {
@@ skipping 16 matching lines @@
   // If |callback_| is available, calls Render() with the provided properties.
   // Updates |is_background_rendering_|, |last_interval_|, and resets
   // |background_rendering_timer_|.  Ensures that natural size and opacity
   // changes are correctly fired.  Returns true if there's a new frame available
   // via GetCurrentFrame().
   bool CallRender(base::TimeTicks deadline_min,
                   base::TimeTicks deadline_max,
                   bool background_rendering);
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
-  scoped_ptr<base::TickClock> tick_clock_;
+  std::unique_ptr<base::TickClock> tick_clock_;
 
   // These callbacks are executed on the compositor thread.
   const base::Callback<void(gfx::Size)> natural_size_changed_cb_;
   const base::Callback<void(bool)> opacity_changed_cb_;
 
   // Allows tests to disable the background rendering task.
   bool background_rendering_enabled_;
 
   // Manages UpdateCurrentFrame() callbacks if |client_| has stopped sending
   // them for various reasons.  Runs on |compositor_task_runner_| and is reset
@@ skipping 16 matching lines @@
   // These values are updated and read from the media and compositor threads.
   base::Lock callback_lock_;
   VideoRendererSink::RenderCallback* callback_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCompositor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_