VideoCapture: add support for GpuMemoryBuffer allocation and lifetime mgmt in VideoCaptureBufferPool

media/video/capture/fake_video_capture_device.cc

Index: media/video/capture/fake_video_capture_device.cc
diff --git a/media/video/capture/fake_video_capture_device.cc b/media/video/capture/fake_video_capture_device.cc
index 4f3a8bb7d62ae73569cf634d7c8991239f89f5a0..cd831a9e36bb2b42e1da8369a02635d1d630fd09 100644
--- a/media/video/capture/fake_video_capture_device.cc
+++ b/media/video/capture/fake_video_capture_device.cc
@@ -103,6 +103,7 @@ void FakeVideoCaptureDevice::AllocateAndStart(
 
   switch (device_type_) {
     case USING_OWN_BUFFERS:
+    case USING_OWN_BUFFERS_TRIPLANAR:
       fake_frame_.reset(new uint8[VideoFrame::AllocationSize(
           VideoFrame::I420, capture_format_.frame_size)]);
       BeepAndScheduleNextCapture(
@@ -131,8 +132,7 @@ void FakeVideoCaptureDevice::StopAndDeAllocate() {
 
 void FakeVideoCaptureDevice::CaptureUsingOwnBuffers() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const size_t frame_size =
-      VideoFrame::AllocationSize(VideoFrame::I420, capture_format_.frame_size);
+  const size_t frame_size = capture_format_.ImageAllocationSize();
   memset(fake_frame_.get(), 0, frame_size);
 
   DrawPacman(false  /* use_argb */,
@@ -142,11 +142,24 @@ void FakeVideoCaptureDevice::CaptureUsingOwnBuffers() {
              capture_format_.frame_size);
 
   // Give the captured frame to the client.
-  client_->OnIncomingCapturedData(fake_frame_.get(),
-                                  frame_size,
-                                  capture_format_,
-                                  0,
-                                  base::TimeTicks::Now());
+  if (device_type_ == USING_OWN_BUFFERS) {
+    client_->OnIncomingCapturedData(fake_frame_.get(),
+                                    frame_size,
+                                    capture_format_,
+                                    0  /* rotation */,
+                                    base::TimeTicks::Now());
+  } else if (device_type_ == USING_OWN_BUFFERS_TRIPLANAR) {
+    client_->OnIncomingCapturedYuvData(
+        fake_frame_.get(),
+        fake_frame_.get() + capture_format_.frame_size.GetArea(),
+        fake_frame_.get() + capture_format_.frame_size.GetArea() * 5 / 4,
+        capture_format_.frame_size.width(),
+        capture_format_.frame_size.width() / 2,
+        capture_format_.frame_size.width() / 2,
+        capture_format_,
+        0  /* rotation */,
+        base::TimeTicks::Now());
+  }
   BeepAndScheduleNextCapture(
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                  weak_factory_.GetWeakPtr()));
@@ -162,9 +175,11 @@ void FakeVideoCaptureDevice::CaptureUsingClientBuffers() {
   if (!capture_buffer)
     return;
 
-  uint8_t* const data_ptr = static_cast<uint8_t*>(capture_buffer->data());
-  memset(data_ptr, 0, capture_buffer->size());
+  const scoped_ptr<media::DataHandle> scoped_data_handle =
+      capture_buffer->GetDataHandle().Pass();
+  uint8_t* const data_ptr = static_cast<uint8_t*>(scoped_data_handle->data());
   DCHECK(data_ptr) << "Buffer has NO backing memory";
+  memset(data_ptr, 0, capture_buffer->size());
 
   DrawPacman(false  /* use_argb */,
              data_ptr,
@@ -178,7 +193,7 @@ void FakeVideoCaptureDevice::CaptureUsingClientBuffers() {
           capture_format_.frame_size,
           gfx::Rect(capture_format_.frame_size),
           capture_format_.frame_size,
-          static_cast<uint8*>(capture_buffer->data()),
+          data_ptr,
           capture_buffer->size(),
           base::SharedMemory::NULLHandle(),
           0,
@@ -197,7 +212,34 @@ void FakeVideoCaptureDevice::CaptureUsingClientBuffers() {
 void FakeVideoCaptureDevice::CaptureUsingGpuMemoryBuffers() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  NOTIMPLEMENTED();
+  const scoped_refptr<VideoCaptureDevice::Client::Buffer> capture_buffer =
+      client_->ReserveOutputBuffer(media::PIXEL_FORMAT_GPUMEMORYBUFFER,
+                                   capture_format_.frame_size);
+  DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
+  if (!capture_buffer)
+    return;
+
+  const scoped_ptr<media::DataHandle> scoped_data_handle =
+      capture_buffer->GetDataHandle().Pass();
+  uint8_t* const data_ptr = static_cast<uint8_t*>(scoped_data_handle->data());
+  DCHECK(data_ptr) << "Buffer has NO backing memory";
+  memset(data_ptr, 0, capture_buffer->size());
+
+  DrawPacman(true  /* use_argb */,
+             data_ptr,
+             frame_count_,
+             kFakeCapturePeriodMs,
+             capture_format_.frame_size);
+
+  // Give the captured frame to the client.
+  const VideoCaptureFormat format(capture_format_.frame_size,
+                                  capture_format_.frame_rate,
+                                  media::PIXEL_FORMAT_GPUMEMORYBUFFER);
+  client_->OnIncomingCapturedBuffer(capture_buffer, format,
+                                    base::TimeTicks::Now());
+  BeepAndScheduleNextCapture(
+      base::Bind(&FakeVideoCaptureDevice::CaptureUsingGpuMemoryBuffers,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(