1 files changed, 90 insertions, 46 deletions

diff --git a/chromium/content/browser/renderer_host/media/video_capture_manager_unittest.cc b/chromium/content/browser/renderer_host/media/video_capture_manager_unittest.cc
index 83c064655ed..34172d78cb4 100644
--- a/chromium/content/browser/renderer_host/media/video_capture_manager_unittest.cc
+++ b/chromium/content/browser/renderer_host/media/video_capture_manager_unittest.cc
@@ -10,8 +10,10 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
+#include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 #include "media/video/capture/video_capture_device.h"
@@ -40,30 +42,33 @@ class MockMediaStreamProviderListener : public MediaStreamProviderListener {
                            MediaStreamProviderError));
 };  // class MockMediaStreamProviderListener
 
-// Needed as an input argument to Start().
-class MockFrameObserver : public media::VideoCaptureDevice::EventHandler {
+// Needed as an input argument to StartCaptureForClient().
+class MockFrameObserver : public VideoCaptureControllerEventHandler {
  public:
-  virtual scoped_refptr<media::VideoFrame> ReserveOutputBuffer() OVERRIDE {
-    return NULL;
-  }
-  virtual void OnError() OVERRIDE {}
+  MOCK_METHOD1(OnError, void(const VideoCaptureControllerID& id));
+
+  virtual void OnBufferCreated(const VideoCaptureControllerID& id,
+                               base::SharedMemoryHandle handle,
+                               int length, int buffer_id) OVERRIDE {};
+  virtual void OnBufferReady(const VideoCaptureControllerID& id,
+                             int buffer_id,
+                             base::Time timestamp) OVERRIDE {};
   virtual void OnFrameInfo(
-      const media::VideoCaptureCapability& info) OVERRIDE {}
-  virtual void OnIncomingCapturedFrame(const uint8* data,
-                                       int length,
-                                       base::Time timestamp,
-                                       int rotation,
-                                       bool flip_vert,
-                                       bool flip_horiz) OVERRIDE {}
-  virtual void OnIncomingCapturedVideoFrame(
-      const scoped_refptr<media::VideoFrame>& frame,
-      base::Time timestamp) OVERRIDE {}
+      const VideoCaptureControllerID& id,
+      const media::VideoCaptureCapability& format) OVERRIDE {};
+  virtual void OnFrameInfoChanged(const VideoCaptureControllerID& id,
+                                  int width,
+                                  int height,
+                                  int frame_rate) OVERRIDE {};
+  virtual void OnEnded(const VideoCaptureControllerID& id) OVERRIDE {};
+
+  void OnGotControllerCallback(VideoCaptureControllerID) {}
 };
 
 // Test class
 class VideoCaptureManagerTest : public testing::Test {
  public:
-  VideoCaptureManagerTest() {}
+  VideoCaptureManagerTest() : next_client_id_(1) {}
   virtual ~VideoCaptureManagerTest() {}
 
  protected:
@@ -80,6 +85,48 @@ class VideoCaptureManagerTest : public testing::Test {
 
   virtual void TearDown() OVERRIDE {}
 
+  void OnGotControllerCallback(
+      VideoCaptureControllerID id,
+      base::Closure quit_closure,
+      bool expect_success,
+      const base::WeakPtr<VideoCaptureController>& controller) {
+    if (expect_success) {
+      ASSERT_TRUE(controller);
+      ASSERT_TRUE(0 == controllers_.count(id));
+      controllers_[id] = controller.get();
+    } else {
+      ASSERT_TRUE(NULL == controller);
+    }
+    quit_closure.Run();
+  }
+
+  VideoCaptureControllerID StartClient(int session_id, bool expect_success) {
+    media::VideoCaptureParams params;
+    params.session_id = session_id;
+    params.width = 320;
+    params.height = 240;
+    params.frame_rate = 30;
+
+    VideoCaptureControllerID client_id(next_client_id_++);
+    base::RunLoop run_loop;
+    vcm_->StartCaptureForClient(
+        params, base::kNullProcessHandle, client_id, frame_observer_.get(),
+        base::Bind(&VideoCaptureManagerTest::OnGotControllerCallback,
+                   base::Unretained(this), client_id, run_loop.QuitClosure(),
+                   expect_success));
+    run_loop.Run();
+    return client_id;
+  }
+
+  void StopClient(VideoCaptureControllerID client_id) {
+    ASSERT_TRUE(1 == controllers_.count(client_id));
+    vcm_->StopCaptureForClient(controllers_[client_id], client_id,
+                               frame_observer_.get());
+    controllers_.erase(client_id);
+  }
+
+  int next_client_id_;
+  std::map<VideoCaptureControllerID, VideoCaptureController*> controllers_;
   scoped_refptr<VideoCaptureManager> vcm_;
   scoped_ptr<MockMediaStreamProviderListener> listener_;
   scoped_ptr<base::MessageLoop> message_loop_;
@@ -108,15 +155,9 @@ TEST_F(VideoCaptureManagerTest, CreateAndClose) {
   message_loop_->RunUntilIdle();
 
   int video_session_id = vcm_->Open(devices.front());
+  VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
-  media::VideoCaptureParams capture_params;
-  capture_params.session_id = video_session_id;
-  capture_params.width = 320;
-  capture_params.height = 240;
-  capture_params.frame_per_second = 30;
-  vcm_->Start(capture_params, frame_observer_.get());
-
-  vcm_->Stop(video_session_id, base::Closure());
+  StopClient(client_id);
   vcm_->Close(video_session_id);
 
   // Wait to check callbacks before removing the listener.
@@ -190,9 +231,9 @@ TEST_F(VideoCaptureManagerTest, OpenNotExisting) {
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .Times(1).WillOnce(SaveArg<1>(&devices));
-  EXPECT_CALL(*listener_, Error(MEDIA_DEVICE_VIDEO_CAPTURE,
-                                _, kDeviceNotAvailable))
-      .Times(1);
+  EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(1);
+  EXPECT_CALL(*frame_observer_, OnError(_)).Times(1);
+  EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(1);
 
   vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
 
@@ -204,11 +245,15 @@ TEST_F(VideoCaptureManagerTest, OpenNotExisting) {
   std::string device_id("id_doesnt_exist");
   StreamDeviceInfo dummy_device(stream_type, device_name, device_id, false);
 
-  // This should fail with error code 'kDeviceNotAvailable'.
-  vcm_->Open(dummy_device);
+  // This should fail with an error to the controller.
+  int session_id = vcm_->Open(dummy_device);
+  VideoCaptureControllerID client_id = StartClient(session_id, true);
+  message_loop_->RunUntilIdle();
 
-  // Wait to check callbacks before removing the listener.
+  StopClient(client_id);
+  vcm_->Close(session_id);
   message_loop_->RunUntilIdle();
+
   vcm_->Unregister();
 }
 
@@ -218,17 +263,21 @@ TEST_F(VideoCaptureManagerTest, StartUsingId) {
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(1);
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(1);
 
-  media::VideoCaptureParams capture_params;
-  capture_params.session_id = VideoCaptureManager::kStartOpenSessionId;
-  capture_params.width = 320;
-  capture_params.height = 240;
-  capture_params.frame_per_second = 30;
-
   // Start shall trigger the Open callback.
-  vcm_->Start(capture_params, frame_observer_.get());
+  VideoCaptureControllerID client_id = StartClient(
+      VideoCaptureManager::kStartOpenSessionId, true);
 
   // Stop shall trigger the Close callback
-  vcm_->Stop(VideoCaptureManager::kStartOpenSessionId, base::Closure());
+  StopClient(client_id);
+
+  // Wait to check callbacks before removing the listener.
+  message_loop_->RunUntilIdle();
+  vcm_->Unregister();
+}
+
+// Start a device without calling Open, using a non-magic ID.
+TEST_F(VideoCaptureManagerTest, StartInvalidSession) {
+  StartClient(22, false);
 
   // Wait to check callbacks before removing the listener.
   message_loop_->RunUntilIdle();
@@ -252,17 +301,12 @@ TEST_F(VideoCaptureManagerTest, CloseWithoutStop) {
 
   int video_session_id = vcm_->Open(devices.front());
 
-  media::VideoCaptureParams capture_params;
-  capture_params.session_id = video_session_id;
-  capture_params.width = 320;
-  capture_params.height = 240;
-  capture_params.frame_per_second = 30;
-  vcm_->Start(capture_params, frame_observer_.get());
+  VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
   // Close will stop the running device, an assert will be triggered in
   // VideoCaptureManager destructor otherwise.
   vcm_->Close(video_session_id);
-  vcm_->Stop(video_session_id, base::Closure());
+  StopClient(client_id);
 
   // Wait to check callbacks before removing the listener
   message_loop_->RunUntilIdle();