Video Capture: Allow suspension of individual devices.

content/browser/renderer_host/media/video_capture_manager_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.
 
 // Unit test for VideoCaptureManager.
 
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <stdint.h>
 
+#include <algorithm>
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.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/common/media/media_stream_options.h"
 #include "media/capture/video/fake_video_capture_device_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 namespace content {
 
+namespace {
+
+// Wraps FakeVideoCaptureDeviceFactory to allow mocking of the
+// VideoCaptureDevice MaybeSuspend() and Resume() methods. This is used to check
+// that devices are asked to suspend or resume at the correct times.
+class WrappedDeviceFactory : public media::FakeVideoCaptureDeviceFactory {
+ public:
+  class WrappedDevice : public media::VideoCaptureDevice {
+   public:
+    WrappedDevice(std::unique_ptr<media::VideoCaptureDevice> device,
+                  WrappedDeviceFactory* factory)
+        : device_(std::move(device)), factory_(factory) {
+      factory_->OnDeviceCreated(this);
+    }
+
+    ~WrappedDevice() final {
+      factory_->OnDeviceDestroyed(this);
+    }
+
+    void AllocateAndStart(const media::VideoCaptureParams& params,
+                          std::unique_ptr<Client> client) final {
+      device_->AllocateAndStart(params, std::move(client));
+    }
+
+    void RequestRefreshFrame() final {
+      device_->RequestRefreshFrame();
+    }
+
+    void MaybeSuspend() final {
+      factory_->WillSuspendDevice();
+      device_->MaybeSuspend();
+    }
+
+    void Resume() final {
+      factory_->WillResumeDevice();
+      device_->Resume();
+    }
+
+    void StopAndDeAllocate() final {
+      device_->StopAndDeAllocate();
+    }
+
+    void GetPhotoCapabilities(GetPhotoCapabilitiesCallback callback) final {
+      device_->GetPhotoCapabilities(std::move(callback));
+    }
+
+    void TakePhoto(TakePhotoCallback callback) final {
+      device_->TakePhoto(std::move(callback));
+    }
+
+   private:
+    const std::unique_ptr<media::VideoCaptureDevice> device_;
+    WrappedDeviceFactory* const factory_;
+
+    DISALLOW_COPY_AND_ASSIGN(WrappedDevice);
+  };
+
+  WrappedDeviceFactory() : FakeVideoCaptureDeviceFactory() {}
+  ~WrappedDeviceFactory() final {}
+
+  std::unique_ptr<media::VideoCaptureDevice> CreateDevice(
+      const media::VideoCaptureDeviceDescriptor& device_descriptor) final {
+    return base::MakeUnique<WrappedDevice>(
+        FakeVideoCaptureDeviceFactory::CreateDevice(device_descriptor), this);
+  }
+
+  MOCK_METHOD0(WillSuspendDevice, void());
+  MOCK_METHOD0(WillResumeDevice, void());
+
+ private:
+  void OnDeviceCreated(WrappedDevice* device) {
+    devices_.push_back(device);
+  }
+
+  void OnDeviceDestroyed(WrappedDevice* device) {
+    const auto it = std::find(devices_.begin(), devices_.end(), device);
+    CHECK(it != devices_.end());
+    devices_.erase(it);
+  }
+
+  std::vector<WrappedDevice*> devices_;
+
+  DISALLOW_COPY_AND_ASSIGN(WrappedDeviceFactory);
+};
+
 // Listener class used to track progress of VideoCaptureManager test.
 class MockMediaStreamProviderListener : public MediaStreamProviderListener {
  public:
   MockMediaStreamProviderListener() {}
   ~MockMediaStreamProviderListener() {}
 
   MOCK_METHOD2(Opened, void(MediaStreamType, int));
   MOCK_METHOD2(Closed, void(MediaStreamType, int));
   MOCK_METHOD2(Aborted, void(MediaStreamType, int));
 };  // class MockMediaStreamProviderListener
@@ skipping 12 matching lines @@
                         int buffer_id) override {}
   void OnBufferDestroyed(VideoCaptureControllerID id, int buffer_id) override {}
   void OnBufferReady(VideoCaptureControllerID id,
                      int buffer_id,
                      const scoped_refptr<media::VideoFrame>& frame) override {}
   void OnEnded(VideoCaptureControllerID id) override {}
 
   void OnGotControllerCallback(VideoCaptureControllerID) {}
 };
 
+}  // namespace
+
 // Test class
 class VideoCaptureManagerTest : public testing::Test {
  public:
   VideoCaptureManagerTest() : next_client_id_(1) {}
   ~VideoCaptureManagerTest() override {}
 
   void HandleEnumerationResult(
       const base::Closure& quit_closure,
       const media::VideoCaptureDeviceDescriptors& descriptors) {
     StreamDeviceInfoArray devices;
     for (const auto& descriptor : descriptors) {
       devices.emplace_back(MEDIA_DEVICE_VIDEO_CAPTURE,
                            descriptor.GetNameAndModel(), descriptor.device_id);
     }
     devices_ = std::move(devices);
     quit_closure.Run();
   }
 
  protected:
   void SetUp() override {
     listener_.reset(new MockMediaStreamProviderListener());
     message_loop_.reset(new base::MessageLoopForIO);
     ui_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
                                            message_loop_.get()));
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
     vcm_ = new VideoCaptureManager(
         std::unique_ptr<media::VideoCaptureDeviceFactory>(
-            new media::FakeVideoCaptureDeviceFactory()));
-    video_capture_device_factory_ =
-        static_cast<media::FakeVideoCaptureDeviceFactory*>(
-            vcm_->video_capture_device_factory());
+            new WrappedDeviceFactory()));
+    video_capture_device_factory_ = static_cast<WrappedDeviceFactory*>(
+        vcm_->video_capture_device_factory());
     const int32_t kNumberOfFakeDevices = 2;
     video_capture_device_factory_->set_number_of_devices(kNumberOfFakeDevices);
     vcm_->Register(listener_.get(), message_loop_->task_runner().get());
     frame_observer_.reset(new MockFrameObserver());
 
     base::RunLoop run_loop;
     vcm_->EnumerateDevices(
         base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult,
                    base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();
     ASSERT_GE(devices_.size(), 2u);
   }
 
   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_FALSE(controller);
     }
-    quit_closure.Run();
   }
 
   VideoCaptureControllerID StartClient(int session_id, bool expect_success) {
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
 
     VideoCaptureControllerID client_id(next_client_id_++);
-    base::RunLoop run_loop;
     vcm_->StartCaptureForClient(
         session_id,
         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();
+    base::RunLoop().RunUntilIdle();
     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(), false);
     controllers_.erase(client_id);
   }
 
   void ResumeClient(int session_id, int client_id) {
     ASSERT_EQ(1u, controllers_.count(client_id));
     media::VideoCaptureParams params;
     params.requested_format = media::VideoCaptureFormat(
         gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420);
-
     vcm_->ResumeCaptureForClient(
         session_id,
         params,
         controllers_[client_id],
         client_id,
         frame_observer_.get());
+    // Allow possible VideoCaptureDevice::Resume() task to run.
+    base::RunLoop().RunUntilIdle();
   }
 
   void PauseClient(VideoCaptureControllerID client_id) {
     ASSERT_EQ(1u, controllers_.count(client_id));
     vcm_->PauseCaptureForClient(controllers_[client_id], client_id,
-                               frame_observer_.get());
+                                frame_observer_.get());
+    // Allow possible VideoCaptureDevice::MaybeSuspend() task to run.
+    base::RunLoop().RunUntilIdle();
   }
 
 #if defined(OS_ANDROID)
   void ApplicationStateChange(base::android::ApplicationState state) {
     vcm_->OnApplicationStateChange(state);
   }
 #endif
 
   int next_client_id_;
   std::map<VideoCaptureControllerID, VideoCaptureController*> controllers_;
   scoped_refptr<VideoCaptureManager> vcm_;
   std::unique_ptr<MockMediaStreamProviderListener> listener_;
   std::unique_ptr<base::MessageLoop> message_loop_;
   std::unique_ptr<BrowserThreadImpl> ui_thread_;
   std::unique_ptr<BrowserThreadImpl> io_thread_;
   std::unique_ptr<MockFrameObserver> frame_observer_;
-  media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
+  WrappedDeviceFactory* video_capture_device_factory_;
   StreamDeviceInfoArray devices_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManagerTest);
 };
 
 // Test cases
 
 // Try to open, start, stop and close a device.
 TEST_F(VideoCaptureManagerTest, CreateAndClose) {
@@ skipping 265 matching lines @@
   // Close will stop the running device, an assert will be triggered in
   // VideoCaptureManager destructor otherwise.
   vcm_->Close(video_session_id);
   StopClient(client_id);
 
   // Wait to check callbacks before removing the listener
   base::RunLoop().RunUntilIdle();
   vcm_->Unregister();
 }
 
-// Try to open, start, pause and resume a device.
+// Try to open, start, pause and resume a device. Confirm the device is
+// paused/resumed at the correct times in both single-client and multiple-client
+// scenarios.
 TEST_F(VideoCaptureManagerTest, PauseAndResumeClient) {
-  InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
-  EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  int video_session_id = vcm_->Open(devices_.front());
-  VideoCaptureControllerID client_id = StartClient(video_session_id, true);
+  const int video_session_id = vcm_->Open(devices_.front());
+  const VideoCaptureControllerID client_id =
+      StartClient(video_session_id, true);
 
-  // Resume client a second time should cause no problem.
+  // Test pause/resume when only one client is present.
+  EXPECT_CALL(*video_capture_device_factory_, WillSuspendDevice()).Times(1);
   PauseClient(client_id);
+  EXPECT_CALL(*video_capture_device_factory_, WillResumeDevice()).Times(1);
   ResumeClient(video_session_id, client_id);
+
+  // Attempting to resume the client a second time should not cause any calls to
+  // VideoCaptureDevice::Resume().
+  ResumeClient(video_session_id, client_id);
+
+  // Add a second client that is never paused, then pause/resume the first
+  // client, and no calls to VideoCaptureDevice::MaybeSuspend() or Resume() are
+  // made.
+  const VideoCaptureControllerID client_id2 =
+      StartClient(video_session_id, true);
+  PauseClient(client_id);
   ResumeClient(video_session_id, client_id);
 
   StopClient(client_id);
+  StopClient(client_id2);
+
+  EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   vcm_->Close(video_session_id);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->Unregister();
 }
 
 #if defined(OS_ANDROID)
 // Try to open, start, pause and resume a device.
 TEST_F(VideoCaptureManagerTest, PauseAndResumeDevice) {
@@ skipping 23 matching lines @@
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->Unregister();
 }
 #endif
 
 // TODO(mcasas): Add a test to check consolidation of the supported formats
 // provided by the device when http://crbug.com/323913 is closed.
 
 }  // namespace content