Video Capture Mojo (1.4b): Implement ability to use fake device instance

services/video_capture/service_unittest.cc

 // Copyright 2016 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 "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "services/shell/public/cpp/service_test.h"
+#include "services/video_capture/mock_video_capture_device_client.h"
 #include "services/video_capture/public/interfaces/video_capture_device_factory.mojom.h"
 #include "services/video_capture/public/interfaces/video_capture_service.mojom.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::Exactly;
 using testing::_;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 
 namespace video_capture {
 
 class MockDeviceDescriptorReceiver {
  public:
   // Use forwarding method to work around gmock not supporting move-only types.
   void HandleEnumerateDeviceDescriptorsCallback(
       std::vector<mojom::VideoCaptureDeviceDescriptorPtr> descriptors) {
     OnEnumerateDeviceDescriptorsCallback(descriptors);
   }
 
   MOCK_METHOD1(
       OnEnumerateDeviceDescriptorsCallback,
       void(const std::vector<mojom::VideoCaptureDeviceDescriptorPtr>&));
 };
 
+// Basic test fixture that sets up a connection to the fake device factory.
 class VideoCaptureServiceTest : public shell::test::ServiceTest {
  public:
   VideoCaptureServiceTest()
       : shell::test::ServiceTest("exe:video_capture_unittests") {}
   ~VideoCaptureServiceTest() override {}
 
   void SetUp() override {
     ServiceTest::SetUp();
     connector()->ConnectToInterface("mojo:video_capture", &service_);
     service_->ConnectToFakeDeviceFactory(mojo::GetProxy(&factory_));
@@ skipping 31 matching lines @@
         wait_loop.Quit();
       }));
 
   factory_->EnumerateDeviceDescriptors(base::Bind(
       &MockDeviceDescriptorReceiver::HandleEnumerateDeviceDescriptorsCallback,
       base::Unretained(&descriptor_receiver_)));
   wait_loop.Run();
   ASSERT_EQ(1u, num_devices_enumerated);
 }
 
+// Tests that VideoCaptureDeviceFactory::CreateDeviceProxy() returns an error
+// code when trying to create a device for an invalid descriptor.
+TEST_F(VideoCaptureServiceTest, ErrorCodeOnCreateDeviceForInvalidDescriptor) {
+  auto invalid_descriptor = mojom::VideoCaptureDeviceDescriptor::New();
+  invalid_descriptor->device_id = "invalid";
+  invalid_descriptor->model_id = "invalid";
+  base::RunLoop wait_loop;
+  mojom::VideoCaptureDeviceProxyPtr fake_device_proxy_;
+  mojom::DeviceAccessResultCode result_code;
+  factory_->CreateDeviceProxy(
+      std::move(invalid_descriptor), mojo::GetProxy(&fake_device_proxy_),
+      base::Bind(
+          [](base::RunLoop* wait_loop, mojom::DeviceAccessResultCode* target,
+             mojom::DeviceAccessResultCode result_code) {
+            *target = result_code;
+            wait_loop->Quit();
+          },
+          &wait_loop, &result_code));
+  wait_loop.Run();
+  ASSERT_EQ(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND, result_code);
+}
+
+// Test fixture that creates a proxy to the fake device provided by the fake
+// device factory.
+class FakeDeviceVideoCaptureServiceTest : public VideoCaptureServiceTest {

[mcasas, 2016/08/30 01:20:26]

Separate this new class and associated test cases into
a file on its own, and make the file names follow the 
class plz.

[chfremer, 2016/08/30 18:22:54]

Done.

+ public:
+  FakeDeviceVideoCaptureServiceTest() : VideoCaptureServiceTest() {}
+  ~FakeDeviceVideoCaptureServiceTest() override {}
+
+  void SetUp() override {
+    VideoCaptureServiceTest::SetUp();
+
+    base::RunLoop wait_loop;
+    mojom::VideoCaptureDeviceDescriptorPtr fake_device_descriptor;
+    EXPECT_CALL(descriptor_receiver_, OnEnumerateDeviceDescriptorsCallback(_))
+        .WillOnce(Invoke([&wait_loop, &fake_device_descriptor](
+            const std::vector<mojom::VideoCaptureDeviceDescriptorPtr>&
+                descriptors) {
+          fake_device_descriptor = descriptors[0].Clone();
+          wait_loop.Quit();
+        }));
+    factory_->EnumerateDeviceDescriptors(base::Bind(
+        &MockDeviceDescriptorReceiver::HandleEnumerateDeviceDescriptorsCallback,
+        base::Unretained(&descriptor_receiver_)));
+    wait_loop.Run();
+
+    factory_->CreateDeviceProxy(
+        std::move(fake_device_descriptor), mojo::GetProxy(&fake_device_proxy_),
+        base::Bind([](mojom::DeviceAccessResultCode result_code) {
+          ASSERT_EQ(mojom::DeviceAccessResultCode::SUCCESS, result_code);
+        }));
+  }
+
+ protected:
+  mojom::VideoCaptureDeviceProxyPtr fake_device_proxy_;
+};
+
+TEST_F(FakeDeviceVideoCaptureServiceTest, FrameCallbacksArrive) {
+  auto arbitrary_requested_format = mojom::VideoCaptureFormat::New();
+  arbitrary_requested_format->frame_size.SetSize(640, 480);
+  arbitrary_requested_format->frame_rate = 15;
+  arbitrary_requested_format->pixel_format = media::mojom::VideoFormat::I420;
+  arbitrary_requested_format->pixel_storage = mojom::VideoPixelStorage::CPU;
+
+  base::RunLoop wait_loop;
+  const int kNumFramesToWaitFor = 3;
+  int num_frames_arrived = 0;
+  mojom::VideoCaptureDeviceClientPtr client_proxy;
+  MockVideoCaptureDeviceClient client(mojo::GetProxy(&client_proxy));
+  EXPECT_CALL(client, OnFrameAvailablePtr(_))
+      .WillRepeatedly(InvokeWithoutArgs(
+          [&wait_loop, &kNumFramesToWaitFor, &num_frames_arrived]() {
+            num_frames_arrived += 1;
+            if (num_frames_arrived >= kNumFramesToWaitFor) {
+              wait_loop.Quit();
+            }
+          }));
+
+  fake_device_proxy_->Start(std::move(arbitrary_requested_format),
+                            mojom::ResolutionChangePolicy::FIXED_RESOLUTION,
+                            mojom::PowerLineFrequency::DEFAULT,
+                            std::move(client_proxy));
+  wait_loop.Run();
+}
+
 }  // namespace video_capture