Convert Pass()→std::move() in //media

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 <stdint.h>
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 18 matching lines @@
 
 namespace media {
 namespace cast {
 
 class VideoEncoderTest
     : public ::testing::TestWithParam<std::pair<Codec, bool>> {
  protected:
   VideoEncoderTest()
       : testing_clock_(new base::SimpleTestTickClock()),
         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
-        cast_environment_(new CastEnvironment(
-            scoped_ptr<base::TickClock>(testing_clock_).Pass(),
-            task_runner_,
-            task_runner_,
-            task_runner_)),
+        cast_environment_(
+            new CastEnvironment(scoped_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 {
     video_config_.codec = GetParam().first;
     video_config_.use_external_encoder = GetParam().second;
 
     if (video_config_.use_external_encoder)
       vea_factory_.reset(new FakeVideoEncodeAcceleratorFactory(task_runner_));
   }
 
   void TearDown() final {
     video_encoder_.reset();
     RunTasksAndAdvanceClock();
   }
 
   void CreateEncoder() {
     ASSERT_EQ(STATUS_UNINITIALIZED, operational_status_);
     video_config_.max_number_of_video_buffers_used = 1;
     video_encoder_ = VideoEncoder::Create(
-        cast_environment_,
-        video_config_,
+        cast_environment_, video_config_,
         base::Bind(&VideoEncoderTest::OnOperationalStatusChange,
                    base::Unretained(this)),
         base::Bind(
             &FakeVideoEncodeAcceleratorFactory::CreateVideoEncodeAccelerator,
             base::Unretained(vea_factory_.get())),
         base::Bind(&FakeVideoEncodeAcceleratorFactory::CreateSharedMemory,
-                   base::Unretained(vea_factory_.get()))).Pass();
+                   base::Unretained(vea_factory_.get())));
     RunTasksAndAdvanceClock();
     if (is_encoder_present())
       ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
   }
 
   bool is_encoder_present() const {
     return !!video_encoder_;
   }
 
   bool is_testing_software_vp8_encoder() const {
@@ skipping 116 matching lines @@
     DVLOG(1) << "OnOperationalStatusChange: from " << operational_status_
              << " to " << status;
     operational_status_ = status;
 
     EXPECT_TRUE(operational_status_ == STATUS_CODEC_REINIT_PENDING ||
                 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().Pass();
+      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,
                                 uint32_t expected_rtp_timestamp,
                                 const base::TimeTicks& expected_reference_time,
                                 scoped_ptr<SenderEncodedFrame> encoded_frame) {
     EXPECT_TRUE(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
@@ skipping 196 matching lines @@
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media