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

services/video_capture/service_unittest.cc

Index: services/video_capture/service_unittest.cc
diff --git a/services/video_capture/service_unittest.cc b/services/video_capture/service_unittest.cc
index c3abcf76f74ed0243e09d0c0a72d27bacd4585ef..d104ad12e389c601f4a64baebb931d8c5abfaf26 100644
--- a/services/video_capture/service_unittest.cc
+++ b/services/video_capture/service_unittest.cc
@@ -5,6 +5,7 @@
 #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"
@@ -29,6 +30,7 @@ class MockDeviceDescriptorReceiver {
       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()
@@ -80,4 +82,89 @@ TEST_F(VideoCaptureServiceTest, FakeDeviceFactoryEnumeratesOneDevice) {
   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