VideoCaptureBufferPool: Refactor to allow support of non-ShMem backed buffers

content/browser/renderer_host/media/video_capture_texture_wrapper.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_texture_wrapper.h"
 
 #include "base/bind.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
@@ skipping 190 matching lines @@
 }
 
 void VideoCaptureTextureWrapper::OnIncomingCapturedData(
     const uint8* data,
     int length,
     const media::VideoCaptureFormat& frame_format,
     int clockwise_rotation,
     const base::TimeTicks& timestamp) {
 
   // Reserve a temporary Buffer for conversion to ARGB.
+  const media::VideoCaptureFormat format(frame_format.frame_size,
+                                         frame_format.frame_rate,
+                                         media::PIXEL_FORMAT_ARGB);
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> argb_buffer =
-      ReserveOutputBuffer(media::VideoFrame::ARGB, frame_format.frame_size);
+      ReserveOutputBuffer(format);
   DVLOG_IF(1, !argb_buffer) << "Couldn't allocate ARGB Buffer";
   if (!argb_buffer)
     return;
 
   DCHECK(argb_buffer->data());
   // TODO(mcasas): Take |rotation| into acount.
   int ret = libyuv::ConvertToARGB(data,
                                   length,
                                   reinterpret_cast<uint8*>(argb_buffer->data()),
                                   frame_format.frame_size.width() * 4,
                                   0,
                                   0,
                                   frame_format.frame_size.width(),
                                   frame_format.frame_size.height(),
                                   frame_format.frame_size.width(),
                                   frame_format.frame_size.height(),
                                   libyuv::kRotate0,
                                   VideoPixelFormatToFourCC(
                                       frame_format.pixel_format));
   DLOG_IF(ERROR, ret != 0) << "Error converting incoming frame";
   if (ret != 0)
     return;
 
   // Reserve output buffer for the texture on the IPC borderlands.
+  const media::VideoCaptureFormat format2(gfx::Size(),

[miu, 2015/04/08 01:20:00]

Here, an empty size is being passed.  If the texture format is specified, won't
VCBufferPool need to know the size to allocate a GpuMemoryBuffer?

[mcasas, 2015/04/08 22:07:06]

Yes, down the line it will. 

Changed this line to using |frame_format.frame_size|.

Please read the comments about the change of 
ReserveOutputBuffer() signature below.

+                                          frame_format.frame_rate,
+                                          media::PIXEL_FORMAT_TEXTURE);
   scoped_refptr<media::VideoCaptureDevice::Client::Buffer> texture_buffer =
-      ReserveOutputBuffer(media::VideoFrame::NATIVE_TEXTURE, gfx::Size());
+      ReserveOutputBuffer(format2);
   DVLOG_IF(1, !texture_buffer) << "Couldn't allocate Texture Buffer";
   if (!texture_buffer)
     return;
 
   capture_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &TextureWrapperDelegate::OnIncomingCapturedData,
           wrapper_delegate_,
           texture_buffer,
@@ skipping 205 matching lines @@
 void VideoCaptureTextureWrapper::TextureWrapperDelegate::OnError(
     const std::string& message) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << message;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
 }  // namespace content