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

media/cast/sender/video_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 "media/cast/sender/video_encoder.h"
+
 #include <stdint.h>
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/common/rtp_time.h"
 #include "media/cast/sender/fake_video_encode_accelerator_factory.h"
-#include "media/cast/sender/video_encoder.h"
 #include "media/cast/sender/video_frame_factory.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #include "media/cast/sender/h264_vt_encoder.h"
 #endif
 
 namespace media {
 namespace cast {
 
 class VideoEncoderTest
     : public ::testing::TestWithParam<std::pair<Codec, bool>> {
  protected:
   VideoEncoderTest()
       : testing_clock_(new base::SimpleTestTickClock()),
         task_runner_(new FakeSingleThreadTaskRunner(testing_clock_)),
-        cast_environment_(
-            new CastEnvironment(scoped_ptr<base::TickClock>(testing_clock_),
-                                task_runner_,
-                                task_runner_,
-                                task_runner_)),
+        cast_environment_(new CastEnvironment(
+            std::unique_ptr<base::TickClock>(testing_clock_),
+            task_runner_,
+            task_runner_,
+            task_runner_)),
         video_config_(GetDefaultVideoSenderConfig()),
         operational_status_(STATUS_UNINITIALIZED),
         count_frames_delivered_(0) {
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
     first_frame_time_ = testing_clock_->NowTicks();
   }
 
   ~VideoEncoderTest() override {}
 
   void SetUp() final {
@@ skipping 152 matching lines @@
                 operational_status_ == STATUS_INITIALIZED);
 
     // Create the VideoFrameFactory the first time status changes to
     // STATUS_INITIALIZED.
     if (operational_status_ == STATUS_INITIALIZED && !video_frame_factory_)
       video_frame_factory_ = video_encoder_->CreateVideoFrameFactory();
   }
 
   // Checks that |encoded_frame| matches expected values.  This is the method
   // bound in the callback returned from EncodeAndCheckDelivery().
-  void DeliverEncodedVideoFrame(uint32_t expected_frame_id,
-                                uint32_t expected_last_referenced_frame_id,
-                                RtpTimeTicks expected_rtp_timestamp,
-                                const base::TimeTicks& expected_reference_time,
-                                scoped_ptr<SenderEncodedFrame> encoded_frame) {
+  void DeliverEncodedVideoFrame(
+      uint32_t expected_frame_id,
+      uint32_t expected_last_referenced_frame_id,
+      RtpTimeTicks expected_rtp_timestamp,
+      const base::TimeTicks& expected_reference_time,
+      std::unique_ptr<SenderEncodedFrame> encoded_frame) {
     EXPECT_TRUE(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
     EXPECT_EQ(expected_frame_id, encoded_frame->frame_id);
     EXPECT_EQ(expected_rtp_timestamp, encoded_frame->rtp_timestamp);
     EXPECT_EQ(expected_reference_time, encoded_frame->reference_time);
 
     // The platform encoders are "black boxes" and may choose to vend key frames
     // and/or empty data at any time.  The software encoders, however, should
     // strictly adhere to expected behavior.
     if (is_testing_platform_encoder()) {
@@ skipping 26 matching lines @@
       EXPECT_LE(0.0, encoded_frame->lossy_utilization);
     }
 
     ++count_frames_delivered_;
   }
 
   base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
   const scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
   const scoped_refptr<CastEnvironment> cast_environment_;
   VideoSenderConfig video_config_;
-  scoped_ptr<FakeVideoEncodeAcceleratorFactory> vea_factory_;
+  std::unique_ptr<FakeVideoEncodeAcceleratorFactory> vea_factory_;
   base::TimeTicks first_frame_time_;
   OperationalStatus operational_status_;
-  scoped_ptr<VideoEncoder> video_encoder_;
-  scoped_ptr<VideoFrameFactory> video_frame_factory_;
+  std::unique_ptr<VideoEncoder> video_encoder_;
+  std::unique_ptr<VideoFrameFactory> video_frame_factory_;
 
   int count_frames_delivered_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderTest);
 };
 
 // A simple test to encode three frames of video, expecting to see one key frame
 // followed by two delta frames.
 TEST_P(VideoEncoderTest, GeneratesKeyFrameThenOnlyDeltaFrames) {
   CreateEncoder();
@@ skipping 136 matching lines @@
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media