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

media/cast/sender/h264_vt_encoder_unittest.cc

 // 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.
 
 #include <stdint.h>
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 79 matching lines @@
   void PushExpectation(uint32_t expected_frame_id,
                        uint32_t expected_last_referenced_frame_id,
                        RtpTimeTicks expected_rtp_timestamp,
                        const base::TimeTicks& expected_reference_time) {
     expectations_.push(Expectation{expected_frame_id,
                                    expected_last_referenced_frame_id,
                                    expected_rtp_timestamp,
                                    expected_reference_time});
   }
 
-  void CompareFrameWithExpected(scoped_ptr<SenderEncodedFrame> encoded_frame) {
+  void CompareFrameWithExpected(
+      std::unique_ptr<SenderEncodedFrame> encoded_frame) {
     ASSERT_LT(0u, expectations_.size());
     auto e = expectations_.front();
     expectations_.pop();
     if (e.expected_frame_id != e.expected_last_referenced_frame_id) {
       EXPECT_EQ(EncodedFrame::DEPENDENT, encoded_frame->dependency);
     } else {
       EXPECT_EQ(EncodedFrame::KEY, encoded_frame->dependency);
     }
     EXPECT_EQ(e.expected_frame_id, encoded_frame->frame_id);
     EXPECT_EQ(e.expected_last_referenced_frame_id,
@@ skipping 34 matching lines @@
         base::Bind(&EndToEndFrameChecker::CompareFrameWithExpected,
                    base::Unretained(this)));
     base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(decoder_init_result);
   }
 
   void PushExpectation(const scoped_refptr<VideoFrame>& frame) {
     expectations_.push(frame);
   }
 
-  void EncodeDone(scoped_ptr<SenderEncodedFrame> encoded_frame) {
+  void EncodeDone(std::unique_ptr<SenderEncodedFrame> encoded_frame) {
     auto buffer = DecoderBuffer::CopyFrom(encoded_frame->bytes(),
                                           encoded_frame->data.size());
     decoder_.Decode(buffer, base::Bind(&EndToEndFrameChecker::DecodeDone,
                                        base::Unretained(this)));
   }
 
   void CompareFrameWithExpected(const scoped_refptr<VideoFrame>& frame) {
     ASSERT_LT(0u, expectations_.size());
     auto& e = expectations_.front();
     expectations_.pop();
@@ skipping 25 matching lines @@
   ASSERT_TRUE(cv_pixel_buffer);
   CVPixelBufferLockBaseAddress(cv_pixel_buffer, 0);
   auto ptr = CVPixelBufferGetBaseAddressOfPlane(cv_pixel_buffer, 0);
   ASSERT_TRUE(ptr);
   memset(ptr, 0xfe, CVPixelBufferGetBytesPerRowOfPlane(cv_pixel_buffer, 0) *
                         CVPixelBufferGetHeightOfPlane(cv_pixel_buffer, 0));
   CVPixelBufferUnlockBaseAddress(cv_pixel_buffer, 0);
 }
 
 void NoopFrameEncodedCallback(
-    scoped_ptr<media::cast::SenderEncodedFrame> /*encoded_frame*/) {
-}
+    std::unique_ptr<media::cast::SenderEncodedFrame> /*encoded_frame*/) {}
 
 class TestPowerSource : public base::PowerMonitorSource {
  public:
   void GenerateSuspendEvent() {
     ProcessPowerEvent(SUSPEND_EVENT);
     base::MessageLoop::current()->RunUntilIdle();
   }
   void GenerateResumeEvent() {
     ProcessPowerEvent(RESUME_EVENT);
     base::MessageLoop::current()->RunUntilIdle();
   }
 
  private:
   bool IsOnBatteryPowerImpl() final { return false; }
 };
 
 class H264VideoToolboxEncoderTest : public ::testing::Test {
  protected:
   H264VideoToolboxEncoderTest() = default;
 
   void SetUp() final {
     clock_ = new base::SimpleTestTickClock();
     clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
 
     power_source_ = new TestPowerSource();
-    power_monitor_.reset(
-        new base::PowerMonitor(scoped_ptr<TestPowerSource>(power_source_)));
+    power_monitor_.reset(new base::PowerMonitor(
+        std::unique_ptr<TestPowerSource>(power_source_)));
 
     cast_environment_ = new CastEnvironment(
-        scoped_ptr<base::TickClock>(clock_), message_loop_.task_runner(),
+        std::unique_ptr<base::TickClock>(clock_), message_loop_.task_runner(),
         message_loop_.task_runner(), message_loop_.task_runner());
     encoder_.reset(new H264VideoToolboxEncoder(
         cast_environment_, video_sender_config_,
         base::Bind(&SaveOperationalStatus, &operational_status_)));
     message_loop_.RunUntilIdle();
     EXPECT_EQ(STATUS_INITIALIZED, operational_status_);
   }
 
   void TearDown() final {
     encoder_.reset();
@@ skipping 18 matching lines @@
   }
 
   static void TearDownTestCase() { frame_ = nullptr; }
 
   static scoped_refptr<media::VideoFrame> frame_;
   static VideoSenderConfig video_sender_config_;
 
   base::SimpleTestTickClock* clock_;  // Owned by CastEnvironment.
   base::MessageLoop message_loop_;
   scoped_refptr<CastEnvironment> cast_environment_;
-  scoped_ptr<VideoEncoder> encoder_;
+  std::unique_ptr<VideoEncoder> encoder_;
   OperationalStatus operational_status_;
   TestPowerSource* power_source_;  // Owned by the power monitor.
-  scoped_ptr<base::PowerMonitor> power_monitor_;
+  std::unique_ptr<base::PowerMonitor> power_monitor_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(H264VideoToolboxEncoderTest);
 };
 
 // static
 scoped_refptr<media::VideoFrame> H264VideoToolboxEncoderTest::frame_;
 VideoSenderConfig H264VideoToolboxEncoderTest::video_sender_config_;
 
 TEST_F(H264VideoToolboxEncoderTest, CheckFrameMetadataSequence) {
@@ skipping 124 matching lines @@
       gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
 
   // After a power resume event, the factory should produce frames right away
   // because the encoder re-initializes on its own.
   power_source_->GenerateResumeEvent();
   CreateFrameAndMemsetPlane(video_frame_factory.get());
 }
 
 }  // namespace cast
 }  // namespace media