Convert //remoting to use std::unique_ptr

remoting/test/cyclic_frame_generator.cc

 // 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.
 
 #include "remoting/test/cyclic_frame_generator.h"
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/time/default_tick_clock.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace remoting {
 namespace test {
 
 namespace {
 
 const int kBarcodeCellWidth = 8;
 const int kBarcodeCellHeight = 8;
 const int kBarcodeBits = 10;
 const int kBarcodeBlackThreshold = 85;
 const int kBarcodeWhiteThreshold = 170;
 
-scoped_ptr<webrtc::DesktopFrame> LoadDesktopFrameFromPng(
+std::unique_ptr<webrtc::DesktopFrame> LoadDesktopFrameFromPng(
     const base::FilePath& file_path) {
   std::string file_content;
   if (!base::ReadFileToString(file_path, &file_content))
     LOG(FATAL) << "Failed to read " << file_path.MaybeAsASCII()
                << ". Please run remoting/test/data/download.sh";
   SkBitmap bitmap;
   gfx::PNGCodec::Decode(reinterpret_cast<const uint8_t*>(file_content.data()),
                         file_content.size(), &bitmap);
-  scoped_ptr<webrtc::DesktopFrame> frame(new webrtc::BasicDesktopFrame(
+  std::unique_ptr<webrtc::DesktopFrame> frame(new webrtc::BasicDesktopFrame(
       webrtc::DesktopSize(bitmap.width(), bitmap.height())));
   bitmap.copyPixelsTo(frame->data(),
                       frame->stride() * frame->size().height(),
                       frame->stride());
   return frame;
 }
 
 void DrawRect(webrtc::DesktopFrame* frame,
               webrtc::DesktopRect rect,
               uint32_t color) {
@@ skipping 16 matching lines @@
     : frame_id(frame_id), type(type), timestamp(timestamp) {}
 
 // static
 scoped_refptr<CyclicFrameGenerator> CyclicFrameGenerator::Create() {
   base::FilePath test_data_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &test_data_path);
   test_data_path = test_data_path.Append(FILE_PATH_LITERAL("remoting"));
   test_data_path = test_data_path.Append(FILE_PATH_LITERAL("test"));
   test_data_path = test_data_path.Append(FILE_PATH_LITERAL("data"));
 
-  std::vector<scoped_ptr<webrtc::DesktopFrame>> frames;
+  std::vector<std::unique_ptr<webrtc::DesktopFrame>> frames;
   frames.push_back(
       LoadDesktopFrameFromPng(test_data_path.AppendASCII("test_frame1.png")));
   frames.push_back(
       LoadDesktopFrameFromPng(test_data_path.AppendASCII("test_frame2.png")));
   return new CyclicFrameGenerator(std::move(frames));
 }
 
 CyclicFrameGenerator::CyclicFrameGenerator(
-    std::vector<scoped_ptr<webrtc::DesktopFrame>> reference_frames)
+    std::vector<std::unique_ptr<webrtc::DesktopFrame>> reference_frames)
     : reference_frames_(std::move(reference_frames)),
       clock_(&default_tick_clock_),
       started_time_(clock_->NowTicks()) {
   CHECK(!reference_frames_.empty());
   screen_size_ = reference_frames_[0]->size();
   for (const auto& frame : reference_frames_) {
     CHECK(screen_size_.equals(frame->size()))
         << "All reference frames should have the same size.";
   }
 }
 
 CyclicFrameGenerator::~CyclicFrameGenerator() {}
 
 void CyclicFrameGenerator::SetTickClock(base::TickClock* tick_clock) {
   clock_ = tick_clock;
   started_time_ = clock_->NowTicks();
 }
 
-scoped_ptr<webrtc::DesktopFrame> CyclicFrameGenerator::GenerateFrame(
+std::unique_ptr<webrtc::DesktopFrame> CyclicFrameGenerator::GenerateFrame(
     webrtc::SharedMemoryFactory* shared_memory_factory) {
   base::TimeTicks now = clock_->NowTicks();
   int reference_frame =
       ((now - started_time_) / frame_cycle_period_) % reference_frames_.size();
   bool cursor_state = ((now - started_time_) / cursor_blink_period_) % 2;
 
-  scoped_ptr<webrtc::DesktopFrame> frame(
+  std::unique_ptr<webrtc::DesktopFrame> frame(
       new webrtc::BasicDesktopFrame(screen_size_));
   frame->CopyPixelsFrom(*reference_frames_[reference_frame],
                         webrtc::DesktopVector(),
                         webrtc::DesktopRect::MakeSize(screen_size_));
 
   // Render the cursor.
   webrtc::DesktopRect cursor_rect =
       webrtc::DesktopRect::MakeXYWH(20, 20, 2, 20);
   if (cursor_state) {
     DrawRect(frame.get(), cursor_rect, 0);
@@ skipping 77 matching lines @@
   }
 
   if (!generated_frames_info_.count(frame_id))
     LOG(FATAL) << "Barcode contains unknown frame_id: " << frame_id;
 
   return generated_frames_info_[frame_id];
 }
 
 }  // namespace test
 }  // namespace remoting