[Mojo Video Capture] Introduce abstraction 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>
@@ skipping 103 matching lines @@
   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,
+                                 DeviceBuildContext context) 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 {
-    controller_.reset(new VideoCaptureController());
+    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>();
+    controller_ = new VideoCaptureController(
+        arbitrary_device_id, arbitrary_stream_type, arbitrary_params,
+        std::move(buildable_device));
     InitializeNewDeviceClientAndBufferPoolInstances();
     auto consumer_feedback_observer =
         base::MakeUnique<MockConsumerFeedbackObserver>();
     mock_consumer_feedback_observer_ = consumer_feedback_observer.get();
     controller_->SetConsumerFeedbackObserver(
         std::move(consumer_feedback_observer));
     client_a_.reset(
         new MockVideoCaptureControllerEventHandler(controller_.get()));
     client_b_.reset(
         new MockVideoCaptureControllerEventHandler(controller_.get()));
@@ skipping 26 matching lines @@
         media::VideoFrame::AllocationSize(stub_frame->format(),
                                           stub_frame->coded_size()),
         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_;
-  std::unique_ptr<VideoCaptureController> controller_;
+  scoped_refptr<VideoCaptureController> controller_;
   std::unique_ptr<media::VideoCaptureDevice::Client> device_client_;
   MockConsumerFeedbackObserver* mock_consumer_feedback_observer_;
   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:
@@ skipping 629 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