Remove VideoCaptureDeviceFactory::EnumerateDeviceDescriptors()

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 136 matching lines @@
                                    media::VideoPixelStorage storage,
                                    int frame_feedback_id) override {
     return Buffer();
   }
   double GetBufferPoolUtilization() const override { return 0.0; }
 
  private:
   base::Callback<void(const VideoCaptureFormat&)> frame_cb_;
 };
 
-class DeviceEnumerationListener
-    : public base::RefCounted<DeviceEnumerationListener> {
- public:
-  MOCK_METHOD1(OnEnumeratedDevicesCallbackPtr,
-               void(VideoCaptureDeviceDescriptors* descriptors));
-  // GMock doesn't support move-only arguments, so we use this forward method.
-  void OnEnumeratedDevicesCallback(
-      std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors) {
-    OnEnumeratedDevicesCallbackPtr(descriptors.release());
-  }
-
- private:
-  friend class base::RefCounted<DeviceEnumerationListener>;
-  virtual ~DeviceEnumerationListener() {}
-};
-
 class ImageCaptureClient : public base::RefCounted<ImageCaptureClient> {
  public:
   // GMock doesn't support move-only arguments, so we use this forward method.
   void DoOnGetPhotoCapabilities(mojom::PhotoCapabilitiesPtr capabilities) {
     capabilities_ = std::move(capabilities);
     OnCorrectGetPhotoCapabilities();
   }
   MOCK_METHOD0(OnCorrectGetPhotoCapabilities, void(void));
   MOCK_METHOD1(OnGetPhotoCapabilitiesFailure,
                void(const base::Callback<void(mojom::PhotoCapabilitiesPtr)>&));
@@ skipping 26 matching lines @@
 
   mojom::PhotoCapabilitiesPtr capabilities_;
 };
 
 }  // namespace
 
 class FakeVideoCaptureDeviceBase : public ::testing::Test {
  protected:
   FakeVideoCaptureDeviceBase()
       : loop_(new base::MessageLoop()),
+        descriptors_(new VideoCaptureDeviceDescriptors()),
         client_(CreateClient()),
-        device_enumeration_listener_(new DeviceEnumerationListener()),
         image_capture_client_(new ImageCaptureClient()),
         video_capture_device_factory_(new FakeVideoCaptureDeviceFactory()) {}
 
   void SetUp() override { EXPECT_CALL(*client_, OnError(_, _)).Times(0); }
 
   std::unique_ptr<MockClient> CreateClient() {
     return std::unique_ptr<MockClient>(new MockClient(base::Bind(
         &FakeVideoCaptureDeviceBase::OnFrameCaptured, base::Unretained(this))));
   }
 
   void OnFrameCaptured(const VideoCaptureFormat& format) {
     last_format_ = format;
     run_loop_->QuitClosure().Run();
   }
 
   void WaitForCapturedFrame() {
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
-  std::unique_ptr<VideoCaptureDeviceDescriptors> EnumerateDevices() {
-    VideoCaptureDeviceDescriptors* descriptors;
-    EXPECT_CALL(*device_enumeration_listener_.get(),
-                OnEnumeratedDevicesCallbackPtr(_))
-        .WillOnce(SaveArg<0>(&descriptors));
-
-    video_capture_device_factory_->EnumerateDeviceDescriptors(
-        base::Bind(&DeviceEnumerationListener::OnEnumeratedDevicesCallback,
-                   device_enumeration_listener_));
-    base::RunLoop().RunUntilIdle();
-    return std::unique_ptr<VideoCaptureDeviceDescriptors>(descriptors);
-  }
-
   const VideoCaptureFormat& last_format() const { return last_format_; }
 
-  VideoCaptureDeviceDescriptors descriptors_;
   const std::unique_ptr<base::MessageLoop> loop_;
+  std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors_;

[chfremer, 2017/04/07 16:34:21]

Does this need to be a std::unique_ptr<> or can we use
VideoCaptureDeviceDescriptors directly?

[Chandan, 2017/04/10 09:18:24]

VideoCaptureDeviceDescriptors descriptors_ was unused.
std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(EnumerateDevices());
was used in each test run. Hence, changed descriptors_ to std::unique_ptr<> to
avoid '->' to '.' changes in test runs.

   std::unique_ptr<base::RunLoop> run_loop_;
   std::unique_ptr<MockClient> client_;
-  const scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_;
   const scoped_refptr<ImageCaptureClient> image_capture_client_;
   VideoCaptureFormat last_format_;
   const std::unique_ptr<FakeVideoCaptureDeviceFactory>
       video_capture_device_factory_;
 };
 
 class FakeVideoCaptureDeviceTest
     : public FakeVideoCaptureDeviceBase,
       public ::testing::WithParamInterface<
           ::testing::tuple<VideoPixelFormat,
                            FakeVideoCaptureDevice::DeliveryMode,
                            float>> {};
 
 // Tests that a frame is delivered with the expected settings.
 // Sweeps through a fixed set of requested/expected resolutions.
 TEST_P(FakeVideoCaptureDeviceTest, CaptureUsing) {
   if (testing::get<1>(GetParam()) ==
           FakeVideoCaptureDevice::DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS &&
       testing::get<0>(GetParam()) == media::PIXEL_FORMAT_MJPEG) {
     // Unsupported case
     return;
   }
 
-  const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
-      EnumerateDevices());
-  ASSERT_FALSE(descriptors->empty());
+  descriptors_->clear();

[chfremer, 2017/04/07 16:34:21]

I believe that the gtest framework will create a new instance of the test class
for each test run, so this should not be needed.

[Chandan, 2017/04/10 09:18:24]

Done.

+  video_capture_device_factory_->GetDeviceDescriptors(descriptors_.get());
+  ASSERT_FALSE(descriptors_->empty());
 
   std::unique_ptr<VideoCaptureDevice> device =
       FakeVideoCaptureDeviceFactory::CreateDeviceWithDefaultResolutions(
           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));
@@ skipping 26 matching lines @@
     ,
     FakeVideoCaptureDeviceTest,
     Combine(
         Values(PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_MJPEG),
         Values(
             FakeVideoCaptureDevice::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS,
             FakeVideoCaptureDevice::DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS),
         Values(20, 29.97, 30, 50, 60)));
 
 TEST_F(FakeVideoCaptureDeviceTest, GetDeviceSupportedFormats) {
+  descriptors_->clear();
   video_capture_device_factory_->SetToDefaultDevicesConfig(4);
-  std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
-      EnumerateDevices());
-  ASSERT_EQ(4u, descriptors->size());
+  video_capture_device_factory_->GetDeviceDescriptors(descriptors_.get());
+  ASSERT_EQ(4u, descriptors_->size());
   const VideoPixelFormat expected_format_by_device_index[] = {
       PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_MJPEG,
       PIXEL_FORMAT_I420};
 
   int device_index = 0;
-  for (const auto& descriptors_iterator : *descriptors) {
+  for (const auto& descriptors_iterator : *descriptors_) {
     VideoCaptureFormats supported_formats;
     video_capture_device_factory_->GetSupportedFormats(descriptors_iterator,
                                                        &supported_formats);
     ASSERT_EQ(5u, supported_formats.size());
     VideoPixelFormat expected_format =
         expected_format_by_device_index[device_index];
     EXPECT_EQ(96, supported_formats[0].frame_size.width());
     EXPECT_EQ(96, supported_formats[0].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[0].pixel_format);
     EXPECT_GE(supported_formats[0].frame_rate, 20.0);
@@ skipping 11 matching lines @@
     EXPECT_GE(supported_formats[3].frame_rate, 20.0);
     EXPECT_EQ(1920, supported_formats[4].frame_size.width());
     EXPECT_EQ(1080, supported_formats[4].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[4].pixel_format);
     EXPECT_GE(supported_formats[4].frame_rate, 20.0);
     device_index++;
   }
 }
 
 TEST_F(FakeVideoCaptureDeviceTest, GetCameraCalibration) {
+  descriptors_->clear();
   const size_t device_count = 2;
   video_capture_device_factory_->SetToDefaultDevicesConfig(device_count);
-  std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
-      EnumerateDevices());
-  ASSERT_EQ(device_count, descriptors->size());
-  ASSERT_FALSE(descriptors->at(0).camera_calibration);
-  const VideoCaptureDeviceDescriptor& depth_device = descriptors->at(1);
+
+  video_capture_device_factory_->GetDeviceDescriptors(descriptors_.get());
+  ASSERT_EQ(device_count, descriptors_->size());
+  ASSERT_FALSE(descriptors_->at(0).camera_calibration);
+  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, ErrorDeviceReportsError) {
   auto device = FakeVideoCaptureDeviceFactory::CreateErrorDevice();
@@ skipping 156 matching lines @@
   float expected_fps;
   size_t expected_device_count;
   std::vector<VideoPixelFormat> expected_pixel_formats;
 };
 
 class FakeVideoCaptureDeviceFactoryTest
     : public FakeVideoCaptureDeviceBase,
       public ::testing::WithParamInterface<CommandLineTestData> {};
 
 TEST_F(FakeVideoCaptureDeviceFactoryTest, DeviceWithNoSupportedFormats) {
+  descriptors_->clear();
   std::vector<FakeVideoCaptureDeviceSettings> config;
   FakeVideoCaptureDeviceSettings device_setting;
   device_setting.device_id = "Device with no supported formats";
   config.emplace_back(device_setting);
   video_capture_device_factory_->SetToCustomDevicesConfig(config);
 
-  const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
-      EnumerateDevices());
-  EXPECT_EQ(1u, descriptors->size());
+  video_capture_device_factory_->GetDeviceDescriptors(descriptors_.get());
+  EXPECT_EQ(1u, descriptors_->size());
   media::VideoCaptureFormats supported_formats;
-  video_capture_device_factory_->GetSupportedFormats(descriptors->at(0),
+  video_capture_device_factory_->GetSupportedFormats(descriptors_->at(0),
                                                      &supported_formats);
   EXPECT_EQ(0u, supported_formats.size());
-  auto device = video_capture_device_factory_->CreateDevice(descriptors->at(0));
+  auto device =
+      video_capture_device_factory_->CreateDevice(descriptors_->at(0));
   EXPECT_TRUE(device.get());
 
   auto client = CreateClient();
   EXPECT_CALL(*client, OnError(_, _));
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(1280, 720);
   device->AllocateAndStart(capture_params, std::move(client));
 }
 
 // Tests that the FakeVideoCaptureDeviceFactory delivers the expected number
 // of devices and formats when being configured using command-line switches.
 TEST_P(FakeVideoCaptureDeviceFactoryTest, FrameRateAndDeviceCount) {
+  descriptors_->clear();
   std::vector<FakeVideoCaptureDeviceSettings> config;
   FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString(
       GetParam().switch_value_string, &config);
   video_capture_device_factory_->SetToCustomDevicesConfig(config);
 
-  const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
-      EnumerateDevices());
-  EXPECT_EQ(GetParam().expected_device_count, descriptors->size());
+  video_capture_device_factory_->GetDeviceDescriptors(descriptors_.get());
+  EXPECT_EQ(GetParam().expected_device_count, descriptors_->size());
 
   int device_index = 0;
-  for (const auto& descriptors_iterator : *descriptors) {
+  for (const auto& descriptors_iterator : *descriptors_) {
     media::VideoCaptureFormats supported_formats;
     video_capture_device_factory_->GetSupportedFormats(descriptors_iterator,
                                                        &supported_formats);
     for (const auto& supported_formats_entry : supported_formats) {
       EXPECT_EQ(GetParam().expected_pixel_formats[device_index],
                 supported_formats_entry.pixel_format);
     }
 
     std::unique_ptr<VideoCaptureDevice> device =
         video_capture_device_factory_->CreateDevice(descriptors_iterator);
@@ skipping 40 matching lines @@
                                4u,
                                {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, 0u, {PIXEL_FORMAT_I420}}));
 };  // namespace media