Implement IPCs and VideoCapture::Client interfaces for texture capture

content/browser/renderer_host/media/video_capture_host.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/browser/renderer_host/media/video_capture_host.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
@@ skipping 51 matching lines @@
     int buffer_id) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureHost::DoSendFreeBufferOnIOThread,
                  this, controller_id, buffer_id));
 }
 
 void VideoCaptureHost::OnBufferReady(
     const VideoCaptureControllerID& controller_id,
     int buffer_id,
-    base::TimeTicks timestamp,
-    const media::VideoCaptureFormat& frame_format) {
+    const media::VideoCaptureFormat& frame_format,
+    base::TimeTicks timestamp) {
   BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
+      BrowserThread::IO,
+      FROM_HERE,
       base::Bind(&VideoCaptureHost::DoSendFilledBufferOnIOThread,
-                 this, controller_id, buffer_id, timestamp,
-                 frame_format));
+                 this,
+                 controller_id,
+                 buffer_id,
+                 frame_format,
+                 timestamp));
+}
+
+void VideoCaptureHost::OnMailboxBufferReady(
+    const VideoCaptureControllerID& controller_id,
+    int buffer_id,
+    const gpu::MailboxHolder& mailbox_holder,
+    const media::VideoCaptureFormat& frame_format,
+    base::TimeTicks timestamp) {
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&VideoCaptureHost::DoSendFilledMailboxBufferOnIOThread,

[mcasas, 2014/01/21 14:34:02]

If the call to VideoCaptureHost::OnMailboxBufferReady comes
from a method in the IO thread 
VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread(),
is it needed to jump again to IO thread?

[sheu, 2014/01/29 01:19:20]

Most of the trampolining seems unnecessary here, but the interface does not
enforce that the functions here are always called on the IO thread. 
Additionally, the VideoCaptureHost is created on the UI thread, so one can't
even say that the VideoCaptureHost is to be used on the thread it's created on,
and remove the trampolining that way.

+                 this,
+                 controller_id,
+                 buffer_id,
+                 mailbox_holder,
+                 frame_format,
+                 timestamp));
 }
 
 void VideoCaptureHost::OnEnded(const VideoCaptureControllerID& controller_id) {
   DVLOG(1) << "VideoCaptureHost::OnEnded";
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureHost::DoEndedOnIOThread, this, controller_id));
 }
 
 void VideoCaptureHost::DoSendNewBufferOnIOThread(
@@ skipping 17 matching lines @@
 
   if (entries_.find(controller_id) == entries_.end())
     return;
 
   Send(new VideoCaptureMsg_FreeBuffer(controller_id.device_id, buffer_id));
 }
 
 void VideoCaptureHost::DoSendFilledBufferOnIOThread(
     const VideoCaptureControllerID& controller_id,
     int buffer_id,
-    base::TimeTicks timestamp,
-    const media::VideoCaptureFormat& format) {
+    const media::VideoCaptureFormat& format,
+    base::TimeTicks timestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (entries_.find(controller_id) == entries_.end())
     return;
 
-  Send(new VideoCaptureMsg_BufferReady(controller_id.device_id, buffer_id,
-                                       timestamp, format));
+  Send(new VideoCaptureMsg_BufferReady(
+      controller_id.device_id, buffer_id, format, timestamp));
+}
+
+void VideoCaptureHost::DoSendFilledMailboxBufferOnIOThread(
+    const VideoCaptureControllerID& controller_id,
+    int buffer_id,
+    const gpu::MailboxHolder& mailbox_holder,
+    const media::VideoCaptureFormat& format,
+    base::TimeTicks timestamp) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (entries_.find(controller_id) == entries_.end())
+    return;
+
+  Send(new VideoCaptureMsg_MailboxBufferReady(
+      controller_id.device_id, buffer_id, mailbox_holder, format, timestamp));
 }
 
 void VideoCaptureHost::DoHandleErrorOnIOThread(
     const VideoCaptureControllerID& controller_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (entries_.find(controller_id) == entries_.end())
     return;
 
   Send(new VideoCaptureMsg_StateChanged(controller_id.device_id,
@@ skipping 101 matching lines @@
   DeleteVideoCaptureControllerOnIOThread(controller_id);
 }
 
 void VideoCaptureHost::OnPauseCapture(int device_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DVLOG(1) << "VideoCaptureHost::OnPauseCapture, device_id " << device_id;
   // Not used.
   Send(new VideoCaptureMsg_StateChanged(device_id, VIDEO_CAPTURE_STATE_ERROR));
 }
 
-void VideoCaptureHost::OnReceiveEmptyBuffer(int device_id, int buffer_id) {
+void VideoCaptureHost::OnReceiveEmptyBuffer(int device_id,
+                                            int buffer_id,
+                                            uint32 sync_point) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   VideoCaptureControllerID controller_id(device_id);
   EntryMap::iterator it = entries_.find(controller_id);
   if (it != entries_.end()) {
     const base::WeakPtr<VideoCaptureController>& controller = it->second;
     if (controller)
-      controller->ReturnBuffer(controller_id, this, buffer_id);
+      controller->ReturnBuffer(controller_id, this, buffer_id, sync_point);
   }
 }
 
 void VideoCaptureHost::DeleteVideoCaptureControllerOnIOThread(
     const VideoCaptureControllerID& controller_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   EntryMap::iterator it = entries_.find(controller_id);
   if (it == entries_.end())
     return;
 
   if (it->second) {
     media_stream_manager_->video_capture_manager()->StopCaptureForClient(
         it->second.get(), controller_id, this);
   }
   entries_.erase(it);
 }
 
 }  // namespace content