Implement IPCs and VideoCapture::Client interfaces for texture capture

content/browser/renderer_host/media/video_capture_host_unittest.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 <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 96 matching lines @@
 
 class MockVideoCaptureHost : public VideoCaptureHost {
  public:
   MockVideoCaptureHost(MediaStreamManager* manager)
       : VideoCaptureHost(manager),
         return_buffers_(false),
         dump_video_(false) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnNewBufferCreated,
-               void(int device_id, base::SharedMemoryHandle handle,
-                    int length, int buffer_id));
+               void(int device_id,
+                    base::SharedMemoryHandle handle,
+                    int length,
+                    int buffer_id));
   MOCK_METHOD2(OnBufferFreed,
                void(int device_id, int buffer_id));
   MOCK_METHOD4(OnBufferFilled,
                void(int device_id,
                     int buffer_id,
-                    base::TimeTicks timestamp,
-                    const media::VideoCaptureFormat& format));
+                    const media::VideoCaptureFormat& format,
+                    base::TimeTicks timestamp));
+  MOCK_METHOD5(OnMailboxBufferFilled,
+               void(int device_id,
+                    int buffer_id,
+                    const gpu::MailboxHolder& mailbox_holder,
+                    const media::VideoCaptureFormat& format,
+                    base::TimeTicks timestamp));
   MOCK_METHOD2(OnStateChanged, void(int device_id, VideoCaptureState state));
 
   // Use class DumpVideo to write I420 video to file.
   void SetDumpVideo(bool enable) {
     dump_video_ = enable;
   }
 
   void SetReturnReceivedDibs(bool enable) {
     return_buffers_ = enable;
   }
 
   // Return Dibs we currently have received.
   void ReturnReceivedDibs(int device_id)  {
     int handle = GetReceivedDib();
     while (handle) {
-      this->OnReceiveEmptyBuffer(device_id, handle);
+      this->OnReceiveEmptyBuffer(device_id, handle, 0);
       handle = GetReceivedDib();
     }
   }
 
   int GetReceivedDib() {
     if (filled_dib_.empty())
       return 0;
     std::map<int, base::SharedMemory*>::iterator it = filled_dib_.begin();
     int h = it->first;
     delete it->second;
@@ skipping 14 matching lines @@
   virtual bool Send(IPC::Message* message) OVERRIDE {
     CHECK(message);
 
     // In this method we dispatch the messages to the according handlers as if
     // we are the renderer.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(MockVideoCaptureHost, *message)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_NewBuffer, OnNewBufferCreatedDispatch)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_FreeBuffer, OnBufferFreedDispatch)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_BufferReady, OnBufferFilledDispatch)
+      IPC_MESSAGE_HANDLER(VideoCaptureMsg_MailboxBufferReady,
+                          OnMailboxBufferFilledDispatch)
       IPC_MESSAGE_HANDLER(VideoCaptureMsg_StateChanged, OnStateChangedDispatch)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
   // These handler methods do minimal things and delegate to the mock methods.
@@ skipping 12 matching lines @@
 
     std::map<int, base::SharedMemory*>::iterator it =
         filled_dib_.find(buffer_id);
     ASSERT_TRUE(it != filled_dib_.end());
     delete it->second;
     filled_dib_.erase(it);
   }
 
   void OnBufferFilledDispatch(int device_id,
                               int buffer_id,
-                              base::TimeTicks timestamp,
-                              const media::VideoCaptureFormat& frame_format) {
+                              const media::VideoCaptureFormat& frame_format,
+                              base::TimeTicks timestamp) {
     base::SharedMemory* dib = filled_dib_[buffer_id];
     ASSERT_TRUE(dib != NULL);
     if (dump_video_) {
       if (!format_.IsValid()) {
         dumper_.StartDump(frame_format.frame_size.width(),
                           frame_format.frame_size.height());
         format_ = frame_format;
       }
       ASSERT_EQ(format_.frame_size.width(), frame_format.frame_size.width())
           << "Dump format does not handle variable resolution.";
       ASSERT_EQ(format_.frame_size.height(), frame_format.frame_size.height())
           << "Dump format does not handle variable resolution.";
       dumper_.NewVideoFrame(dib->memory());
     }
 
-    OnBufferFilled(device_id, buffer_id, timestamp, frame_format);
+    OnBufferFilled(device_id, buffer_id, frame_format, timestamp);
     if (return_buffers_) {
-      VideoCaptureHost::OnReceiveEmptyBuffer(device_id, buffer_id);
+      VideoCaptureHost::OnReceiveEmptyBuffer(device_id, buffer_id, 0);
     }
   }
 
+  void OnMailboxBufferFilledDispatch(int device_id,
+                                     int buffer_id,
+                                     const gpu::MailboxHolder& mailbox_holder,
+                                     const media::VideoCaptureFormat& format,
+                                     base::TimeTicks timestamp) {
+    OnMailboxBufferFilled(
+        device_id, buffer_id, mailbox_holder, format, timestamp);
+    if (return_buffers_) {
+      VideoCaptureHost::OnReceiveEmptyBuffer(
+          device_id, buffer_id, mailbox_holder.sync_point);
+    }
+  }
+
   void OnStateChangedDispatch(int device_id, VideoCaptureState state) {
     OnStateChanged(device_id, state);
   }
 
   std::map<int, base::SharedMemory*> filled_dib_;
   bool return_buffers_;
   bool dump_video_;
   media::VideoCaptureFormat format_;
   DumpVideo dumper_;
 };
@@ skipping 262 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content