Convert //remoting to use std::unique_ptr

remoting/test/cyclic_frame_generator.h

 // Copyright 2016 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 REMOTING_TEST_CYCLIC_FRAME_GENERATOR_H_
 #define REMOTING_TEST_CYCLIC_FRAME_GENERATOR_H_
 
 #include <map>
+#include <memory>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/time/default_tick_clock.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capturer.h"
 
 namespace remoting {
 namespace test {
 
 // CyclicFrameGenerator generates a sequence of frames that approximates
 // properties of a real video stream when using a desktop applications. It
 // loads a sequence of reference frames and switches between them with the
 // specified frequency (every 2 seconds by default). Between reference frames it
@@ skipping 17 matching lines @@
     FrameInfo(int frame_id, FrameType type, base::TimeTicks timestamp);
 
     int frame_id = 0;
     FrameType type = FrameType::EMPTY;
     base::TimeTicks timestamp;
   };
 
   static scoped_refptr<CyclicFrameGenerator> Create();
 
   CyclicFrameGenerator(
-      std::vector<scoped_ptr<webrtc::DesktopFrame>> reference_frames);
+      std::vector<std::unique_ptr<webrtc::DesktopFrame>> reference_frames);
 
   void set_frame_cycle_period(base::TimeDelta frame_cycle_period) {
     frame_cycle_period_ = frame_cycle_period;
   }
 
   void set_cursor_blink_period(base::TimeDelta cursor_blink_period) {
     cursor_blink_period_ = cursor_blink_period;
   }
 
   void SetTickClock(base::TickClock* tick_clock);
 
   // When |draw_barcode| is set to true a barcode is drawn on each generated
   // frame. This make it possible to call IdentifyFrame() to identify the frame
   // by its content.
   void set_draw_barcode(bool draw_barcode) { draw_barcode_ = draw_barcode; }
 
-  scoped_ptr<webrtc::DesktopFrame> GenerateFrame(
+  std::unique_ptr<webrtc::DesktopFrame> GenerateFrame(
       webrtc::SharedMemoryFactory* shared_memory_factory);
 
   FrameType last_frame_type() { return last_frame_type_; }
 
   // Identifies |frame| by its content and returns FrameInfo corresponding to
   // the frame.
   FrameInfo IdentifyFrame(webrtc::DesktopFrame* frame);
 
  private:
   ~CyclicFrameGenerator();
   friend class base::RefCountedThreadSafe<CyclicFrameGenerator>;
 
-  std::vector<scoped_ptr<webrtc::DesktopFrame>> reference_frames_;
+  std::vector<std::unique_ptr<webrtc::DesktopFrame>> reference_frames_;
   base::DefaultTickClock default_tick_clock_;
   base::TickClock* clock_;
   webrtc::DesktopSize screen_size_;
 
   // By default switch between reference frames every 2 seconds.
   base::TimeDelta frame_cycle_period_ = base::TimeDelta::FromSeconds(2);
 
   // By default blink the cursor 4 times per seconds.
   base::TimeDelta cursor_blink_period_ = base::TimeDelta::FromMilliseconds(250);
 
@@ skipping 14 matching lines @@
 
   std::map<int, FrameInfo> generated_frames_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CyclicFrameGenerator);
 };
 
 }  // namespace test
 }  // namespace remoting
 
 #endif  // REMOTING_TEST_CYCLIC_FRAME_GENERATOR_H_