Pass GpuMemoryBuffer backed VideoFrame from browser to renderer processes

content/renderer/media/video_capture_message_filter.h

 // 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.
 //
 // MessageFilter that handles video capture messages and delegates them to
 // video captures. VideoCaptureMessageFilter is operated on IO thread of
 // render process. It intercepts video capture messages and process them on
 // IO thread since these messages are time critical.
 
 #ifndef CONTENT_RENDERER_MEDIA_VIDEO_CAPTURE_MESSAGE_FILTER_H_
 #define CONTENT_RENDERER_MEDIA_VIDEO_CAPTURE_MESSAGE_FILTER_H_
 
 #include <map>
 
 #include "base/memory/shared_memory.h"
 #include "base/values.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
 #include "ipc/message_filter.h"
 #include "media/base/video_capture_types.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 
 struct VideoCaptureMsg_BufferReady_Params;
 
 namespace gpu {
 struct MailboxHolder;
 }  // namespace gpu
 
 namespace content {
 
 class CONTENT_EXPORT VideoCaptureMessageFilter : public IPC::MessageFilter {
  public:
   class CONTENT_EXPORT Delegate {
    public:
     // Called when a video frame buffer is created in the browser process.
     virtual void OnBufferCreated(base::SharedMemoryHandle handle,
                                  int length,
                                  int buffer_id) = 0;
 
+    // Called when a GpuMemoryBuffer backed video frame buffer is created in the
+    // browser process.
+    virtual void OnGpuMemoryBufferCreated(
+        const std::vector<gfx::GpuMemoryBufferHandle>& gmb_handles,
+        const gfx::Size& size,
+        int buffer_id) = 0;
+
     virtual void OnBufferDestroyed(int buffer_id) = 0;
 
     // Called when a buffer referencing a captured VideoFrame is received from
     // Browser process.
-    virtual void OnBufferReceived(int buffer_id,
-                                  base::TimeTicks timestamp,
-                                  const base::DictionaryValue& metadata,
-                                  media::VideoPixelFormat pixel_format,
-                                  media::VideoFrame::StorageType storage_type,
-                                  const gfx::Size& coded_size,
-                                  const gfx::Rect& visible_rect,
-                                  const gpu::MailboxHolder& mailbox_holder) = 0;
+    virtual void OnBufferReceived(
+        int buffer_id,
+        base::TimeTicks timestamp,
+        const base::DictionaryValue& metadata,
+        media::VideoPixelFormat pixel_format,
+        media::VideoFrame::StorageType storage_type,
+        const gfx::Size& coded_size,
+        const gfx::Rect& visible_rect,
+        const std::vector<gpu::MailboxHolder>& mailbox_holders) = 0;
 
     // Called when state of a video capture device has changed in the browser
     // process.
     virtual void OnStateChanged(VideoCaptureState state) = 0;
 
     // Called upon reception of device's supported formats back from browser.
     virtual void OnDeviceSupportedFormatsEnumerated(
         const media::VideoCaptureFormats& supported_formats) = 0;
 
     // Called upon reception of format(s) in use by a device back from browser.
@@ skipping 30 matching lines @@
 
  private:
   typedef std::map<int32, Delegate*> Delegates;
 
   // Receive a newly created buffer from browser process.
   void OnBufferCreated(int device_id,
                        base::SharedMemoryHandle handle,
                        int length,
                        int buffer_id);
 
+  // Receive a newly created GpuMemoryBuffer backed buffer from browser process.
+  void OnGpuMemoryBufferCreated(
+      int device_id,
+      const std::vector<gfx::GpuMemoryBufferHandle>& gmb_handles,
+      const gfx::Size& size,
+      int buffer_id);
+
   // Release a buffer received by OnBufferCreated.
   void OnBufferDestroyed(int device_id,
                          int buffer_id);
 
   // Receive a filled buffer from browser process.
   void OnBufferReceived(const VideoCaptureMsg_BufferReady_Params& params);
 
   // State of browser process' video capture device has changed.
   void OnDeviceStateChanged(int device_id, VideoCaptureState state);
 
@@ skipping 16 matching lines @@
   int32 last_device_id_;
 
   IPC::Sender* sender_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureMessageFilter);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_VIDEO_CAPTURE_MESSAGE_FILTER_H_