getUserMedia: handle the device starting status report.

media/capture/video/fake_video_capture_device_unittest.cc

 // Copyright 2014 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 "media/capture/video/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 268 matching lines @@
       testing::get<0>(GetParam()) ==
           FakeVideoCaptureDeviceMaker::PixelFormat::MJPEG) {
     // Unsupported case
     return;
   }
 
   const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
       EnumerateDevices());
   ASSERT_FALSE(descriptors->empty());
 
-  auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
-      testing::get<0>(GetParam()), testing::get<1>(GetParam()),
-      testing::get<2>(GetParam()));
+  std::unique_ptr<VideoCaptureDevice> device =

[chfremer, 2017/03/02 17:56:10]

Thanks for these cleanups!

[braveyao, 2017/03/03 17:53:12]

Acknowledged.

+      FakeVideoCaptureDeviceMaker::MakeInstance(testing::get<0>(GetParam()),
+                                                testing::get<1>(GetParam()),
+                                                testing::get<2>(GetParam()));
   ASSERT_TRUE(device);
 
   // First: Requested, Second: Expected
   std::vector<std::pair<gfx::Size, gfx::Size>> resolutions_to_test;
   resolutions_to_test.emplace_back(gfx::Size(640, 480), gfx::Size(640, 480));
   resolutions_to_test.emplace_back(gfx::Size(104, 105), gfx::Size(320, 240));
   resolutions_to_test.emplace_back(gfx::Size(0, 0), gfx::Size(96, 96));
   resolutions_to_test.emplace_back(gfx::Size(0, 720), gfx::Size(96, 96));
   resolutions_to_test.emplace_back(gfx::Size(1920, 1080),
                                    gfx::Size(1920, 1080));
 
   for (const auto& resolution : resolutions_to_test) {
-    auto client = CreateClient();
+    std::unique_ptr<MockClient> client = CreateClient();
     EXPECT_CALL(*client, OnError(_, _)).Times(0);
     EXPECT_CALL(*client, OnStarted());
 
     VideoCaptureParams capture_params;
     capture_params.requested_format.frame_size = resolution.first;
     capture_params.requested_format.frame_rate = testing::get<2>(GetParam());
     device->AllocateAndStart(capture_params, std::move(client));
 
     WaitForCapturedFrame();
     EXPECT_EQ(resolution.second.width(), last_format().frame_size.width());
@@ skipping 69 matching lines @@
   const VideoCaptureDeviceDescriptor& depth_device = descriptors->at(1);
   EXPECT_EQ("/dev/video1", depth_device.device_id);
   ASSERT_TRUE(depth_device.camera_calibration);
   EXPECT_EQ(135.0, depth_device.camera_calibration->focal_length_x);
   EXPECT_EQ(135.6, depth_device.camera_calibration->focal_length_y);
   EXPECT_EQ(0.0, depth_device.camera_calibration->depth_near);
   EXPECT_EQ(65.535, depth_device.camera_calibration->depth_far);
 }
 
 TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
-  auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
-      FakeVideoCaptureDeviceMaker::PixelFormat::I420,
-      FakeVideoCaptureDeviceMaker::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS,
-      30.0);
+  std::unique_ptr<VideoCaptureDevice> device =
+      FakeVideoCaptureDeviceMaker::MakeInstance(
+          FakeVideoCaptureDeviceMaker::PixelFormat::I420,
+          FakeVideoCaptureDeviceMaker::DeliveryMode::
+              USE_DEVICE_INTERNAL_BUFFERS,
+          30.0);
   ASSERT_TRUE(device);
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(640, 480);
   capture_params.requested_format.frame_rate = 30.0;
   EXPECT_CALL(*client_, OnStarted());
   device->AllocateAndStart(capture_params, std::move(client_));
 
   VideoCaptureDevice::GetPhotoCapabilitiesCallback scoped_get_callback(
       base::Bind(&ImageCaptureClient::DoOnGetPhotoCapabilities,
                  image_capture_client_),
       base::Bind(&ImageCaptureClient::OnGetPhotoCapabilitiesFailure,
                  image_capture_client_));
 
   EXPECT_CALL(*image_capture_client_.get(), OnCorrectGetPhotoCapabilities())
       .Times(1);
   device->GetPhotoCapabilities(std::move(scoped_get_callback));
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
 
-  auto* capabilities = image_capture_client_->capabilities();
+  const mojom::PhotoCapabilities* capabilities =
+      image_capture_client_->capabilities();
   ASSERT_TRUE(capabilities);
   EXPECT_EQ(100, capabilities->iso->min);
   EXPECT_EQ(100, capabilities->iso->max);
   EXPECT_EQ(100, capabilities->iso->current);
   EXPECT_EQ(0, capabilities->iso->step);
   EXPECT_EQ(capture_params.requested_format.frame_size.height(),
             capabilities->height->current);
   EXPECT_EQ(96, capabilities->height->min);
   EXPECT_EQ(1080, capabilities->height->max);
   EXPECT_EQ(1, capabilities->height->step);
@@ skipping 67 matching lines @@
   device->GetPhotoCapabilities(std::move(scoped_get_callback2));
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
   EXPECT_EQ(max_zoom_value,
             image_capture_client_->capabilities()->zoom->current);
 
   device->StopAndDeAllocate();
 }
 
 TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) {
-  auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
-      FakeVideoCaptureDeviceMaker::PixelFormat::I420,
-      FakeVideoCaptureDeviceMaker::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS,
-      30.0);
+  std::unique_ptr<VideoCaptureDevice> device =
+      FakeVideoCaptureDeviceMaker::MakeInstance(
+          FakeVideoCaptureDeviceMaker::PixelFormat::I420,
+          FakeVideoCaptureDeviceMaker::DeliveryMode::
+              USE_DEVICE_INTERNAL_BUFFERS,
+          30.0);
   ASSERT_TRUE(device);
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(640, 480);
   capture_params.requested_format.frame_rate = 30.0;
   EXPECT_CALL(*client_, OnStarted());
   device->AllocateAndStart(capture_params, std::move(client_));
 
   VideoCaptureDevice::TakePhotoCallback scoped_callback(
       base::Bind(&ImageCaptureClient::DoOnPhotoTaken, image_capture_client_),
@@ skipping 41 matching lines @@
 
     std::unique_ptr<VideoCaptureDevice> device =
         video_capture_device_factory_->CreateDevice(descriptors_iterator);
     ASSERT_TRUE(device);
 
     VideoCaptureParams capture_params;
     capture_params.requested_format.frame_size.SetSize(1280, 720);
     capture_params.requested_format.frame_rate = GetParam().expected_fps;
     capture_params.requested_format.pixel_format =
         GetParam().expected_pixel_formats[device_index];
-    auto client = CreateClient();
+    std::unique_ptr<MockClient> client = CreateClient();
     EXPECT_CALL(*client, OnStarted());
     device->AllocateAndStart(capture_params, std::move(client));
     WaitForCapturedFrame();
     EXPECT_EQ(1280, last_format().frame_size.width());
     EXPECT_EQ(720, last_format().frame_size.height());
     EXPECT_EQ(GetParam().expected_fps, last_format().frame_rate);
     EXPECT_EQ(GetParam().expected_pixel_formats[device_index],
               last_format().pixel_format);
     device->StopAndDeAllocate();
 
@@ skipping 24 matching lines @@
                                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16,
                                 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}},
            CommandLineTestData{"device-count=4,ownership=client",
                                20,
                                4u,
 
                                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16,
                                 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}},
            CommandLineTestData{"device-count=0", 20, 1u, {PIXEL_FORMAT_I420}}));
 };  // namespace media