Video Capture Mojo (1.4a.a): Add service configurator interface

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/public/interfaces/fake_video_capture_device_factory_configurator.mojom.h"
 #include "services/video_capture/public/interfaces/video_capture_device_factory.mojom.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 {
 
-ACTION_P(RunClosure, closure) {
-  closure.Run();
-}
-
-class MockClient {
+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>&));
 };
 
+void HandleAddFakeVideoCaptureDeviceCallback(
+    base::RunLoop* loop,
+    mojom::VideoCaptureDeviceDescriptorPtr* out_descriptor,
+    mojom::VideoCaptureDeviceDescriptorPtr in_descriptor) {
+  *out_descriptor = std::move(in_descriptor);
+  loop->Quit();
+}
+
 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", &factory_);
+    connector()->ConnectToInterface("mojo:video_capture", &service_);
+    service_->ConnectToFakeDeviceFactory(mojo::GetProxy(&factory_));
+    service_->ConnectToFakeDeviceFactoryConfigurator(
+        mojo::GetProxy(&configurator_));
   }
 
  protected:
+  mojom::VideoCaptureDeviceDescriptorPtr AddFakeCaptureDevice() {
+    mojom::VideoCaptureDeviceDescriptorPtr fake_device_descriptor;
+    base::RunLoop wait_loop;
+    configurator_->AddFakeVideoCaptureDevice(
+        base::Bind(HandleAddFakeVideoCaptureDeviceCallback, &wait_loop,
+                   &fake_device_descriptor));
+    wait_loop.Run();
+    return fake_device_descriptor;
+  }
+
+  mojom::VideoCaptureServicePtr service_;
+  mojom::FakeVideoCaptureDeviceFactoryConfiguratorPtr configurator_;
   mojom::VideoCaptureDeviceFactoryPtr factory_;
-  MockClient client_;
+  MockDeviceDescriptorReceiver descriptor_receiver_;
 };
 
 // Tests that an answer arrives from the service when calling
 // EnumerateDeviceDescriptors().
 TEST_F(VideoCaptureServiceTest, EnumerateDeviceDescriptorsCallbackArrives) {
   base::RunLoop wait_loop;
-  EXPECT_CALL(client_, OnEnumerateDeviceDescriptorsCallback(_))
+  EXPECT_CALL(descriptor_receiver_, OnEnumerateDeviceDescriptorsCallback(_))
       .Times(Exactly(1))
-      .WillOnce(RunClosure(wait_loop.QuitClosure()));
+      .WillOnce(InvokeWithoutArgs([&wait_loop]() { wait_loop.Quit(); }));
+  ;
 
-  factory_->EnumerateDeviceDescriptors(
-      base::Bind(&MockClient::HandleEnumerateDeviceDescriptorsCallback,
-                 base::Unretained(&client_)));
+  factory_->EnumerateDeviceDescriptors(base::Bind(
+      &MockDeviceDescriptorReceiver::HandleEnumerateDeviceDescriptorsCallback,
+      base::Unretained(&descriptor_receiver_)));
   wait_loop.Run();
 }
 
+TEST_F(VideoCaptureServiceTest, FakeCaptureDeviceGetsEnumerated) {
+  auto fake_device_descriptor = AddFakeCaptureDevice();
+
+  base::RunLoop wait_loop;
+  EXPECT_CALL(descriptor_receiver_, OnEnumerateDeviceDescriptorsCallback(_))
+      .Times(Exactly(1))
+      .WillOnce(Invoke([&fake_device_descriptor, &wait_loop](
+          const std::vector<mojom::VideoCaptureDeviceDescriptorPtr>&
+              descriptors) {
+        bool fake_device_found = false;
+        for (const auto& descriptor : descriptors) {
+          if (descriptor->device_id == fake_device_descriptor->device_id) {
+            fake_device_found = true;
+            break;
+          }
+        }
+        ASSERT_TRUE(fake_device_found);
+        wait_loop.Quit();
+      }));
+
+  factory_->EnumerateDeviceDescriptors(base::Bind(
+      &MockDeviceDescriptorReceiver::HandleEnumerateDeviceDescriptorsCallback,
+      base::Unretained(&descriptor_receiver_)));
+  wait_loop.Run();
+}
+
 }  // namespace video_capture