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

media/capture/video/chromeos/video_capture_device_arc_chromeos.h

Index: media/capture/video/chromeos/video_capture_device_arc_chromeos.h
diff --git a/media/capture/video/chromeos/video_capture_device_arc_chromeos.h b/media/capture/video/chromeos/video_capture_device_arc_chromeos.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a8938ecfa3eb539b10fc416885562c2f23dda04
--- /dev/null
+++ b/media/capture/video/chromeos/video_capture_device_arc_chromeos.h
@@ -0,0 +1,117 @@
+// 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.
+
+#ifndef MEDIA_CAPTURE_VIDEO_CHROMEOS_VIDEO_CAPTURE_DEVICE_CHROMEOS_H_
+#define MEDIA_CAPTURE_VIDEO_CHROMEOS_VIDEO_CAPTURE_DEVICE_CHROMEOS_H_
+
+#include <stdint.h>
+
+#include <memory>
+#include <string>
+
+#include "base/macros.h"
+#include "base/threading/thread.h"
+#include "media/capture/video/chromeos/mojo/arc_camera3.mojom.h"
+#include "media/capture/video/video_capture_device.h"
+#include "media/capture/video/video_capture_device_descriptor.h"
+#include "media/capture/video_capture_types.h"
+
+namespace display {
+
+class Display;
+
+}  // namespace display
+
+namespace media {
+
+class CameraHalDelegate;
+class CameraDeviceDelegate;
+
+// Implementation of VideoCaptureDevice for ChromeOS with ARC++ camera HALv3.
+class CAPTURE_EXPORT VideoCaptureDeviceArcChromeOS final
+    : public VideoCaptureDevice {
+ public:
+  // Converts the HAL pixel format |from| to Chromium pixel format.  Returns
+  // PIXEL_FORMAT_UNKNOWN if |from| is not supported.
+  static VideoPixelFormat PixFormatHalToChromium(
+      arc::mojom::HalPixelFormat from);
+
+  // Converts the Chromium pixel format |from| to DRM pixel format.  Returns 0
+  // if |from| is not supported.
+  static uint32_t PixFormatChromiumToDrm(VideoPixelFormat from);
+
+  VideoCaptureDeviceArcChromeOS(
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      const VideoCaptureDeviceDescriptor& device_descriptor,
+      scoped_refptr<CameraHalDelegate> camera_hal_delegate);
+
+  ~VideoCaptureDeviceArcChromeOS() final;
+
+  // VideoCaptureDevice implementation.
+  void AllocateAndStart(const VideoCaptureParams& params,
+                        std::unique_ptr<Client> client) final;
+  void StopAndDeAllocate() final;
+  void TakePhoto(TakePhotoCallback callback) final;
+  void GetPhotoCapabilities(GetPhotoCapabilitiesCallback callback) final;
+  void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
+                       SetPhotoOptionsCallback callback) final;
+
+ private:
+  // Internal methods which AllocateAndStart depends on to create a camera
+  // device.  OnGotCameraInfo and OnOpenDevice are callbacks provided to the
+  // |camera_hal_delegate_| Mojo IPC calls, and are run on the
+  // |module_task_runner_| of |camera_hal_delegate_|.
+  void OnGotCameraInfo(const VideoCaptureParams& params,
+                       std::unique_ptr<Client> client,
+                       base::WaitableEvent* started,
+                       int32_t result,
+                       arc::mojom::CameraInfoPtr camera_info);
+  void OnOpenedDevice(const VideoCaptureParams& params,
+                      std::unique_ptr<Client> client,
+                      base::WaitableEvent* started,
+                      arc::mojom::CameraMetadataPtr static_metadata,
+                      int32_t result,
+                      arc::mojom::Camera3DeviceOpsPtr device_ops);
+
+  const VideoCaptureDeviceDescriptor device_descriptor_;
+
+  // A reference to the CameraHalDelegate instance in the VCD factory.  This is
+  // used by AllocateAndStart to query camera info and create the camera device.
+  const scoped_refptr<CameraHalDelegate> camera_hal_delegate_;
+
+  // A reference to the thread that all the VideoCaptureDevice interface methods
+  // are called.
+  const scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner_;
+
+  // The thread that all the Mojo operations of |camera_device_delegate_| take
+  // place.  Started in CreateDeviceOnCaptureThread and stopped in
+  // StopAndDeAllocate, where the access to the base::Thread methods are
+  // sequenced on |capture_task_runner_|.
+  base::Thread device_thread_;
+
+  // Internal delegate doing the actual capture setting, buffer allocation and
+  // circulation with the camera HAL. Created on |module_task_runner_| of
+  // |camera_hal_delegate_| in OnOpenedDevice and deleted in StopAndDeAllocate
+  // on |capture_task_runner_|.  The creation and deletion of
+  // |camera_device_delegate_| is serialized through a WaitableEvent.
+  // All methods of |camera_device_delegate_| operate on |device_thread_|.
+  scoped_refptr<CameraDeviceDelegate> camera_device_delegate_;
+
+  class ScreenObserverDelegate;
+
+  void SetRotation(int rotation);
+  void SetDisplayRotation(const display::Display& display);
+
+  scoped_refptr<ScreenObserverDelegate> screen_observer_delegate_;
+  const VideoFacingMode lens_facing_;
+  const int camera_orientation_;
+  // Whether the incoming frames should rotate when the device rotates.
+  const bool rotates_with_device_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(VideoCaptureDeviceArcChromeOS);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_CAPTURE_VIDEO_CHROMEOS_VIDEO_CAPTURE_DEVICE_CHROMEOS_H_