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

content/common/gpu/media/gpu_jpeg_decode_accelerator.cc

 // Copyright 2015 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 "content/common/gpu/media/gpu_jpeg_decode_accelerator.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
@@ skipping 87 matching lines @@
 
   void Decode(const media::BitstreamBuffer& bitstream_buffer,
               const scoped_refptr<media::VideoFrame>& video_frame) {
     DCHECK(CalledOnValidThread());
     DCHECK(accelerator_);
     accelerator_->Decode(bitstream_buffer, video_frame);
   }
 
   void set_accelerator(scoped_ptr<media::JpegDecodeAccelerator> accelerator) {
     DCHECK(CalledOnValidThread());
-    accelerator_ = accelerator.Pass();
+    accelerator_ = std::move(accelerator);
   }
 
  private:
   base::WeakPtr<content::GpuJpegDecodeAccelerator> owner_;
   int32_t route_id_;
   scoped_ptr<media::JpegDecodeAccelerator> accelerator_;
 };
 
 // Create, destroy, and RemoveClient run on child thread. All other methods run
 // on IO thread.
@@ skipping 210 matching lines @@
       &GpuJpegDecodeAccelerator::CreateV4L2JDA,
       &GpuJpegDecodeAccelerator::CreateVaapiJDA,
   };
 
   scoped_ptr<Client> client(new Client(this, route_id));
   scoped_ptr<media::JpegDecodeAccelerator> accelerator;
   for (const auto& create_jda_function : create_jda_fps) {
     scoped_ptr<media::JpegDecodeAccelerator> tmp_accelerator =
         (*create_jda_function)(io_task_runner_);
     if (tmp_accelerator && tmp_accelerator->Initialize(client.get())) {
-      accelerator = tmp_accelerator.Pass();
+      accelerator = std::move(tmp_accelerator);
       break;
     }
   }
 
   if (!accelerator) {
     DLOG(ERROR) << "JPEG accelerator Initialize failed";
     GpuMsg_CreateJpegDecoder::WriteReplyParams(reply_msg, false);
     Send(reply_msg);
     return;
   }
-  client->set_accelerator(accelerator.Pass());
+  client->set_accelerator(std::move(accelerator));
 
   if (!filter_) {
     DCHECK_EQ(client_number_, 0);
     filter_ = new MessageFilter(this);
     // This should be before AddClientOnIOThread.
     channel_->AddFilter(filter_.get());
   }
   client_number_++;
 
   // In this PostTask, |client| may leak if |io_task_runner_| is destroyed
@@ skipping 34 matching lines @@
 scoped_ptr<media::JpegDecodeAccelerator>
 GpuJpegDecodeAccelerator::CreateV4L2JDA(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
   scoped_ptr<media::JpegDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(USE_V4L2_CODEC)
   scoped_refptr<V4L2Device> device = V4L2Device::Create(
       V4L2Device::kJpegDecoder);
   if (device)
     decoder.reset(new V4L2JpegDecodeAccelerator(device, io_task_runner));
 #endif
-  return decoder.Pass();
+  return decoder;
 }
 
 // static
 scoped_ptr<media::JpegDecodeAccelerator>
 GpuJpegDecodeAccelerator::CreateVaapiJDA(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner) {
   scoped_ptr<media::JpegDecodeAccelerator> decoder;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   decoder.reset(new VaapiJpegDecodeAccelerator(io_task_runner));
 #endif
-  return decoder.Pass();
+  return decoder;
 }
 
 // static
 bool GpuJpegDecodeAccelerator::IsSupported() {
   const GpuJpegDecodeAccelerator::CreateJDAFp create_jda_fps[] = {
       &GpuJpegDecodeAccelerator::CreateV4L2JDA,
       &GpuJpegDecodeAccelerator::CreateVaapiJDA,
   };
   for (const auto& create_jda_function : create_jda_fps) {
     scoped_ptr<media::JpegDecodeAccelerator> accelerator =
         (*create_jda_function)(base::ThreadTaskRunnerHandle::Get());
     if (accelerator && accelerator->IsSupported())
       return true;
   }
   return false;
 }
 
 }  // namespace content