[Mojo Video Capture] Split interface BuildableVideoCaptureDevice

content/browser/renderer_host/media/video_capture_controller_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 "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
+#include "content/browser/renderer_host/media/mock_video_capture_provider.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/video_capture_gpu_jpeg_decoder.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
 #include "media/capture/video/video_capture_buffer_pool_impl.h"
 #include "media/capture/video/video_capture_buffer_tracker_factory_impl.h"
@@ skipping 74 matching lines @@
         base::Bind(base::IgnoreResult(&VideoCaptureController::RemoveClient),
                    base::Unretained(controller_), id, this));
   }
 
   VideoCaptureController* controller_;
   media::VideoPixelFormat expected_pixel_format_ = media::PIXEL_FORMAT_I420;
   double resource_utilization_;
   bool enable_auto_return_buffer_on_buffer_ready_ = true;
 };
 
-class MockConsumerFeedbackObserver
-    : public media::VideoFrameConsumerFeedbackObserver {
- public:
-  MOCK_METHOD2(OnUtilizationReport,
-               void(int frame_feedback_id, double utilization));
-};
-
-class MockBuildableVideoCaptureDevice : public BuildableVideoCaptureDevice {
- public:
-  void CreateAndStartDeviceAsync(
-      VideoCaptureController* controller,
-      const media::VideoCaptureParams& params,
-      BuildableVideoCaptureDevice::Callbacks* callbacks,
-      base::OnceClosure done_cb) override {}
-  void ReleaseDeviceAsync(VideoCaptureController* controller,
-                          base::OnceClosure done_cb) override {}
-  bool IsDeviceAlive() const override { return false; }
-  void GetPhotoCapabilities(
-      media::VideoCaptureDevice::GetPhotoCapabilitiesCallback callback)
-      const override {}
-  void SetPhotoOptions(
-      media::mojom::PhotoSettingsPtr settings,
-      media::VideoCaptureDevice::SetPhotoOptionsCallback callback) override {}
-  void TakePhoto(
-      media::VideoCaptureDevice::TakePhotoCallback callback) override {}
-  void MaybeSuspendDevice() override {}
-  void ResumeDevice() override {}
-  void RequestRefreshFrame() override {}
-  void SetDesktopCaptureWindowIdAsync(gfx::NativeViewId window_id,
-                                      base::OnceClosure done_cb) override {}
-};
-
 // Test fixture for testing a unit consisting of an instance of
 // VideoCaptureController connected to an instance of VideoCaptureDeviceClient,
 // an instance of VideoCaptureBufferPoolImpl, as well as related threading glue
 // that replicates how it is used in production.
 class VideoCaptureControllerTest
     : public testing::Test,
       public testing::WithParamInterface<media::VideoPixelFormat> {
  public:
   VideoCaptureControllerTest()
       : arbitrary_format_(gfx::Size(320, 240), 30, media::PIXEL_FORMAT_I420),
         arbitrary_route_id_(0x99),
         arbitrary_session_id_(100) {}
   ~VideoCaptureControllerTest() override {}
 
  protected:
   static const int kPoolSize = 3;
 
   void SetUp() override {
     const std::string arbitrary_device_id = "arbitrary_device_id";
     const MediaStreamType arbitrary_stream_type =
         content::MEDIA_DEVICE_VIDEO_CAPTURE;
     const media::VideoCaptureParams arbitrary_params;
-    auto buildable_device = base::MakeUnique<MockBuildableVideoCaptureDevice>();
+    auto device_launcher = base::MakeUnique<MockVideoCaptureDeviceLauncher>();
     controller_ = new VideoCaptureController(
         arbitrary_device_id, arbitrary_stream_type, arbitrary_params,
-        std::move(buildable_device));
+        std::move(device_launcher));
     InitializeNewDeviceClientAndBufferPoolInstances();
-    auto consumer_feedback_observer =
-        base::MakeUnique<MockConsumerFeedbackObserver>();
-    mock_consumer_feedback_observer_ = consumer_feedback_observer.get();
-    controller_->SetConsumerFeedbackObserver(
-        std::move(consumer_feedback_observer));
+    auto mock_launched_device =
+        base::MakeUnique<MockLaunchedVideoCaptureDevice>();
+    mock_launched_device_ = mock_launched_device.get();
+    controller_->OnDeviceLaunched(std::move(mock_launched_device));
     client_a_.reset(
         new MockVideoCaptureControllerEventHandler(controller_.get()));
     client_b_.reset(
         new MockVideoCaptureControllerEventHandler(controller_.get()));
   }
 
   void TearDown() override { base::RunLoop().RunUntilIdle(); }
 
   void InitializeNewDeviceClientAndBufferPoolInstances() {
     buffer_pool_ = new media::VideoCaptureBufferPoolImpl(
@@ skipping 23 matching lines @@
         format, rotation, base::TimeTicks(), base::TimeDelta(),
         frame_feedback_id);
   }
 
   TestBrowserThreadBundle bundle_;
   scoped_refptr<media::VideoCaptureBufferPool> buffer_pool_;
   std::unique_ptr<MockVideoCaptureControllerEventHandler> client_a_;
   std::unique_ptr<MockVideoCaptureControllerEventHandler> client_b_;
   scoped_refptr<VideoCaptureController> controller_;
   std::unique_ptr<media::VideoCaptureDevice::Client> device_client_;
-  MockConsumerFeedbackObserver* mock_consumer_feedback_observer_;
+  MockLaunchedVideoCaptureDevice* mock_launched_device_;
   const float arbitrary_frame_rate_ = 10.0f;
   const base::TimeTicks arbitrary_reference_time_ = base::TimeTicks();
   const base::TimeDelta arbitrary_timestamp_ = base::TimeDelta();
   const media::VideoCaptureFormat arbitrary_format_;
   const VideoCaptureControllerID arbitrary_route_id_;
   const media::VideoCaptureSessionId arbitrary_session_id_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureControllerTest);
 };
@@ skipping 137 matching lines @@
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2, _));
     EXPECT_CALL(*client_a_,
                 DoBufferReady(client_a_route_2, device_format.frame_size));
   }
   client_a_->resource_utilization_ = 0.5;
   client_b_->resource_utilization_ = -1.0;
   // Expect VideoCaptureController to call the load observer with a
   // resource utilization of 0.5 (the largest of all reported values).
-  EXPECT_CALL(*mock_consumer_feedback_observer_,
+  EXPECT_CALL(*mock_launched_device_,
               OnUtilizationReport(arbitrary_frame_feedback_id, 0.5));
 
   device_client_->OnIncomingCapturedBuffer(std::move(buffer), device_format,
                                            arbitrary_reference_time_,
                                            arbitrary_timestamp_);
 
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
-  Mock::VerifyAndClearExpectations(mock_consumer_feedback_observer_);
+  Mock::VerifyAndClearExpectations(mock_launched_device_);
 
   // Second buffer which ought to use the same shared memory buffer. In this
   // case pretend that the Buffer pointer is held by the device for a long
   // delay. This shouldn't affect anything.
   const int arbitrary_frame_feedback_id_2 = 102;
   media::VideoCaptureDevice::Client::Buffer buffer2 =
       device_client_->ReserveOutputBuffer(
           device_format.frame_size, device_format.pixel_format,
           device_format.pixel_storage, arbitrary_frame_feedback_id_2);
   ASSERT_TRUE(buffer2.is_valid());
   auto buffer2_access = buffer2.handle_provider->GetHandleForInProcessAccess();
   memset(buffer2_access->data(), buffer_no++, buffer2_access->mapped_size());
   client_a_->resource_utilization_ = 0.5;
   client_b_->resource_utilization_ = 3.14;
   // Expect VideoCaptureController to call the load observer with a
   // resource utilization of 3.14 (the largest of all reported values).
-  EXPECT_CALL(*mock_consumer_feedback_observer_,
+  EXPECT_CALL(*mock_launched_device_,
               OnUtilizationReport(arbitrary_frame_feedback_id_2, 3.14));
 
   device_client_->OnIncomingCapturedBuffer(std::move(buffer2), device_format,
                                            arbitrary_reference_time_,
                                            arbitrary_timestamp_);
 
   // The buffer should be delivered to the clients in any order.
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_1, _));
     EXPECT_CALL(*client_a_,
                 DoBufferReady(client_a_route_1, device_format.frame_size));
   }
   {
     InSequence s;
     EXPECT_CALL(*client_b_, DoBufferCreated(client_b_route_1, _));
     EXPECT_CALL(*client_b_,
                 DoBufferReady(client_b_route_1, device_format.frame_size));
   }
   {
     InSequence s;
     EXPECT_CALL(*client_a_, DoBufferCreated(client_a_route_2, _));
     EXPECT_CALL(*client_a_,
                 DoBufferReady(client_a_route_2, device_format.frame_size));
   }
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(client_a_.get());
   Mock::VerifyAndClearExpectations(client_b_.get());
-  Mock::VerifyAndClearExpectations(mock_consumer_feedback_observer_);
+  Mock::VerifyAndClearExpectations(mock_launched_device_);
 
   // Add a fourth client now that some buffers have come through.
   controller_->AddClient(client_b_route_2, client_b_.get(), 1, session_1);
   Mock::VerifyAndClearExpectations(client_b_.get());
 
   // Third, fourth, and fifth buffers. Pretend they all arrive at the same time.
   for (int i = 0; i < kPoolSize; i++) {
     const int arbitrary_frame_feedback_id = 200 + i;
     media::VideoCaptureDevice::Client::Buffer buffer =
         device_client_->ReserveOutputBuffer(
@@ skipping 196 matching lines @@
     const int stub_frame_feedback_id = frame_index;
     const float stub_consumer_utilization =
         static_cast<float>(frame_index) / kTestFrameSequenceLength;
 
     client_a_->resource_utilization_ = stub_consumer_utilization;
 
     EXPECT_CALL(*client_a_,
                 DoBufferReady(route_id, arbitrary_format.frame_size))
         .Times(1);
     EXPECT_CALL(
-        *mock_consumer_feedback_observer_,
+        *mock_launched_device_,
         OnUtilizationReport(stub_frame_feedback_id, stub_consumer_utilization))
         .Times(1);
 
     // Device prepares and pushes a frame.
     // For the first half of the frames we exercise ReserveOutputBuffer() while
     // for the second half we exercise ResurrectLastOutputBuffer().
     // The frame is expected to arrive at |client_a_|.DoBufferReady(), which
     // automatically notifies |controller_| that it has finished consuming it.
     media::VideoCaptureDevice::Client::Buffer buffer;
     if (frame_index < kTestFrameSequenceLength / 2) {
       buffer = device_client_->ReserveOutputBuffer(
           arbitrary_format.frame_size, arbitrary_format.pixel_format,
           arbitrary_format.pixel_storage, stub_frame_feedback_id);
     } else {
       buffer = device_client_->ResurrectLastOutputBuffer(
           arbitrary_format.frame_size, arbitrary_format.pixel_format,
           arbitrary_format.pixel_storage, stub_frame_feedback_id);
     }
     ASSERT_TRUE(buffer.is_valid());
     device_client_->OnIncomingCapturedBuffer(
         std::move(buffer), arbitrary_format, arbitrary_reference_time_,
         arbitrary_timestamp_);
 
     base::RunLoop().RunUntilIdle();
     Mock::VerifyAndClearExpectations(client_a_.get());
-    Mock::VerifyAndClearExpectations(mock_consumer_feedback_observer_);
+    Mock::VerifyAndClearExpectations(mock_launched_device_);
   }
 }
 
 TEST_F(VideoCaptureControllerTest,
        DeviceClientIsReleasedBeforeAnyBufferWasShared) {
   // Register |client_a_| at |controller_|.
   media::VideoCaptureParams requested_params;
   requested_params.requested_format = arbitrary_format_;
   controller_->AddClient(arbitrary_route_id_, client_a_.get(),
                          arbitrary_session_id_, requested_params);
@@ skipping 170 matching lines @@
     EXPECT_CALL(*client_b_, OnStarted(_));
     device_client_->OnStarted();
 
     // VideoCaptureController will take care of the OnStarted event for the
     // clients who join later.
     EXPECT_CALL(*client_a_, OnStarted(_));
     controller_->AddClient(client_a_route_2, client_a_.get(), 200, session_200);
   }
 }
 }  // namespace content