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

content/browser/renderer_host/media/video_capture_device_client.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/browser/renderer_host/media/video_capture_device_client.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.h"
@@ skipping 11 matching lines @@
 namespace content {
 
 // Class combining a Client::Buffer interface implementation and a pool buffer
 // implementation to guarantee proper cleanup on destruction on our side.
 class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
  public:
   AutoReleaseBuffer(const scoped_refptr<VideoCaptureBufferPool>& pool,
                     int buffer_id)
       : id_(buffer_id),
         pool_(pool),
-        buffer_handle_(pool_->GetBufferHandle(buffer_id).Pass()) {
+        buffer_handle_(pool_->GetBufferHandle(buffer_id)) {
     DCHECK(pool_.get());
   }
   int id() const override { return id_; }
   gfx::Size dimensions() const override { return buffer_handle_->dimensions(); }
   size_t mapped_size() const override { return buffer_handle_->mapped_size(); }
   void* data(int plane) override { return buffer_handle_->data(plane); }
   ClientBuffer AsClientBuffer(int plane) override {
     return buffer_handle_->AsClientBuffer(plane);
   }
 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
@@ skipping 166 matching lines @@
 
   if (external_jpeg_decoder_) {
     const VideoCaptureGpuJpegDecoder::STATUS status =
         external_jpeg_decoder_->GetStatus();
     if (status == VideoCaptureGpuJpegDecoder::FAILED) {
       external_jpeg_decoder_.reset();
     } else if (status == VideoCaptureGpuJpegDecoder::INIT_PASSED &&
         frame_format.pixel_format == media::PIXEL_FORMAT_MJPEG &&
         rotation == 0 && !flip) {
       external_jpeg_decoder_->DecodeCapturedData(data, length, frame_format,
-                                                 timestamp, buffer.Pass());
+                                                 timestamp, std::move(buffer));
       return;
     }
   }
 
   if (libyuv::ConvertToI420(data,
                             length,
                             y_plane_data,
                             yplane_stride,
                             u_plane_data,
                             uv_plane_stride,
                             v_plane_data,
                             uv_plane_stride,
                             crop_x,
                             crop_y,
                             frame_format.frame_size.width(),
                             (flip ? -1 : 1) * frame_format.frame_size.height(),
                             new_unrotated_width,
                             new_unrotated_height,
                             rotation_mode,
                             origin_colorspace) != 0) {
     DLOG(WARNING) << "Failed to convert buffer's pixel format to I420 from "
                   << media::VideoPixelFormatToString(frame_format.pixel_format);
     return;
   }
 
   const VideoCaptureFormat output_format = VideoCaptureFormat(
       dimensions, frame_format.frame_rate,
       media::PIXEL_FORMAT_I420, output_pixel_storage);
-  OnIncomingCapturedBuffer(buffer.Pass(), output_format, timestamp);
+  OnIncomingCapturedBuffer(std::move(buffer), output_format, timestamp);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedYuvData(
     const uint8_t* y_data,
     const uint8_t* u_data,
     const uint8_t* v_data,
     size_t y_stride,
     size_t u_stride,
     size_t v_stride,
     const VideoCaptureFormat& frame_format,
@@ skipping 29 matching lines @@
                        v_data, v_stride,
                        y_plane_data, dst_y_stride,
                        u_plane_data, dst_u_stride,
                        v_plane_data, dst_v_stride,
                        frame_format.frame_size.width(),
                        frame_format.frame_size.height())) {
     DLOG(WARNING) << "Failed to copy buffer";
     return;
   }
 
-  OnIncomingCapturedBuffer(buffer.Pass(), frame_format, timestamp);
+  OnIncomingCapturedBuffer(std::move(buffer), frame_format, timestamp);
 };
 
 scoped_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ReserveOutputBuffer(
     const gfx::Size& frame_size,
     media::VideoPixelFormat pixel_format,
     media::VideoPixelStorage pixel_storage) {
   DCHECK_GT(frame_size.width(), 0);
   DCHECK_GT(frame_size.height(), 0);
   // Currently, only I420 pixel format is supported.
@@ skipping 10 matching lines @@
   scoped_ptr<media::VideoCaptureDevice::Client::Buffer> output_buffer(
       new AutoReleaseBuffer(buffer_pool_, buffer_id));
 
   if (buffer_id_to_drop != VideoCaptureBufferPool::kInvalidId) {
     BrowserThread::PostTask(BrowserThread::IO,
         FROM_HERE,
         base::Bind(&VideoCaptureController::DoBufferDestroyedOnIOThread,
                    controller_, buffer_id_to_drop));
   }
 
-  return output_buffer.Pass();
+  return output_buffer;
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     scoped_ptr<Buffer> buffer,
     const VideoCaptureFormat& frame_format,
     const base::TimeTicks& timestamp) {
   // Currently, only I420 pixel format is supported.
   DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_format.pixel_format);
 
   scoped_refptr<VideoFrame> frame;
@@ skipping 16 matching lines @@
           gfx::Rect(frame_format.frame_size), frame_format.frame_size,
           reinterpret_cast<uint8_t*>(buffer->data()),
           VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
                                      frame_format.frame_size),
           base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
       break;
   }
   DCHECK(frame.get());
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                frame_format.frame_rate);
-  OnIncomingCapturedVideoFrame(buffer.Pass(), frame, timestamp);
+  OnIncomingCapturedVideoFrame(std::move(buffer), frame, timestamp);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     scoped_ptr<Buffer> buffer,
     const scoped_refptr<VideoFrame>& frame,
     const base::TimeTicks& timestamp) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
@@ skipping 55 matching lines @@
       // arithmetic inside Buffer::data() when this bug is resolved.
       *y_plane_data = reinterpret_cast<uint8_t*>(buffer->data());
       *u_plane_data =
           *y_plane_data +
           VideoFrame::PlaneSize(format, VideoFrame::kYPlane, dimensions)
               .GetArea();
       *v_plane_data =
           *u_plane_data +
           VideoFrame::PlaneSize(format, VideoFrame::kUPlane, dimensions)
               .GetArea();
-      return buffer.Pass();
+      return buffer;
     case media::PIXEL_STORAGE_GPUMEMORYBUFFER:
       *y_plane_data =
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kYPlane));
       *u_plane_data =
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kUPlane));
       *v_plane_data =
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kVPlane));
-      return buffer.Pass();
+      return buffer;
   }
   NOTREACHED();
   return scoped_ptr<Buffer>();
 }
 
 }  // namespace content