From Video Capture, abolish OnFrameInfo and enable resolution changes

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 87 matching lines @@
  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));
-  MOCK_METHOD3(OnBufferFilled,
-               void(int device_id, int buffer_id, base::Time timestamp));
+  MOCK_METHOD2(OnBufferFreed,
+               void(int device_id, int buffer_id));
+  MOCK_METHOD4(OnBufferFilled,
+               void(int device_id, int buffer_id, base::Time timestamp,
+                    const media::VideoCaptureFormat& format));
   MOCK_METHOD2(OnStateChanged, void(int device_id, VideoCaptureState state));
-  MOCK_METHOD1(OnDeviceInfo, void(int device_id));
 
   // Use class DumpVideo to write I420 video to file.
   void SetDumpVideo(bool enable) {
     dump_video_ = enable;
   }
 
-  void SetReturnReceviedDibs(bool 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);
       handle = GetReceivedDib();
     }
@@ skipping 20 matching lines @@
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   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_StateChanged, OnStateChangedDispatch)
-      IPC_MESSAGE_HANDLER(VideoCaptureMsg_DeviceInfo, OnDeviceInfoDispatch)
       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.
   void OnNewBufferCreatedDispatch(int device_id,
                                   base::SharedMemoryHandle handle,
                                   uint32 length,
                                   int buffer_id) {
     OnNewBufferCreated(device_id, handle, length, buffer_id);
     base::SharedMemory* dib = new base::SharedMemory(handle, false);
     dib->Map(length);
     filled_dib_[buffer_id] = dib;
   }
 
-  void OnBufferFilledDispatch(int device_id, int buffer_id,
-                              base::Time timestamp) {
+  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,
+                              base::Time timestamp,
+                              const media::VideoCaptureFormat& frame_format) {
+    base::SharedMemory* dib = filled_dib_[buffer_id];
+    ASSERT_TRUE(dib != NULL);
     if (dump_video_) {
-      base::SharedMemory* dib = filled_dib_[buffer_id];
-      ASSERT_TRUE(dib != NULL);
+      if (!format_.IsValid()) {
+        dumper_.StartDump(frame_format.width, frame_format.height);
+        format_ = frame_format;
+      }
+      ASSERT_EQ(format_.width, frame_format.width)
+          << "Dump format does not handle variable resolution.";
+      ASSERT_EQ(format_.height, frame_format.height)
+          << "Dump format does not handle variable resolution.";;
       dumper_.NewVideoFrame(dib->memory());
     }
 
-    OnBufferFilled(device_id, buffer_id, timestamp);
+    OnBufferFilled(device_id, buffer_id, timestamp, frame_format);
     if (return_buffers_) {
       VideoCaptureHost::OnReceiveEmptyBuffer(device_id, buffer_id);
     }
   }
 
   void OnStateChangedDispatch(int device_id, VideoCaptureState state) {
     OnStateChanged(device_id, state);
   }
 
-  void OnDeviceInfoDispatch(int device_id,
-                            media::VideoCaptureParams params) {
-    if (dump_video_) {
-      dumper_.StartDump(params.width, params.height);
-    }
-    OnDeviceInfo(device_id);
-  }
-
   std::map<int, base::SharedMemory*> filled_dib_;
   bool return_buffers_;
   bool dump_video_;
+  media::VideoCaptureFormat format_;
   DumpVideo dumper_;
 };
 
 ACTION_P2(ExitMessageLoop, message_loop, quit_closure) {
   message_loop->PostTask(FROM_HERE, quit_closure);
 }
 
 // This is an integration test of VideoCaptureHost in conjunction with
 // MediaStreamManager, VideoCaptureManager, VideoCaptureController, and
 // VideoCaptureDevice.
@@ skipping 94 matching lines @@
   void CloseSession() {
     if (opened_device_label_.empty())
       return;
     media_stream_manager_->StopGeneratedStream(opened_device_label_);
     opened_device_label_.clear();
     opened_session_id_ = kInvalidMediaCaptureSessionId;
   }
 
  protected:
   void StartCapture() {
-    InSequence s;
-    // 1. First - get info about the new resolution
-    EXPECT_CALL(*host_, OnDeviceInfo(kDeviceId));
-
-    // 2. Change state to started
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STARTED));
-
-    // 3. Newly created buffers will arrive.
     EXPECT_CALL(*host_, OnNewBufferCreated(kDeviceId, _, _, _))
         .Times(AnyNumber()).WillRepeatedly(Return());
 
-    // 4. First filled buffer will arrive.
     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.width = 352;
     params.height = 288;
     params.frame_rate = 30;
     params.session_id = opened_session_id_;
     host_->OnStartCapture(kDeviceId, params);
     run_loop.Run();
@@ skipping 11 matching lines @@
     params.frame_rate = 30;
     params.session_id = opened_session_id_;
     host_->OnStartCapture(kDeviceId, params);
     host_->OnStopCapture(kDeviceId);
     run_loop.RunUntilIdle();
   }
 
 #ifdef DUMP_VIDEO
   void CaptureAndDumpVideo(int width, int height, int frame_rate) {
     InSequence s;
-    // 1. First - get info about the new resolution
-    EXPECT_CALL(*host_, OnDeviceInfo(kDeviceId));
+    EXPECT_CALL(*host_.get(), OnNewBufferCreated(kDeviceId, _, _, _))
+        .Times(AnyNumber()).WillRepeatedly(Return());
 
-    // 2. Change state to started
-    EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STARTED));
-
-    // 3. First filled buffer will arrive.
     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.width = width;
     params.height = height;
     params.frame_rate = frame_rate;
     params.session_id = opened_session_id_;
     host_->SetDumpVideo(true);
     host_->OnStartCapture(kDeviceId, params);
     run_loop.Run();
   }
 #endif
 
   void StopCapture() {
     base::RunLoop run_loop;
     EXPECT_CALL(*host_, OnStateChanged(kDeviceId, VIDEO_CAPTURE_STATE_STOPPED))
         .WillOnce(ExitMessageLoop(message_loop_, run_loop.QuitClosure()));
 
     host_->OnStopCapture(kDeviceId);
-    host_->SetReturnReceviedDibs(true);
+    host_->SetReturnReceivedDibs(true);
     host_->ReturnReceivedDibs(kDeviceId);
 
     run_loop.Run();
 
-    host_->SetReturnReceviedDibs(false);
+    host_->SetReturnReceivedDibs(false);
     // Expect the VideoCaptureDevice has been stopped
     EXPECT_EQ(0u, host_->entries_.size());
   }
 
   void NotifyPacketReady() {
     base::RunLoop run_loop;
-    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _))
+    EXPECT_CALL(*host_, OnBufferFilled(kDeviceId, _, _, _))
         .Times(AnyNumber()).WillOnce(ExitMessageLoop(
             message_loop_, run_loop.QuitClosure()))
         .RetiresOnSaturation();
     run_loop.Run();
   }
 
   void ReturnReceivedPackets() {
     host_->ReturnReceivedDibs(kDeviceId);
   }
 
@@ skipping 62 matching lines @@
 #ifdef DUMP_VIDEO
 TEST_F(VideoCaptureHostTest, CaptureAndDumpVideoVga) {
   CaptureAndDumpVideo(640, 480, 30);
 }
 TEST_F(VideoCaptureHostTest, CaptureAndDump720P) {
   CaptureAndDumpVideo(1280, 720, 30);
 }
 #endif
 
 }  // namespace content