Video capture frame size: separate coded size and visible size.

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/file_util.h"
@@ skipping 108 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_METHOD4(OnBufferFilled,
+  MOCK_METHOD5(OnBufferFilled,
                void(int device_id,
                     int buffer_id,
                     const media::VideoCaptureFormat& format,
+                    const gfx::Rect& visible_rect,
                     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.
@@ skipping 72 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,
                               const media::VideoCaptureFormat& frame_format,
+                              const gfx::Rect& visible_rect,
                               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, frame_format, timestamp);
+    OnBufferFilled(device_id, buffer_id, frame_format, visible_rect, timestamp);
     if (return_buffers_) {
       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) {
@@ skipping 134 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 12 matching lines @@
     run_loop.RunUntilIdle();
   }
 
 #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 64 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content