Remove VideoCaptureDeviceFactory::EnumerateDeviceDescriptors()

media/capture/video/video_capture_device_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 "media/capture/video/video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 187 matching lines @@
 
   const mojom::PhotoCapabilities* capabilities() { return capabilities_.get(); }
 
  private:
   friend class base::RefCountedThreadSafe<MockImageCaptureClient>;
   virtual ~MockImageCaptureClient() {}
 
   mojom::PhotoCapabilitiesPtr capabilities_;
 };
 
-class DeviceEnumerationListener
-    : public base::RefCounted<DeviceEnumerationListener> {
- public:
-  MOCK_METHOD1(DoOnEnumerateDeviceDescriptors,
-               void(VideoCaptureDeviceDescriptors* device_descriptors));
-  // GMock doesn't support move-only arguments, so we use this forward method.
-  void OnEnumerateDeviceDescriptors(
-      std::unique_ptr<VideoCaptureDeviceDescriptors> device_descriptors) {
-    DoOnEnumerateDeviceDescriptors(device_descriptors.release());
-  }
-
- private:
-  friend class base::RefCounted<DeviceEnumerationListener>;
-  virtual ~DeviceEnumerationListener() {}
-};
-
 }  // namespace
 
 class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
  protected:
   typedef VideoCaptureDevice::Client Client;
 
   VideoCaptureDeviceTest()
       : loop_(new base::MessageLoop()),
+        device_descriptors_(new VideoCaptureDeviceDescriptors()),
         video_capture_client_(new MockVideoCaptureClient(
             base::Bind(&VideoCaptureDeviceTest::OnFrameCaptured,
                        base::Unretained(this)))),
-        device_enumeration_listener_(new DeviceEnumerationListener()),
         image_capture_client_(new MockImageCaptureClient()),
         video_capture_device_factory_(VideoCaptureDeviceFactory::CreateFactory(
             base::ThreadTaskRunnerHandle::Get())) {}
 
   void SetUp() override {
 #if defined(OS_ANDROID)
     VideoCaptureDeviceAndroid::RegisterVideoCaptureDevice(
         base::android::AttachCurrentThread());
 
     static_cast<VideoCaptureDeviceFactoryAndroid*>(
@@ skipping 15 matching lines @@
     last_format_ = format;
     if (run_loop_)
       run_loop_->QuitClosure().Run();
   }
 
   void WaitForCapturedFrame() {
     run_loop_.reset(new base::RunLoop());
     run_loop_->Run();
   }
 
-  bool EnumerateAndFindUsableDevices() {
-    VideoCaptureDeviceDescriptors* descriptors = nullptr;
-    EXPECT_CALL(*device_enumeration_listener_.get(),
-                DoOnEnumerateDeviceDescriptors(_))
-        .WillOnce(SaveArg<0>(&descriptors));
-
-    video_capture_device_factory_->EnumerateDeviceDescriptors(
-        base::Bind(&DeviceEnumerationListener::OnEnumerateDeviceDescriptors,
-                   device_enumeration_listener_));
-    base::RunLoop().RunUntilIdle();
-
-    device_descriptors_.reset(descriptors);
-    if (!device_descriptors_)
-      return false;
+  bool FindUsableDevices() {
+    video_capture_device_factory_->GetDeviceDescriptors(
+        device_descriptors_.get());
 
 #if defined(OS_ANDROID)
     // Android deprecated/legacy devices capture on a single thread, which is
     // occupied by the tests, so nothing gets actually delivered.
     // TODO(mcasas): use those devices' test mode to deliver frames in a
     // background thread, https://crbug.com/626857
-    for (const auto& descriptor : *descriptors) {
+    for (const auto& descriptor : *device_descriptors_) {
       if (VideoCaptureDeviceFactoryAndroid::IsLegacyOrDeprecatedDevice(
               descriptor.device_id)) {
         return false;
       }
     }
 #endif
 
     return !device_descriptors_->empty();
   }
 
   const VideoCaptureFormat& last_format() const { return last_format_; }
 
   std::unique_ptr<VideoCaptureDeviceDescriptor>
   GetFirstDeviceDescriptorSupportingPixelFormat(
       const VideoPixelFormat& pixel_format) {
-    if (!EnumerateAndFindUsableDevices())
+    if (!FindUsableDevices())
       return nullptr;
 
     for (const auto& descriptor : *device_descriptors_) {
       VideoCaptureFormats supported_formats;
       video_capture_device_factory_->GetSupportedFormats(descriptor,
                                                          &supported_formats);
       for (const auto& formats_iterator : supported_formats) {
         if (formats_iterator.pixel_format == pixel_format) {
           return std::unique_ptr<VideoCaptureDeviceDescriptor>(
               new VideoCaptureDeviceDescriptor(descriptor));
@@ skipping 16 matching lines @@
     if (it == supported_formats.end()) {
       DVLOG(1) << "Size " << size.ToString() << " is not supported.";
       return false;
     }
     return true;
   }
 
 #if defined(OS_WIN)
   base::win::ScopedCOMInitializer initialize_com_;
 #endif
+  const std::unique_ptr<base::MessageLoop> loop_;
   std::unique_ptr<VideoCaptureDeviceDescriptors> device_descriptors_;
-  const std::unique_ptr<base::MessageLoop> loop_;
   std::unique_ptr<base::RunLoop> run_loop_;
   std::unique_ptr<MockVideoCaptureClient> video_capture_client_;
-  const scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_;
   const scoped_refptr<MockImageCaptureClient> image_capture_client_;
   VideoCaptureFormat last_format_;
   const std::unique_ptr<VideoCaptureDeviceFactory>
       video_capture_device_factory_;
 };
 
 // Cause hangs on Windows Debug. http://crbug.com/417824
 #if defined(OS_WIN) && !defined(NDEBUG)
 #define MAYBE_OpenInvalidDevice DISABLED_OpenInvalidDevice
 #else
@@ skipping 26 matching lines @@
   capture_params.requested_format.frame_size.SetSize(640, 480);
   capture_params.requested_format.frame_rate = 30;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
   device->StopAndDeAllocate();
 #endif
 }
 
 // Allocates the first enumerated device, and expects a frame.
 TEST_P(VideoCaptureDeviceTest, CaptureWithSize) {
-  if (!EnumerateAndFindUsableDevices())
+  if (!FindUsableDevices())
     return;
 
   const gfx::Size& size = GetParam();
   if (!IsCaptureSizeSupported(device_descriptors_->front(), size))
     return;
   const int width = size.width();
   const int height = size.height();
 
   std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->CreateDevice(
@@ skipping 20 matching lines @@
 
 const gfx::Size kCaptureSizes[] = {gfx::Size(640, 480), gfx::Size(1280, 720)};
 
 INSTANTIATE_TEST_CASE_P(VideoCaptureDeviceTests,
                         VideoCaptureDeviceTest,
                         testing::ValuesIn(kCaptureSizes));
 
 // Allocates a device with an uncommon resolution and verifies frames are
 // captured in a close, much more typical one.
 TEST_F(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
-  if (!EnumerateAndFindUsableDevices())
+  if (!FindUsableDevices())
     return;
 
   std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->CreateDevice(
           device_descriptors_->front()));
   ASSERT_TRUE(device);
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
   EXPECT_CALL(*video_capture_client_, OnStarted());
 
   const gfx::Size input_size(640, 480);
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(637, 472);
   capture_params.requested_format.frame_rate = 35;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
   WaitForCapturedFrame();
   device->StopAndDeAllocate();
   EXPECT_EQ(last_format().frame_size.width(), input_size.width());
   EXPECT_EQ(last_format().frame_size.height(), input_size.height());
   if (last_format().pixel_format != PIXEL_FORMAT_MJPEG)
     EXPECT_EQ(input_size.GetArea(), last_format().frame_size.GetArea());
 }
 
 // Cause hangs on Windows, Linux. Fails Android. https://crbug.com/417824
 TEST_F(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
-  if (!EnumerateAndFindUsableDevices())
+  if (!FindUsableDevices())
     return;
 
   // First, do a number of very fast device start/stops.
   for (int i = 0; i <= 5; i++) {
     ResetWithNewClient();
     std::unique_ptr<VideoCaptureDevice> device(
         video_capture_device_factory_->CreateDevice(
             device_descriptors_->front()));
     gfx::Size resolution;
     if (i % 2)
@@ skipping 72 matching lines @@
   std::unique_ptr<VideoCaptureDeviceDescriptor> device_descriptor =
       GetFirstDeviceDescriptorSupportingPixelFormat(PIXEL_FORMAT_MAX);
   // Verify no camera returned for PIXEL_FORMAT_MAX. Nothing else to test here
   // since we cannot forecast the hardware capabilities.
   ASSERT_FALSE(device_descriptor);
 }
 
 // Starts the camera and verifies that a photo can be taken. The correctness of
 // the photo is enforced by MockImageCaptureClient.
 TEST_F(VideoCaptureDeviceTest, MAYBE_TakePhoto) {
-  if (!EnumerateAndFindUsableDevices())
+  if (!FindUsableDevices())
     return;
 
 #if defined(OS_ANDROID)
   // TODO(mcasas): fails on Lollipop devices, reconnect https://crbug.com/646840
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_MARSHMALLOW) {
     return;
   }
 #endif
 
@@ skipping 24 matching lines @@
       .WillOnce(RunClosure(quit_closure));
 
   device->TakePhoto(std::move(scoped_callback));
   run_loop.Run();
 
   device->StopAndDeAllocate();
 }
 
 // Starts the camera and verifies that the photo capabilities can be retrieved.
 TEST_F(VideoCaptureDeviceTest, MAYBE_GetPhotoCapabilities) {
-  if (!EnumerateAndFindUsableDevices())
+  if (!FindUsableDevices())
     return;
 
 #if defined(OS_ANDROID)
   // TODO(mcasas): fails on Lollipop devices, reconnect https://crbug.com/646840
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_MARSHMALLOW) {
     return;
   }
 #endif
 
@@ skipping 26 matching lines @@
 
   device->GetPhotoCapabilities(std::move(scoped_get_callback));
   run_loop.Run();
 
   ASSERT_TRUE(image_capture_client_->capabilities());
 
   device->StopAndDeAllocate();
 }
 
 };  // namespace media