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

media/capture/video/chromeos/camera_hal_delegate_unittest.h

+// 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_CAMERA_HAL_DELEGATE_UNITTEST_H_
+#define MEDIA_CAPTURE_VIDEO_CHROMEOS_CAMERA_HAL_DELEGATE_UNITTEST_H_
+
+#include "media/capture/video/chromeos/camera_hal_delegate.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <utility>
+
+#include "media/capture/video/chromeos/mojo/arc_camera3.mojom.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace media {
+namespace unittest_internal {
+
+class MockCameraModule : public arc::mojom::CameraModule {
+ public:
+  MockCameraModule() : mock_module_thread_("MockModuleThread"), binding_(this) {
+    mock_module_thread_.Start();
+  }
+
+  ~MockCameraModule() {
+    mock_module_thread_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&MockCameraModule::CloseBindingOnThread,
+                              base::Unretained(this)));
+    mock_module_thread_.Stop();
+  }
+
+  void OpenDevice(int32_t camera_id, OpenDeviceCallback callback) {

[chfremer, 2017/05/26 17:40:58]

should we use the "override" keyword here (and for the other overriden methods,
including the destructor)?

[jcliang, 2017/05/31 14:58:07]

Done.

+    DoOpenDevice(camera_id, callback);
+  }
+  MOCK_METHOD2(DoOpenDevice,
+               void(int32_t camera_id, OpenDeviceCallback& callback));
+
+  void GetNumberOfCameras(GetNumberOfCamerasCallback callback) {
+    DoGetNumberOfCameras(callback);
+  }
+  MOCK_METHOD1(DoGetNumberOfCameras,
+               void(GetNumberOfCamerasCallback& callback));
+
+  void GetCameraInfo(int32_t camera_id, GetCameraInfoCallback callback) {
+    DoGetCameraInfo(camera_id, callback);
+  }
+  MOCK_METHOD2(DoGetCameraInfo,
+               void(int32_t camera_id, GetCameraInfoCallback& callback));
+
+  void SetCallbacks(arc::mojom::CameraModuleCallbacksPtr callbacks,
+                    SetCallbacksCallback callback) override {
+    DoSetCallbacks(callbacks, callback);
+    callbacks_ = std::move(callbacks);
+    std::move(callback).Run(0);
+  }
+  MOCK_METHOD2(DoSetCallbacks,
+               void(arc::mojom::CameraModuleCallbacksPtr& callbacks,
+                    SetCallbacksCallback& callback));
+
+  arc::mojom::CameraModulePtrInfo GetInterfacePtrInfo() {

[chfremer, 2017/05/26 17:40:58]

This could be simplified by just creating an instance and binding for this in
the test setup code that wants to use this.
Together with my other recommendation of using dependency injection to pass
CameraHalDelegate its |camera_module_|, this might look something like this:

class CameraHalDelegateTest : public ::testing::Test {
 public:
  CameraHalDelegateTest()
      : mock_camera_module_binding_(&mock_camera_module_),
        hal_delegate_thread_("HalDelegateThread") {}

  void SetUp() override {
    hal_delegate_thread_.Start();
    CameraModulePtr camera_module;
    mock_camera_module_binding_.Bind(mojo::MakeRequest(&camera_module));
    camera_hal_delegate_ =
        new CameraHalDelegate(hal_delegate_thread_.task_runner(),
                              std::move(camera_module));
  }

 protected:
  scoped_refptr<CameraHalDelegate> camera_hal_delegate_;
  testing::StrictMock<unittest_internal::MockCameraModule> mock_camera_module_;
  mojo::Binding<CameraModule> mock_camera_module_binding_;
};

[jcliang, 2017/05/31 14:58:07]

Would you mind if I incorporate your suggestions when I change the unit tests in
a new patch set of https://codereview.chromium.org/2878233002/? The mechanism to
establish the Mojo connection in this CL is temporary. In the end we are going
to use the ArcCamera3Service Mojo proxy in
https://codereview.chromium.org/2878233002/.

[chfremer, 2017/05/31 18:30:41]

I wouldn't mind. No need to put extra work for changing this into this CL if it
goes away anyway in your follow-up.

+    base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED);
+    arc::mojom::CameraModulePtrInfo ptr_info;
+    mock_module_thread_.task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&MockCameraModule::BindOnThread, base::Unretained(this),
+                   base::Unretained(&done), base::Unretained(&ptr_info)));
+    done.Wait();
+    return ptr_info;
+  }
+
+ private:
+  void CloseBindingOnThread() {
+    if (binding_.is_bound()) {
+      binding_.Close();
+    }
+  }
+
+  void BindOnThread(base::WaitableEvent* done,
+                    arc::mojom::CameraModulePtrInfo* ptr_info) {
+    *ptr_info = binding_.CreateInterfacePtrAndBind().PassInterface();
+    done->Signal();
+  }
+
+  base::Thread mock_module_thread_;
+  mojo::Binding<arc::mojom::CameraModule> binding_;
+  arc::mojom::CameraModuleCallbacksPtr callbacks_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockCameraModule);
+};
+
+}  // namespace unittest_internal
+}  // namespace media
+
+#endif  // MEDIA_CAPTURE_VIDEO_CHROMEOS_CAMERA_HAL_DELEGATE_UNITTEST_H_