Convert //remoting to use std::unique_ptr

remoting/codec/codec_test.cc

 // Copyright (c) 2012 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/codec/codec_test.h"
+
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 
 #include <deque>
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
 #include "remoting/base/util.h"
-#include "remoting/codec/codec_test.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/proto/video.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using webrtc::BasicDesktopFrame;
 using webrtc::DesktopFrame;
 using webrtc::DesktopRect;
 using webrtc::DesktopRegion;
@@ skipping 40 matching lines @@
   void Reset() {
     frame_.reset(new BasicDesktopFrame(frame_->size()));
     expected_region_.Clear();
   }
 
   void ResetRenderedData() {
     memset(frame_->data(), 0,
            frame_->size().width() * frame_->size().height() * kBytesPerPixel);
   }
 
-  void ReceivedPacket(scoped_ptr<VideoPacket> packet) {
+  void ReceivedPacket(std::unique_ptr<VideoPacket> packet) {
     ASSERT_TRUE(decoder_->DecodePacket(*packet, frame_.get()));
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void set_expected_frame(DesktopFrame* frame) {
     expected_frame_ = frame;
   }
@@ skipping 69 matching lines @@
     }
     original++;
     decoded++;
     return sqrt(error_sum_squares / 3.0);
   }
 
  private:
   bool strict_;
   DesktopRegion expected_region_;
   VideoDecoder* decoder_;
-  scoped_ptr<DesktopFrame> frame_;
+  std::unique_ptr<DesktopFrame> frame_;
   DesktopFrame* expected_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester);
 };
 
 // The VideoEncoderTester provides a hook for retrieving the data, and passing
 // the message to other subprograms for validaton.
 class VideoEncoderTester {
  public:
   VideoEncoderTester() : decoder_tester_(nullptr), data_available_(0) {}
 
   ~VideoEncoderTester() {
     EXPECT_GT(data_available_, 0);
   }
 
-  void DataAvailable(scoped_ptr<VideoPacket> packet) {
+  void DataAvailable(std::unique_ptr<VideoPacket> packet) {
     ++data_available_;
     // Send the message to the VideoDecoderTester.
     if (decoder_tester_) {
       decoder_tester_->ReceivedPacket(std::move(packet));
     }
   }
 
   void set_decoder_tester(VideoDecoderTester* decoder_tester) {
     decoder_tester_ = decoder_tester;
   }
 
  private:
   VideoDecoderTester* decoder_tester_;
   int data_available_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester);
 };
 
-scoped_ptr<DesktopFrame> PrepareFrame(const DesktopSize& size) {
-  scoped_ptr<DesktopFrame> frame(new BasicDesktopFrame(size));
+std::unique_ptr<DesktopFrame> PrepareFrame(const DesktopSize& size) {
+  std::unique_ptr<DesktopFrame> frame(new BasicDesktopFrame(size));
 
   srand(0);
   int memory_size = size.width() * size.height() * kBytesPerPixel;
   for (int i = 0; i < memory_size; ++i) {
     frame->data()[i] = rand() % 256;
   }
 
   return frame;
 }
 
 static void TestEncodingRects(VideoEncoder* encoder,
                               VideoEncoderTester* tester,
                               DesktopFrame* frame,
                               const DesktopRegion& region) {
   *frame->mutable_updated_region() = region;
   tester->DataAvailable(encoder->Encode(*frame));
 }
 
 void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
   const int kSizes[] = {80, 79, 77, 54};
 
   VideoEncoderTester tester;
 
   for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
     for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
       DesktopSize size(kSizes[xi], kSizes[yi]);
-      scoped_ptr<DesktopFrame> frame = PrepareFrame(size);
+      std::unique_ptr<DesktopFrame> frame = PrepareFrame(size);
       for (const DesktopRegion& region : MakeTestRegionLists(size)) {
         TestEncodingRects(encoder, &tester, frame.get(), region);
       }
 
       // Pass some empty frames through the encoder.
       for (int i = 0; i < 5; ++i) {
         TestEncodingRects(encoder, &tester, frame.get(), DesktopRegion());
       }
     }
   }
 }
 
 void TestVideoEncoderEmptyFrames(VideoEncoder* encoder,
                                  int max_topoff_frames) {
   const DesktopSize kSize(100, 100);
-  scoped_ptr<DesktopFrame> frame(PrepareFrame(kSize));
+  std::unique_ptr<DesktopFrame> frame(PrepareFrame(kSize));
 
   frame->mutable_updated_region()->SetRect(
       webrtc::DesktopRect::MakeSize(kSize));
   EXPECT_TRUE(encoder->Encode(*frame));
 
   int topoff_frames = 0;
   frame->mutable_updated_region()->Clear();
   for (int i = 0; i < max_topoff_frames + 1; ++i) {
     if (!encoder->Encode(*frame))
       break;
@@ skipping 33 matching lines @@
   decoder_tester->Reset();
 }
 
 void TestVideoEncoderDecoder(VideoEncoder* encoder,
                              VideoDecoder* decoder,
                              bool strict) {
   DesktopSize kSize = DesktopSize(160, 120);
 
   VideoEncoderTester encoder_tester;
 
-  scoped_ptr<DesktopFrame> frame = PrepareFrame(kSize);
+  std::unique_ptr<DesktopFrame> frame = PrepareFrame(kSize);
 
   VideoDecoderTester decoder_tester(decoder, kSize);
   decoder_tester.set_strict(strict);
   decoder_tester.set_expected_frame(frame.get());
   encoder_tester.set_decoder_tester(&decoder_tester);
 
   for (const DesktopRegion& region : MakeTestRegionLists(kSize)) {
     TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester,
                           frame.get(), region);
   }
@@ skipping 10 matching lines @@
       *p++ = 0;
     }
   }
 }
 
 void TestVideoEncoderDecoderGradient(VideoEncoder* encoder,
                                      VideoDecoder* decoder,
                                      const DesktopSize& screen_size,
                                      double max_error_limit,
                                      double mean_error_limit) {
-  scoped_ptr<BasicDesktopFrame> frame(
-      new BasicDesktopFrame(screen_size));
+  std::unique_ptr<BasicDesktopFrame> frame(new BasicDesktopFrame(screen_size));
   FillWithGradient(frame.get());
   frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(screen_size));
 
   VideoDecoderTester decoder_tester(decoder, screen_size);
   decoder_tester.set_expected_frame(frame.get());
   decoder_tester.AddRegion(frame->updated_region());
   decoder_tester.ReceivedPacket(encoder->Encode(*frame));
 
   decoder_tester.VerifyResultsApprox(max_error_limit, mean_error_limit);
 }
 
 }  // namespace remoting