Convert //remoting to use std::unique_ptr

remoting/test/test_video_renderer.cc

 // Copyright 2015 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/test_video_renderer.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_decoder_verbatim.h"
 #include "remoting/codec/video_decoder_vpx.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/test/rgb_value.h"
 #include "remoting/test/video_frame_writer.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
@@ skipping 14 matching lines @@
 // Implements video decoding functionality.
 class TestVideoRenderer::Core {
  public:
   Core();
   ~Core();
 
   // Initializes the internal structures of the class.
   void Initialize();
 
   // Used to decode video packets.
-  void ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
+  void ProcessVideoPacket(std::unique_ptr<VideoPacket> packet,
                           const base::Closure& done);
 
   // Initialize a decoder to decode video packets.
   void SetCodecForDecoding(const protocol::ChannelConfig::Codec codec);
 
   // Returns a copy of the current frame.
-  scoped_ptr<webrtc::DesktopFrame> GetCurrentFrameForTest() const;
+  std::unique_ptr<webrtc::DesktopFrame> GetCurrentFrameForTest() const;
 
   // Set expected image pattern for comparison and the callback will be called
   // when the pattern is matched.
   void ExpectAverageColorInRect(
       const webrtc::DesktopRect& expected_rect,
       const RGBValue& expected_avg_color,
       const base::Closure& image_pattern_matched_callback);
 
   // Turn on/off saving video frames to disk.
   void save_frame_data_to_disk(bool save_frame_data_to_disk) {
     save_frame_data_to_disk_ = save_frame_data_to_disk;
   }
 
  private:
   // Returns average color of pixels fall within |rect| on the current frame.
   RGBValue CalculateAverageColorValue(const webrtc::DesktopRect& rect) const;
 
   // Compares |candidate_avg_value| to |expected_avg_color_|.
   // Returns true if the root mean square of the errors in the R, G and B
   // components does not exceed a given limit.
   bool ExpectedAverageColorIsMatched(const RGBValue& candidate_avg_value) const;
 
   // Used to ensure Core methods are called on the same thread.
   base::ThreadChecker thread_checker_;
 
   // Used to decode video packets.
-  scoped_ptr<VideoDecoder> decoder_;
+  std::unique_ptr<VideoDecoder> decoder_;
 
   // Used to post tasks back to main thread.
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 
   // Protects access to |frame_|.
   mutable base::Lock lock_;
 
   // Used to store decoded video frame.
-  scoped_ptr<webrtc::SharedDesktopFrame> frame_;
+  std::unique_ptr<webrtc::SharedDesktopFrame> frame_;
 
   // Used to store the expected image pattern.
   webrtc::DesktopRect expected_rect_;
   RGBValue expected_avg_color_;
 
   // Used to store the callback when expected pattern is matched.
   base::Closure image_pattern_matched_callback_;
 
   // Used to identify whether saving frame frame data to disk.
   bool save_frame_data_to_disk_;
@@ skipping 41 matching lines @@
       VLOG(1) << "Test Video Renderer will use VERBATIM decoder";
       decoder_.reset(new VideoDecoderVerbatim());
       break;
     }
     default: {
       NOTREACHED() << "Unsupported codec: " << codec;
     }
   }
 }
 
-scoped_ptr<webrtc::DesktopFrame>
+std::unique_ptr<webrtc::DesktopFrame>
 TestVideoRenderer::Core::GetCurrentFrameForTest() const {
   base::AutoLock auto_lock(lock_);
   DCHECK(frame_);
-  return make_scoped_ptr(webrtc::BasicDesktopFrame::CopyOf(*frame_));
+  return base::WrapUnique(webrtc::BasicDesktopFrame::CopyOf(*frame_));
 }
 
-void TestVideoRenderer::Core::ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
-                                                 const base::Closure& done) {
+void TestVideoRenderer::Core::ProcessVideoPacket(
+    std::unique_ptr<VideoPacket> packet,
+    const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(decoder_);
   DCHECK(packet);
 
   VLOG(2) << "TestVideoRenderer::Core::ProcessVideoPacket() Called";
 
   // Screen size is attached on the first packet as well as when the
   // host screen is resized.
   if (packet->format().has_screen_width() &&
       packet->format().has_screen_height()) {
     webrtc::DesktopSize source_size(packet->format().screen_width(),
                                     packet->format().screen_height());
     if (!frame_ || !frame_->size().equals(source_size)) {
       base::AutoLock auto_lock(lock_);
       frame_.reset(webrtc::SharedDesktopFrame::Wrap(
           new webrtc::BasicDesktopFrame(source_size)));
     }
   }
 
   // Render the result into a new DesktopFrame instance that shares buffer with
   // |frame_|. updated_region() will be updated for |new_frame|, but not for
   // |frame_|.
-  scoped_ptr<webrtc::DesktopFrame> new_frame(frame_->Share());
+  std::unique_ptr<webrtc::DesktopFrame> new_frame(frame_->Share());
 
   {
     base::AutoLock auto_lock(lock_);
     if (!decoder_->DecodePacket(*packet, new_frame.get())) {
       LOG(ERROR) << "Decoder::DecodePacket() failed.";
       return;
     }
   }
 
   main_task_runner_->PostTask(FROM_HERE, done);
 
   if (save_frame_data_to_disk_) {
-    scoped_ptr<webrtc::DesktopFrame> frame(
+    std::unique_ptr<webrtc::DesktopFrame> frame(
         webrtc::BasicDesktopFrame::CopyOf(*frame_));
     video_frame_writer.HighlightRectInFrame(frame.get(), expected_rect_);
     video_frame_writer.WriteFrameToDefaultPath(*frame);
   }
 
   // Check to see if a image pattern matched reply is passed in, and whether
   // the |expected_rect_| falls within the current frame.
   if (image_pattern_matched_callback_.is_null() ||
       expected_rect_.right() > frame_->size().width() ||
       expected_rect_.bottom() > frame_->size().height()) {
@@ skipping 99 matching lines @@
   VLOG(2) << "TestVideoRenderer::GetVideoStub() Called";
   return this;
 }
 
 protocol::FrameConsumer* TestVideoRenderer::GetFrameConsumer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTREACHED();
   return nullptr;
 }
 
-void TestVideoRenderer::ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
-                                           const base::Closure& done) {
+void TestVideoRenderer::ProcessVideoPacket(
+    std::unique_ptr<VideoPacket> video_packet,
+    const base::Closure& done) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(video_decode_task_runner_) << "Failed to start video decode thread";
 
   if (video_packet->has_data() && video_packet->data().size() != 0) {
     VLOG(2) << "process video packet is called!";
 
     // Post video process task to the video decode thread.
     base::Closure process_video_task = base::Bind(
         &TestVideoRenderer::Core::ProcessVideoPacket,
         base::Unretained(core_.get()), base::Passed(&video_packet), done);
@@ skipping 10 matching lines @@
     const protocol::ChannelConfig::Codec codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   VLOG(2) << "TestVideoRenderer::SetDecoder() Called";
   video_decode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Core::SetCodecForDecoding,
                             base::Unretained(core_.get()),
                             codec));
 }
 
-scoped_ptr<webrtc::DesktopFrame> TestVideoRenderer::GetCurrentFrameForTest()
-    const {
+std::unique_ptr<webrtc::DesktopFrame>
+TestVideoRenderer::GetCurrentFrameForTest() const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   return core_->GetCurrentFrameForTest();
 }
 
 void TestVideoRenderer::ExpectAverageColorInRect(
     const webrtc::DesktopRect& expected_rect,
     const RGBValue& expected_avg_color,
     const base::Closure& image_pattern_matched_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 11 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   video_decode_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Core::save_frame_data_to_disk, base::Unretained(core_.get()),
                  save_frame_data_to_disk));
 }
 
 }  // namespace test
 }  // namespace remoting