media: add video capture device for ARC++ camera HAL v3

media/capture/video/chromeos/video_capture_device_factory_chromeos.cc

+// Copyright 2017 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/chromeos/video_capture_device_factory_chromeos.h"
+
+#include "base/files/file_util.h"
+#include "media/capture/video/linux/video_capture_device_factory_linux.h"
+
+namespace media {
+
+VideoCaptureDeviceFactoryChromeOS::VideoCaptureDeviceFactoryChromeOS(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_for_screen_observer)
+    : task_runner_for_screen_observer_(task_runner_for_screen_observer),
+      camera_hal_ipc_thread_("CameraHalIpcThread") {}
+
+VideoCaptureDeviceFactoryChromeOS::~VideoCaptureDeviceFactoryChromeOS() {
+  camera_hal_delegate_->Reset();
+  camera_hal_ipc_thread_.Stop();
+}
+
+bool VideoCaptureDeviceFactoryChromeOS::Init() {
+  if (!camera_hal_ipc_thread_.Start()) {
+    LOG(ERROR) << "Module thread failed to start";
+    return false;
+  }
+  camera_hal_delegate_ =
+      new CameraHalDelegate(camera_hal_ipc_thread_.task_runner());
+  return camera_hal_delegate_->StartCameraModuleIpc();
+}
+
+std::unique_ptr<VideoCaptureDevice>
+VideoCaptureDeviceFactoryChromeOS::CreateDevice(
+    const VideoCaptureDeviceDescriptor& device_descriptor) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(camera_hal_delegate_);
+  return camera_hal_delegate_->CreateDevice(task_runner_for_screen_observer_,
+                                            device_descriptor);
+}
+
+void VideoCaptureDeviceFactoryChromeOS::GetSupportedFormats(
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    VideoCaptureFormats* supported_formats) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(camera_hal_delegate_);
+  camera_hal_delegate_->GetSupportedFormats(device_descriptor,
+                                            supported_formats);
+}
+
+void VideoCaptureDeviceFactoryChromeOS::GetDeviceDescriptors(
+    VideoCaptureDeviceDescriptors* device_descriptors) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(camera_hal_delegate_);
+  camera_hal_delegate_->GetDeviceDescriptors(device_descriptors);
+}
+
+#if defined(OS_CHROMEOS)
+const base::FilePath kArcCamera3Service("/usr/bin/arc_camera3_service");
+
+// static
+VideoCaptureDeviceFactory*
+VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(

[Pawel Osciak, 2017/06/13 08:40:16]

What would you think about naming the current VideoCaptureDeviceFactoryChromeOS
something like "VideoCaptureDeviceFactoryAndroidHal" or similar instead, and
maybe even having it on the same level as VideoCaptureDeviceFactoryLinux to
avoid confusion and emphasize both are used depending on the existence of the
Hal service?

Something like:

VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory() {
  if (base::PathExists(kArcCamera3Service)) {
     return new VideoCaptureDeviceFactoryAndroidHal(...);
  } else {
     return new VideoCaptureDeviceFactoryLinux(...);
  }
}

[jcliang, 2017/06/14 04:46:08]

IMO VideoCaptureDeviceFactoryAndroidHal is a bit inaccurate. We're using the
Android HAL v3 API but the HAL implementation is quite different from the one
usable on a Android device. Also I think it's a convention to make the factory
class with the platform name as suffix.

I've added some comments here to document the behavior to make it clear that we
have to support two use cases.

[Pawel Osciak, 2017/06/14 09:07:43]

Acknowledged.

+    scoped_refptr<base::SingleThreadTaskRunner>
+        task_runner_for_screen_observer) {
+  if (base::PathExists(kArcCamera3Service)) {
+    auto factory = base::MakeUnique<VideoCaptureDeviceFactoryChromeOS>(
+        task_runner_for_screen_observer);
+    if (!factory->Init()) {
+      return nullptr;
+    }
+    return factory.release();
+  } else {
+    return new VideoCaptureDeviceFactoryLinux(task_runner_for_screen_observer);
+  }
+}
+#endif
+
+}  // namespace media