[Mojo Video Capture] Adapt video_capture service to refactored video capture stack

services/video_capture/test/mock_device_unittest.cc

 // Copyright 2016 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 "base/run_loop.h"
 #include "services/video_capture/test/mock_device_test.h"
 
 using testing::_;
 using testing::Invoke;
 
 namespace video_capture {
 
 // This alias ensures test output is easily attributed to this service's tests.
 // TODO(rockot/chfremer): Consider just renaming the type.
 using MockVideoCaptureDeviceTest = MockDeviceTest;
 
 // Tests that the service stops the capture device when the client closes the
 // connection to the device proxy.
-TEST_F(MockVideoCaptureDeviceTest,
-       DISABLED_DeviceIsStoppedWhenDiscardingDeviceProxy) {
+TEST_F(MockVideoCaptureDeviceTest, DeviceIsStoppedWhenDiscardingDeviceProxy) {
   base::RunLoop wait_loop;
 
-  // The mock device must hold on to the device client that is passed to it.
-  std::unique_ptr<media::VideoCaptureDevice::Client> device_client;
-  EXPECT_CALL(mock_device_, DoAllocateAndStart(_, _))
-      .WillOnce(Invoke([&device_client](
-          const media::VideoCaptureParams& params,
-          std::unique_ptr<media::VideoCaptureDevice::Client>* client) {
-        device_client.reset(client->release());
-      }));
-  EXPECT_CALL(mock_device_, StopAndDeAllocate())
+  EXPECT_CALL(mock_device_, DoStopAndDeAllocate())
       .WillOnce(Invoke([&wait_loop]() { wait_loop.Quit(); }));
 
   device_proxy_->Start(requested_settings_, std::move(mock_receiver_proxy_));
   device_proxy_.reset();
 
   wait_loop.Run();
 }
 
 // Tests that the service stops the capture device when the client closes the
 // connection to the client proxy it provided to the service.
-TEST_F(MockVideoCaptureDeviceTest,
-       DISABLED_DeviceIsStoppedWhenDiscardingDeviceClient) {
+TEST_F(MockVideoCaptureDeviceTest, DeviceIsStoppedWhenDiscardingDeviceClient) {
   base::RunLoop wait_loop;
 
-  // The mock device must hold on to the device client that is passed to it.
-  std::unique_ptr<media::VideoCaptureDevice::Client> device_client;
-  EXPECT_CALL(mock_device_, DoAllocateAndStart(_, _))
-      .WillOnce(Invoke([&device_client](
-          const media::VideoCaptureParams& params,
-          std::unique_ptr<media::VideoCaptureDevice::Client>* client) {
-        device_client.reset(client->release());
-      }));
-  EXPECT_CALL(mock_device_, StopAndDeAllocate())
+  EXPECT_CALL(mock_device_, DoStopAndDeAllocate())
       .WillOnce(Invoke([&wait_loop]() { wait_loop.Quit(); }));
 
   device_proxy_->Start(requested_settings_, std::move(mock_receiver_proxy_));
   mock_receiver_.reset();
 
   wait_loop.Run();
 }
 
+// Tests that a utilization reported to a video_capture.mojom.Device via
+// OnReceiverReportingUtilization() arrives at the corresponding
+// media::VideoCaptureDevice.
+TEST_F(MockVideoCaptureDeviceTest, ReceiverUtilizationIsForwardedToDevice) {
+  base::RunLoop run_loop;
+  const media::VideoCaptureFormat stub_frame_format(gfx::Size(320, 200), 25.0f,
+                                                    media::PIXEL_FORMAT_I420);
+  const int arbitrary_rotation = 0;
+  const int arbitrary_frame_feedback_id = 654;
+  const double arbitrary_utilization = 0.12345;
+
+  EXPECT_CALL(*mock_receiver_, DoOnFrameReadyInBuffer(_, _, _, _))
+      .WillOnce(Invoke([this, &arbitrary_utilization](
+                           int32_t buffer_id, int32_t frame_feedback_id,
+                           mojom::ScopedAccessPermissionPtr*,
+                           media::mojom::VideoFrameInfoPtr*) {
+        device_proxy_->OnReceiverReportingUtilization(frame_feedback_id,
+                                                      arbitrary_utilization);
+      }));
+
+  EXPECT_CALL(mock_device_, OnUtilizationReport(arbitrary_frame_feedback_id,
+                                                arbitrary_utilization))
+      .Times(1);
+
+  device_proxy_->Start(requested_settings_, std::move(mock_receiver_proxy_));
+  run_loop.RunUntilIdle();
+
+  // Simulate device sending a frame, which should trigger |mock_receiver|
+  // DoOnFrameReadyInBuffer() getting called.
+  base::RunLoop run_loop_2;
+  mock_device_.SendStubFrame(stub_frame_format, arbitrary_rotation,
+                             arbitrary_frame_feedback_id);
+  run_loop_2.RunUntilIdle();
+
+  base::RunLoop run_loop_3;
+  mock_receiver_.reset();
+  run_loop_3.RunUntilIdle();
+}
+
 }  // namespace video_capture