Global conversion of Pass()→std::move(): CrOS edition

content/common/gpu/media/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
-
 #include <algorithm>
 #include <queue>
 #include <string>
+#include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 281 matching lines @@
         src += visible_bpl[i];
         dest_offset += coded_bpl[i];
       }
       if (!padding[i].empty()) {
         LOG_ASSERT(WriteFile(&dest_file, dest_offset, &padding[i][0],
                              padding[i].size()));
         dest_offset += padding[i].size();
       }
     }
   }
-  LOG_ASSERT(test_stream->mapped_aligned_in_file.Initialize(dest_file.Pass()));
+  LOG_ASSERT(
+      test_stream->mapped_aligned_in_file.Initialize(std::move(dest_file)));
   // Assert that memory mapped of file starts at 64 byte boundary. So each
   // plane of frames also start at 64 byte boundary.
 
   ASSERT_EQ(
       reinterpret_cast<off_t>(test_stream->mapped_aligned_in_file.data()) & 63,
       0)
       << "File should be mapped at a 64 byte boundary";
 
   LOG_ASSERT(test_stream->mapped_aligned_in_file.length() %
                test_stream->aligned_buffer_size == 0U)
@@ skipping 67 matching lines @@
 // - clean up temporary aligned files.
 // - output log to file.
 class VideoEncodeAcceleratorTestEnvironment : public ::testing::Environment {
  public:
   VideoEncodeAcceleratorTestEnvironment(
       scoped_ptr<base::FilePath::StringType> data,
       const base::FilePath& log_path,
       bool run_at_fps,
       bool needs_encode_latency,
       bool verify_all_output)
-      : test_stream_data_(data.Pass()),
+      : test_stream_data_(std::move(data)),
         log_path_(log_path),
         run_at_fps_(run_at_fps),
         needs_encode_latency_(needs_encode_latency),
         verify_all_output_(verify_all_output) {}
 
   virtual void SetUp() {
     if (!log_path_.empty()) {
       log_file_.reset(new base::File(
           log_path_, base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE));
       LOG_ASSERT(log_file_->IsValid());
@@ skipping 186 matching lines @@
   scoped_ptr<StreamValidator> validator;
 
   if (IsH264(profile)) {
     validator.reset(new H264Validator(frame_cb));
   } else if (IsVP8(profile)) {
     validator.reset(new VP8Validator(frame_cb));
   } else {
     LOG(FATAL) << "Unsupported profile: " << profile;
   }
 
-  return validator.Pass();
+  return validator;
 }
 
 class VideoFrameQualityValidator {
  public:
   VideoFrameQualityValidator(const media::VideoCodecProfile profile,
                              const base::Closure& flush_complete_cb,
                              const base::Closure& decode_error_cb);
   void Initialize(const gfx::Size& coded_size, const gfx::Rect& visible_size);
   // Save original YUV frame to compare it with the decoded frame later.
   void AddOriginalFrame(scoped_refptr<media::VideoFrame> frame);
@@ skipping 422 matching lines @@
 
 VEAClient::~VEAClient() { LOG_ASSERT(!has_encoder()); }
 
 scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateFakeVEA() {
   scoped_ptr<media::VideoEncodeAccelerator> encoder;
   if (g_fake_encoder) {
     encoder.reset(new media::FakeVideoEncodeAccelerator(
         scoped_refptr<base::SingleThreadTaskRunner>(
             base::ThreadTaskRunnerHandle::Get())));
   }
-  return encoder.Pass();
+  return encoder;
 }
 
 scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateV4L2VEA() {
   scoped_ptr<media::VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && (defined(ARCH_CPU_ARMEL) || \
     (defined(USE_OZONE) && defined(USE_V4L2_CODEC)))
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kEncoder);
   if (device)
     encoder.reset(new V4L2VideoEncodeAccelerator(device));
 #endif
-  return encoder.Pass();
+  return encoder;
 }
 
 scoped_ptr<media::VideoEncodeAccelerator> VEAClient::CreateVaapiVEA() {
   scoped_ptr<media::VideoEncodeAccelerator> encoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   encoder.reset(new VaapiVideoEncodeAccelerator());
 #endif
-  return encoder.Pass();
+  return encoder;
 }
 
 void VEAClient::CreateEncoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   LOG_ASSERT(!has_encoder());
 
   scoped_ptr<media::VideoEncodeAccelerator> encoders[] = {
     CreateFakeVEA(),
     CreateV4L2VEA(),
     CreateVaapiVEA()
   };
 
   DVLOG(1) << "Profile: " << test_stream_->requested_profile
            << ", initial bitrate: " << requested_bitrate_;
 
   for (size_t i = 0; i < arraysize(encoders); ++i) {
     if (!encoders[i])
       continue;
-    encoder_ = encoders[i].Pass();
+    encoder_ = std::move(encoders[i]);
     SetState(CS_ENCODER_SET);
     if (encoder_->Initialize(kInputFormat,
                              test_stream_->visible_size,
                              test_stream_->requested_profile,
                              requested_bitrate_,
                              this)) {
       SetStreamParameters(requested_bitrate_, requested_framerate_);
       SetState(CS_INITIALIZED);
 
       if (verify_output_ && !g_fake_encoder)
@@ skipping 672 matching lines @@
   }
 
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoEncodeAcceleratorTestEnvironment(
-                  test_stream_data.Pass(), log_path, run_at_fps,
+                  std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }