Video capture Android: enable unittests for Camera2 API

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 21 matching lines @@
 #endif
 
 #if defined(OS_MACOSX)
 #include "media/base/mac/avfoundation_glue.h"
 #include "media/capture/video/mac/video_capture_device_factory_mac.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "base/android/jni_android.h"
 #include "media/capture/video/android/video_capture_device_android.h"
+#include "media/capture/video/android/video_capture_device_factory_android.h"
 #endif
 
 #if defined(OS_MACOSX)
 // Mac will always give you the size you ask for and this case will fail.
 #define MAYBE_AllocateBadSize DISABLED_AllocateBadSize
 // We will always get YUYV from the Mac AVFoundation implementations.
 #define MAYBE_CaptureMjpeg DISABLED_CaptureMjpeg
 #define MAYBE_TakePhoto TakePhoto
 #elif defined(OS_WIN)
 #define MAYBE_AllocateBadSize AllocateBadSize
 #define MAYBE_CaptureMjpeg CaptureMjpeg
 #define MAYBE_TakePhoto DISABLED_TakePhoto
 #elif defined(OS_ANDROID)
-// TODO(wjia): enable those tests on Android.
-// On Android, native camera (JAVA) delivers frames on UI thread which is the
-// main thread for tests. This results in no frame received by
-// VideoCaptureAndroid.
-#define MAYBE_AllocateBadSize DISABLED_AllocateBadSize
-#define DeAllocateCameraWhileRunning DISABLED_DeAllocateCameraWhileRunning
-#define DeAllocateCameraWhileRunning DISABLED_DeAllocateCameraWhileRunning
-#define MAYBE_CaptureMjpeg DISABLED_CaptureMjpeg
+#define MAYBE_AllocateBadSize AllocateBadSize
+#define MAYBE_CaptureMjpeg CaptureMjpeg
 #define MAYBE_TakePhoto DISABLED_TakePhoto
 #elif defined(OS_LINUX)
 // AllocateBadSize will hang when a real camera is attached and if more than one
 // test is trying to use the camera (even across processes). Do NOT renable
 // this test without fixing the many bugs associated with it:
 // http://crbug.com/94134 http://crbug.com/137260 http://crbug.com/417824
 #define MAYBE_AllocateBadSize DISABLED_AllocateBadSize
 #define MAYBE_CaptureMjpeg CaptureMjpeg
 #define MAYBE_TakePhoto DISABLED_TakePhoto
 #else
@@ skipping 24 matching lines @@
       : main_thread_(base::ThreadTaskRunnerHandle::Get()),
         frame_cb_(frame_cb) {}
 
   void OnIncomingCapturedData(const uint8_t* data,
                               int length,
                               const VideoCaptureFormat& format,
                               int rotation,
                               base::TimeTicks reference_time,
                               base::TimeDelta timestamp) override {
     ASSERT_GT(length, 0);
-    ASSERT_TRUE(data != NULL);
+    ASSERT_TRUE(data);
     main_thread_->PostTask(FROM_HERE, base::Bind(frame_cb_, format));
   }
 
   // Trampoline methods to workaround GMOCK problems with std::unique_ptr<>.
   std::unique_ptr<Buffer> ReserveOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage) override {
     DoReserveOutputBuffer();
     NOTREACHED() << "This should never be called";
@@ skipping 43 matching lines @@
                void(const base::Callback<void(mojom::BlobPtr)>&));
 
  private:
   friend class base::RefCounted<MockImageCaptureClient>;
   virtual ~MockImageCaptureClient() {}
 };
 
 class DeviceEnumerationListener
     : public base::RefCounted<DeviceEnumerationListener> {
  public:
-  MOCK_METHOD1(OnEnumerateDeviceDescriptorsCallbackPtr,
+  MOCK_METHOD1(DoOnEnumerateDeviceDescriptors,
                void(VideoCaptureDeviceDescriptors* device_descriptors));
   // GMock doesn't support move-only arguments, so we use this forward method.
-  void OnEnumerateDeviceDescriptorsCallback(
+  void OnEnumerateDeviceDescriptors(
       std::unique_ptr<VideoCaptureDeviceDescriptors> device_descriptors) {
-    OnEnumerateDeviceDescriptorsCallbackPtr(device_descriptors.release());
+    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()),
         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*>(
+        video_capture_device_factory_.get())
+        ->ConfigureForTesting();
 #endif
 #if defined(OS_MACOSX)
     AVFoundationGlue::InitializeAVFoundation();
 #endif
     EXPECT_CALL(*video_capture_client_, DoReserveOutputBuffer()).Times(0);
     EXPECT_CALL(*video_capture_client_, DoOnIncomingCapturedBuffer()).Times(0);
     EXPECT_CALL(*video_capture_client_, DoOnIncomingCapturedVideoFrame())
         .Times(0);
   }
 
   void ResetWithNewClient() {
     video_capture_client_.reset(new MockVideoCaptureClient(base::Bind(
         &VideoCaptureDeviceTest::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> EnumerateDeviceDescriptors() {
-    VideoCaptureDeviceDescriptors* device_descriptors;
+  bool EnumerateAndFindUsableDevices() {
+    VideoCaptureDeviceDescriptors* descriptors = nullptr;
     EXPECT_CALL(*device_enumeration_listener_.get(),
-                OnEnumerateDeviceDescriptorsCallbackPtr(_))
-        .WillOnce(SaveArg<0>(&device_descriptors));
+                DoOnEnumerateDeviceDescriptors(_))
+        .WillOnce(SaveArg<0>(&descriptors));
 
-    video_capture_device_factory_->EnumerateDeviceDescriptors(base::Bind(
-        &DeviceEnumerationListener::OnEnumerateDeviceDescriptorsCallback,
-        device_enumeration_listener_));
+    video_capture_device_factory_->EnumerateDeviceDescriptors(
+        base::Bind(&DeviceEnumerationListener::OnEnumerateDeviceDescriptors,
+                   device_enumeration_listener_));
     base::RunLoop().RunUntilIdle();
-    return std::unique_ptr<VideoCaptureDeviceDescriptors>(device_descriptors);
+
+    if (!descriptors || descriptors->empty())
+      return false;
+    device_descriptors_.reset(descriptors);
+
+#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) {
+      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) {
-    device_descriptors_ = EnumerateDeviceDescriptors();
-    if (device_descriptors_->empty()) {
-      DVLOG(1) << "No camera available.";
-      return std::unique_ptr<VideoCaptureDeviceDescriptor>();
-    }
-    for (const auto& descriptors_iterator : *device_descriptors_) {
+    if (!EnumerateAndFindUsableDevices())
+      return nullptr;
+
+    for (const auto& descriptor : *device_descriptors_) {
       VideoCaptureFormats supported_formats;
-      video_capture_device_factory_->GetSupportedFormats(descriptors_iterator,
+      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(descriptors_iterator));
+              new VideoCaptureDeviceDescriptor(descriptor));
         }
       }
     }
     DVLOG_IF(1, pixel_format != PIXEL_FORMAT_MAX)
-        << "No camera can capture the"
-        << " format: " << VideoPixelFormatToString(pixel_format);
+        << VideoPixelFormatToString(pixel_format);
     return std::unique_ptr<VideoCaptureDeviceDescriptor>();
   }
 
   bool IsCaptureSizeSupported(const VideoCaptureDeviceDescriptor& device,
                               const gfx::Size& size) {
     VideoCaptureFormats supported_formats;
     video_capture_device_factory_->GetSupportedFormats(device,
                                                        &supported_formats);
     const auto it = std::find_if(
         supported_formats.begin(), supported_formats.end(),
@@ skipping 18 matching lines @@
   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
 #define MAYBE_OpenInvalidDevice OpenInvalidDevice
 #endif
-
+// Tries to allocate an invalid device and verifies it doesn't work.
 TEST_F(VideoCaptureDeviceTest, MAYBE_OpenInvalidDevice) {
   VideoCaptureDeviceDescriptor invalid_descriptor;
   invalid_descriptor.device_id = "jibberish";
   invalid_descriptor.display_name = "jibberish";
 #if defined(OS_WIN)
   invalid_descriptor.capture_api =
       VideoCaptureDeviceFactoryWin::PlatformSupportsMediaFoundation()
           ? VideoCaptureApi::WIN_MEDIA_FOUNDATION
           : VideoCaptureApi::WIN_DIRECT_SHOW;
 #elif defined(OS_MACOSX)
   invalid_descriptor.capture_api = VideoCaptureApi::MACOSX_AVFOUNDATION;
 #endif
   std::unique_ptr<VideoCaptureDevice> device =
       video_capture_device_factory_->CreateDevice(invalid_descriptor);
 
 #if !defined(OS_MACOSX)
-  EXPECT_TRUE(device == NULL);
+  EXPECT_FALSE(device);
 #else
   // The presence of the actual device is only checked on AllocateAndStart()
   // and not on creation.
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(1);
 
   VideoCaptureParams capture_params;
   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) {
-  device_descriptors_ = EnumerateDeviceDescriptors();
-  if (device_descriptors_->empty()) {
-    VLOG(1) << "No camera available. Exiting test.";
+  if (!EnumerateAndFindUsableDevices())
     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(
           device_descriptors_->front()));
   ASSERT_TRUE(device);
-  DVLOG(1) << device_descriptors_->front().device_id;
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(width, height);
   capture_params.requested_format.frame_rate = 30.0f;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
-  // Get captured video frames.
+
   WaitForCapturedFrame();
   EXPECT_EQ(last_format().frame_size.width(), width);
   EXPECT_EQ(last_format().frame_size.height(), height);
   if (last_format().pixel_format != PIXEL_FORMAT_MJPEG)
     EXPECT_EQ(size.GetArea(), last_format().frame_size.GetArea());
+  EXPECT_EQ(last_format().frame_rate, 30);
   device->StopAndDeAllocate();
 }
 
-#if !defined(OS_ANDROID)
 const gfx::Size kCaptureSizes[] = {gfx::Size(640, 480), gfx::Size(1280, 720)};
 
 INSTANTIATE_TEST_CASE_P(VideoCaptureDeviceTests,
                         VideoCaptureDeviceTest,
                         testing::ValuesIn(kCaptureSizes));
-#endif
 
+// Allocates a device with an uncommon resolution and verifies frames are
+// captured

[emircan, 2016/09/02 22:00:23]

Fix indentation.

[mcasas, 2016/09/02 22:27:07]

Done.

+// in a close, much more typical one.
 TEST_F(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
-  device_descriptors_ = EnumerateDeviceDescriptors();
-  if (device_descriptors_->empty()) {
-    VLOG(1) << "No camera available. Exiting test.";
+  if (!EnumerateAndFindUsableDevices())
     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);
 
   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. http://crbug.com/417824
+// Cause hangs on Windows, Linux. Fails Android. https://crbug.com/417824
 TEST_F(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
-  device_descriptors_ = EnumerateDeviceDescriptors();
-  if (device_descriptors_->empty()) {
-    VLOG(1) << "No camera available. Exiting test.";
+  if (!EnumerateAndFindUsableDevices())
     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) {
+    if (i % 2)
       resolution = gfx::Size(640, 480);
-    } else {
+    else
       resolution = gfx::Size(1280, 1024);
-    }
+
     VideoCaptureParams capture_params;
     capture_params.requested_format.frame_size = resolution;
     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();
   }
 
   // Finally, do a device start and wait for it to finish.
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(320, 240);
   capture_params.requested_format.frame_rate = 30;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_I420;
 
   ResetWithNewClient();
   std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->CreateDevice(
           device_descriptors_->front()));
 
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
   WaitForCapturedFrame();
   device->StopAndDeAllocate();
   device.reset();
   EXPECT_EQ(last_format().frame_size.width(), 320);
   EXPECT_EQ(last_format().frame_size.height(), 240);
 }
 
-TEST_F(VideoCaptureDeviceTest, DeAllocateCameraWhileRunning) {
-  device_descriptors_ = EnumerateDeviceDescriptors();
-  if (device_descriptors_->empty()) {
-    VLOG(1) << "No camera available. Exiting test.";
-    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);
-
-  VideoCaptureParams capture_params;
-  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_));
-  // Get captured video frames.
-  WaitForCapturedFrame();
-  EXPECT_EQ(last_format().frame_size.width(), 640);
-  EXPECT_EQ(last_format().frame_size.height(), 480);
-  EXPECT_EQ(last_format().frame_rate, 30);
-  device->StopAndDeAllocate();
-}
-
-// Start the camera in 720p to capture MJPEG instead of a raw format.
+// Starts the camera in 720p to try and capture MJPEG format.
 TEST_F(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
   std::unique_ptr<VideoCaptureDeviceDescriptor> device_descriptor =
       GetFirstDeviceDescriptorSupportingPixelFormat(PIXEL_FORMAT_MJPEG);
   if (!device_descriptor) {
-    VLOG(1) << "No camera supports MJPEG format. Exiting test.";
+    DVLOG(1) << "No camera supports MJPEG format. Exiting test.";
     return;
   }
 #if defined(OS_WIN)
   base::win::Version version = base::win::GetVersion();
-  VLOG(1) << "Windows version: " << (int)version;
   if (version >= base::win::VERSION_WIN10) {
-    VLOG(1) << "Skipped on Win10: http://crbug.com/570604.";
+    VLOG(1) << "Skipped on Win10: http://crbug.com/570604, current: "
+            << static_cast<int>(version);
     return;
   }
 #endif
   std::unique_ptr<VideoCaptureDevice> device(
       video_capture_device_factory_->CreateDevice(*device_descriptor));
   ASSERT_TRUE(device);
 
   EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(1280, 720);
   capture_params.requested_format.frame_rate = 30;
   capture_params.requested_format.pixel_format = PIXEL_FORMAT_MJPEG;
   device->AllocateAndStart(capture_params, std::move(video_capture_client_));
-  // Get captured video frames.
+
   WaitForCapturedFrame();
   // Verify we get MJPEG from the device. Not all devices can capture 1280x720
   // @ 30 fps, so we don't care about the exact resolution we get.
   EXPECT_EQ(last_format().pixel_format, PIXEL_FORMAT_MJPEG);
   EXPECT_GE(static_cast<size_t>(1280 * 720),
             last_format().ImageAllocationSize());
   device->StopAndDeAllocate();
 }
 
-TEST_F(VideoCaptureDeviceTest, GetDeviceSupportedFormats) {
+TEST_F(VideoCaptureDeviceTest, NoCameraSupportsPixelFormatMax) {
   // Use PIXEL_FORMAT_MAX to iterate all device names for testing
   // GetDeviceSupportedFormats().
   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);
 }
 
-// Start the camera and take a photo.
+// Starts the camera and take a photo.
 TEST_F(VideoCaptureDeviceTest, MAYBE_TakePhoto) {
-  device_descriptors_ = EnumerateDeviceDescriptors();
-  if (device_descriptors_->empty()) {
-    VLOG(1) << "No camera available. Exiting test.";
+  if (!EnumerateAndFindUsableDevices())
     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);
 
   VideoCaptureParams capture_params;
   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_));
   WaitForCapturedFrame();
 
   VideoCaptureDevice::TakePhotoCallback scoped_callback(
       base::Bind(&MockImageCaptureClient::DoOnPhotoTaken,
                  image_capture_client_),
       media::BindToCurrentLoop(base::Bind(
           &MockImageCaptureClient::OnTakePhotoFailure, image_capture_client_)));
 
   EXPECT_CALL(*image_capture_client_.get(), OnCorrectPhotoTaken()).Times(1);
   device->TakePhoto(std::move(scoped_callback));
   WaitForCapturedFrame();
 
   device->StopAndDeAllocate();
 }
 
 };  // namespace media