getUserMeida: report device starting states

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 84 matching lines @@
       buffer_id, arbitrary_frame_feedback_id,
       base::MakeUnique<StubBufferHandleProvider>(mapped_size, buffer),
       base::MakeUnique<StubReadWritePermission>(buffer));
 };
 
 class MockClient : public VideoCaptureDevice::Client {
  public:
   MOCK_METHOD2(OnError,
                void(const tracked_objects::Location& from_here,
                     const std::string& reason));
+  MOCK_METHOD0(OnStarted, void(void));
 
   explicit MockClient(base::Callback<void(const VideoCaptureFormat&)> frame_cb)
       : frame_cb_(frame_cb) {}
 
   // Client virtual methods for capturing using Device Buffers.
   void OnIncomingCapturedData(const uint8_t* data,
                               int length,
                               const VideoCaptureFormat& format,
                               int rotation,
                               base::TimeTicks reference_time,
@@ skipping 172 matching lines @@
   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();
     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());
     EXPECT_EQ(resolution.second.height(), last_format().frame_size.height());
     EXPECT_EQ(last_format().pixel_format, testing::get<0>(GetParam()));
@@ skipping 69 matching lines @@
 TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
   auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
       PIXEL_FORMAT_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);
@@ skipping 91 matching lines @@
 TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) {
   auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
       PIXEL_FORMAT_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_),
       base::Bind(&ImageCaptureClient::OnTakePhotoFailure,
                  image_capture_client_));
 
   EXPECT_CALL(*image_capture_client_.get(), OnCorrectPhotoTaken()).Times(1);
   device->TakePhoto(std::move(scoped_callback));
 
@@ skipping 35 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];
-    device->AllocateAndStart(capture_params, CreateClient());
+    auto 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();
 
     device_index++;
   }
@@ skipping 20 matching lines @@
                20,
                3u,
                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_I420}},
            CommandLineTestData{
                "device-count=3,ownership=client",
                20,
                3u,
                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_I420}},
            CommandLineTestData{"device-count=0", 20, 1u, {PIXEL_FORMAT_I420}}));
 };  // namespace media