Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

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/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 46 matching lines @@
 // Define to enable test where video is dumped to file.
 // #define DUMP_VIDEO
 
 // Define to use a real video capture device.
 // #define TEST_REAL_CAPTURE_DEVICE
 
 // Simple class used for dumping video to a file. This can be used for
 // verifying the output.
 class DumpVideo {
  public:
-  DumpVideo() : expected_size_(0) {}
-  void StartDump(int width, int height) {
+  DumpVideo() {}
+  const gfx::Size& coded_size() const { return coded_size_; }
+  void StartDump(const gfx::Size& coded_size) {
     base::FilePath file_name = base::FilePath(base::StringPrintf(
-        FILE_PATH_LITERAL("dump_w%d_h%d.yuv"), width, height));
+        FILE_PATH_LITERAL("dump_w%d_h%d.yuv"),
+        coded_size.width(),
+        coded_size.height()));
     file_.reset(base::OpenFile(file_name, "wb"));
-    expected_size_ = media::VideoFrame::AllocationSize(
-        media::VideoFrame::I420, gfx::Size(width, height));
+    coded_size_ = coded_size;
   }
   void NewVideoFrame(const void* buffer) {
     if (file_.get() != NULL) {
-      ASSERT_EQ(1U, fwrite(buffer, expected_size_, 1, file_.get()));
+      const int size = media::VideoFrame::AllocationSize(
+          media::VideoFrame::I420, coded_size_);
+      ASSERT_EQ(1U, fwrite(buffer, size, 1, file_.get()));
     }
   }
 
  private:
   base::ScopedFILE file_;
-  int expected_size_;
+  gfx::Size coded_size_;
 };
 
 class MockMediaStreamRequester : public MediaStreamRequester {
  public:
   MockMediaStreamRequester() {}
   virtual ~MockMediaStreamRequester() {}
 
   // MediaStreamRequester implementation.
   MOCK_METHOD5(StreamGenerated,
                void(int render_frame_id,
@@ skipping 29 matching lines @@
         dump_video_(false) {}
 
   // A list of mock methods.
   MOCK_METHOD4(OnNewBufferCreated,
                void(int device_id,
                     base::SharedMemoryHandle handle,
                     int length,
                     int buffer_id));
   MOCK_METHOD2(OnBufferFreed,
                void(int device_id, int buffer_id));
-  MOCK_METHOD5(OnBufferFilled,
+  MOCK_METHOD6(OnBufferFilled,
                void(int device_id,
                     int buffer_id,
-                    const media::VideoCaptureFormat& format,
+                    const gfx::Size& coded_size,
                     const gfx::Rect& visible_rect,
-                    base::TimeTicks timestamp));
-  MOCK_METHOD5(OnMailboxBufferFilled,
+                    base::TimeTicks timestamp,
+                    const base::DictionaryValue& metadata));
+  MOCK_METHOD6(OnMailboxBufferFilled,
                void(int device_id,
                     int buffer_id,
                     const gpu::MailboxHolder& mailbox_holder,
-                    const media::VideoCaptureFormat& format,
-                    base::TimeTicks timestamp));
+                    const gfx::Size& packed_frame_size,
+                    base::TimeTicks timestamp,
+                    const base::DictionaryValue& metadata));
   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;
   }
@@ skipping 62 matching lines @@
   void OnBufferFreedDispatch(int device_id, int buffer_id) {
     OnBufferFreed(device_id, buffer_id);
 
     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,
-                              const media::VideoCaptureFormat& frame_format,
-                              const gfx::Rect& visible_rect,
-                              base::TimeTicks timestamp) {
-    base::SharedMemory* dib = filled_dib_[buffer_id];
+  void OnBufferFilledDispatch(
+      const VideoCaptureMsg_BufferReady_Params& params) {
+    base::SharedMemory* dib = filled_dib_[params.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())
+      if (dumper_.coded_size().IsEmpty())
+        dumper_.StartDump(params.coded_size);
+      ASSERT_TRUE(dumper_.coded_size() == params.coded_size)
           << "Dump format does not handle variable resolution.";
       dumper_.NewVideoFrame(dib->memory());
     }
 
-    OnBufferFilled(device_id, buffer_id, frame_format, visible_rect, timestamp);
+    OnBufferFilled(params.device_id, params.buffer_id, params.coded_size,
+                   params.visible_rect, params.timestamp, params.metadata);
     if (return_buffers_) {
-      VideoCaptureHost::OnReceiveEmptyBuffer(device_id, buffer_id, 0);
+      VideoCaptureHost::OnReceiveEmptyBuffer(
+          params.device_id, params.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);
+  void OnMailboxBufferFilledDispatch(
+      const VideoCaptureMsg_MailboxBufferReady_Params& params) {
+    OnMailboxBufferFilled(params.device_id, params.buffer_id,
+                          params.mailbox_holder, params.packed_frame_size,
+                          params.timestamp, params.metadata);
     if (return_buffers_) {
-      VideoCaptureHost::OnReceiveEmptyBuffer(device_id, buffer_id, 0);
+      VideoCaptureHost::OnReceiveEmptyBuffer(
+          params.device_id, params.buffer_id, 0);
     }
   }
 
   void OnStateChangedDispatch(int device_id, VideoCaptureState state) {
     OnStateChanged(device_id, state);
   }
 
   std::map<int, base::SharedMemory*> filled_dib_;
   bool return_buffers_;
   bool dump_video_;
@@ skipping 128 matching lines @@
     opened_session_id_ = kInvalidMediaCaptureSessionId;
   }
 
  protected:
   void StartCapture() {
     EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber())
         .WillRepeatedly(Return());
 
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _, _))
+    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(352, 288), 30, media::PIXEL_FORMAT_I420);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
 
@@ skipping 13 matching lines @@
     WaitForVideoDeviceThread();
   }
 
 #ifdef DUMP_VIDEO
   void CaptureAndDumpVideo(int width, int height, int frame_rate) {
     InSequence s;
     EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber()).WillRepeatedly(Return());
 
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _, _, _))
+    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _, _, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     media::VideoCaptureParams params;
     params.requested_format =
         media::VideoCaptureFormat(gfx::Size(width, height), frame_rate);
     host_->SetDumpVideo(true);
     host_->OnStartCapture(kDeviceId, opened_session_id_, params);
     run_loop.Run();
   }
@@ skipping 11 matching lines @@
 
     run_loop.Run();
 
     host_->SetReturnReceivedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_EQ(0u, host_->entries_.size());
   }
 
   void NotifyPacketReady() {
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _, _))
+    EXPECT_CALL(*host_.get(), OnBufferFilled(kDeviceId, _, _, _, _, _))
         .Times(AnyNumber())
         .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()))
         .RetiresOnSaturation();
     run_loop.Run();
   }
 
   void ReturnReceivedPackets() {
     host_->ReturnReceivedDibs(kDeviceId);
   }
 
@@ skipping 74 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content