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

content/common/gpu/media/video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
 //   to be written sequentially and wait for the decode client to see certain
 //   state transitions.
 // - GLRenderingVDAClient is a VideoDecodeAccelerator::Client implementation
 // - Finally actual TEST cases are at the bottom of this file, using the above
 //   infrastructure.
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <algorithm>
 #include <deque>
 #include <map>
-
-// Include gtest.h out of order because <X11/X.h> #define's Bool & None, which
-// gtest uses as struct names (inside a namespace).  This means that
-// #include'ing gtest after anything that pulls in X.h fails to compile.
-// This is http://code.google.com/p/googletest/issues/detail?id=371
-#include "testing/gtest/include/gtest/gtest.h"
+#include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/md5.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringize_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "content/common/gpu/media/fake_video_decode_accelerator.h"
 #include "content/common/gpu/media/rendering_helper.h"
 #include "content/common/gpu/media/video_accelerator_unittest_helpers.h"
 #include "content/public/common/content_switches.h"
 #include "media/filters/h264_parser.h"
+#include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gl/gl_image.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "content/common/gpu/media/dxva_video_decode_accelerator_win.h"
 #elif defined(OS_CHROMEOS)
 #if defined(USE_V4L2_CODEC)
 #include "content/common/gpu/media/v4l2_device.h"
 #include "content/common/gpu/media/v4l2_slice_video_decode_accelerator.h"
@@ skipping 441 matching lines @@
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateFakeVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
   if (fake_decoder_) {
     decoder.reset(new FakeVideoDecodeAccelerator(
         static_cast<gfx::GLContext*> (rendering_helper_->GetGLContextHandle()),
         frame_size_,
         base::Bind(&DoNothingReturnTrue)));
   }
-  return decoder.Pass();
+  return decoder;
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateDXVAVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
 #if defined(OS_WIN)
   if (base::win::GetVersion() >= base::win::VERSION_WIN7)
     decoder.reset(
         new DXVAVideoDecodeAccelerator(
             base::Bind(&DoNothingReturnTrue),
             rendering_helper_->GetGLContext().get()));
 #endif
-  return decoder.Pass();
+  return decoder;
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateV4L2VDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     base::WeakPtr<VideoDecodeAccelerator::Client> weak_client = AsWeakPtr();
     decoder.reset(new V4L2VideoDecodeAccelerator(
         static_cast<EGLDisplay>(rendering_helper_->GetGLDisplay()),
         static_cast<EGLContext>(rendering_helper_->GetGLContextHandle()),
         weak_client, base::Bind(&DoNothingReturnTrue), device,
         base::ThreadTaskRunnerHandle::Get()));
   }
 #endif
-  return decoder.Pass();
+  return decoder;
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateV4L2SliceVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (device.get()) {
     base::WeakPtr<VideoDecodeAccelerator::Client> weak_client = AsWeakPtr();
     decoder.reset(new V4L2SliceVideoDecodeAccelerator(
         device, static_cast<EGLDisplay>(rendering_helper_->GetGLDisplay()),
         static_cast<EGLContext>(rendering_helper_->GetGLContextHandle()),
         weak_client, base::Bind(&DoNothingReturnTrue),
         base::ThreadTaskRunnerHandle::Get()));
   }
 #endif
-  return decoder.Pass();
+  return decoder;
 }
 
 scoped_ptr<media::VideoDecodeAccelerator>
 GLRenderingVDAClient::CreateVaapiVDA() {
   scoped_ptr<media::VideoDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   decoder.reset(new VaapiVideoDecodeAccelerator(
       base::Bind(&DoNothingReturnTrue),
       base::Bind(&GLRenderingVDAClient::BindImage, base::Unretained(this))));
 #endif
-  return decoder.Pass();
+  return decoder;
 }
 
 void GLRenderingVDAClient::BindImage(uint32_t client_texture_id,
                                      uint32_t texture_target,
                                      scoped_refptr<gl::GLImage> image) {}
 
 void GLRenderingVDAClient::CreateAndStartDecoder() {
   LOG_ASSERT(decoder_deleted());
   LOG_ASSERT(!decoder_.get());
 
   VideoDecodeAccelerator::Client* client = this;
 
   scoped_ptr<media::VideoDecodeAccelerator> decoders[] = {
     CreateFakeVDA(),
     CreateDXVAVDA(),
     CreateV4L2VDA(),
     CreateV4L2SliceVDA(),
     CreateVaapiVDA(),
   };
 
   for (size_t i = 0; i < arraysize(decoders); ++i) {
     if (!decoders[i])
       continue;
-    decoder_ = decoders[i].Pass();
+    decoder_ = std::move(decoders[i]);
     weak_decoder_factory_.reset(
         new base::WeakPtrFactory<VideoDecodeAccelerator>(decoder_.get()));
     if (decoder_->Initialize(profile_, client)) {
       SetState(CS_DECODER_SET);
       FinishInitialization();
       return;
     }
   }
   // Decoders are all initialize failed.
   LOG(ERROR) << "VideoDecodeAccelerator::Initialize() failed";
@@ skipping 1045 matching lines @@
   content::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   content::g_env =
       reinterpret_cast<content::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new content::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }