Pass GpuMemoryBuffer backed VideoFrame from browser to renderer processes

content/renderer/media/video_capture_message_filter.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.
 
 #include "content/renderer/media/video_capture_message_filter.h"
 
 #include "content/common/media/video_capture_messages.h"
 #include "content/common/view_messages.h"
 #include "ipc/ipc_sender.h"
 
@@ skipping 43 matching lines @@
 
   return sender_->Send(message);
 }
 
 bool VideoCaptureMessageFilter::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(VideoCaptureMessageFilter, message)
     IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferReceived)
     IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnDeviceStateChanged)
     IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnBufferCreated)
+    IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewGpuMemoryBuffer,
+                        OnGpuMemoryBufferCreated)
     IPC_MESSAGE_HANDLER(VideoCaptureMsg_FreeBuffer, OnBufferDestroyed)
     IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceSupportedFormatsEnumerated,
                         OnDeviceSupportedFormatsEnumerated)
     IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceFormatsInUseReceived,
                         OnDeviceFormatsInUseReceived)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
@@ skipping 22 matching lines @@
     int device_id) const {
   Delegates::const_iterator i = delegates_.find(device_id);
   return i != delegates_.end() ? i->second : NULL;
 }
 
 void VideoCaptureMessageFilter::OnBufferCreated(
     int device_id,
     base::SharedMemoryHandle handle,
     int length,
     int buffer_id) {
-  Delegate* delegate = find_delegate(device_id);
+  Delegate* const delegate = find_delegate(device_id);
   if (!delegate) {
     DLOG(WARNING) << "OnBufferCreated: Got video SHM buffer for a "
                      "non-existent or removed video capture.";
 
     // Send the buffer back to Host in case it's waiting for all buffers
     // to be returned.
     base::SharedMemory::CloseHandle(handle);
+
     Send(new VideoCaptureHostMsg_BufferReady(device_id, buffer_id, 0, -1.0));
     return;
   }
 
   delegate->OnBufferCreated(handle, length, buffer_id);
 }
 
+void VideoCaptureMessageFilter::OnGpuMemoryBufferCreated(
+    int device_id,
+    const std::vector<gfx::GpuMemoryBufferHandle>& gmb_handles,
+    const gfx::Size& size,
+    int buffer_id) {
+  Delegate* delegate = find_delegate(device_id);

[mcasas, 2015/08/21 03:57:25]

Delegate* const delegate

+  if (!delegate) {
+    DLOG(WARNING) << "OnBufferCreated: Got video GMB buffer for a "
+                     "non-existent or removed video capture.";
+    Send(new VideoCaptureHostMsg_BufferReady(device_id, buffer_id, 0, -1.0));

[mcasas, 2015/08/21 03:57:25]

0? -1.0??

Proposal:
0 /* release_sync_point */, -1.0  /* consumer_resource_utilization */

Here and in l.117.

+    return;
+  }
+
+  delegate->OnGpuMemoryBufferCreated(gmb_handles, size, buffer_id);
+}
+
 void VideoCaptureMessageFilter::OnBufferReceived(
     const VideoCaptureMsg_BufferReady_Params& params) {
   Delegate* const delegate = find_delegate(params.device_id);
   if (!delegate) {
     DLOG(WARNING) << "OnBufferReceived: Got video SHM buffer for a "
                      "non-existent or removed video capture.";
 
     // Send the buffer back to Host in case it's waiting for all buffers
     // to be returned.
     Send(new VideoCaptureHostMsg_BufferReady(
         params.device_id, params.buffer_id, 0, -1.0));
     return;
   }
 
   delegate->OnBufferReceived(params.buffer_id,
                              params.timestamp,
                              params.metadata,
                              params.pixel_format,
                              params.storage_type,
                              params.coded_size,
                              params.visible_rect,
-                             params.mailbox_holder);
+                             params.mailbox_holders);
 }
 
 void VideoCaptureMessageFilter::OnBufferDestroyed(
     int device_id,
     int buffer_id) {
   Delegate* delegate = find_delegate(device_id);
   if (!delegate) {
     DLOG(WARNING) << "OnBufferDestroyed: Instructed to free buffer for a "
         "non-existent or removed video capture.";
     return;
@@ skipping 30 matching lines @@
     const media::VideoCaptureFormats& formats_in_use) {
   Delegate* delegate = find_delegate(device_id);
   if (!delegate) {
     DLOG(WARNING) << "OnDeviceFormatInUse: unknown device";
     return;
   }
   delegate->OnDeviceFormatsInUseReceived(formats_in_use);
 }
 
 }  // namespace content