[Mojo Video Capture] Hook up connection lost events

content/browser/renderer_host/media/service_video_capture_device_launcher_unittest.cc

 // 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.
 
 #include "content/browser/renderer_host/media/service_video_capture_device_launcher.h"
 
 #include "base/run_loop.h"
 #include "base/test/mock_callback.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread.h"
+#include "content/browser/renderer_host/media/service_launched_video_capture_device.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/video_capture/public/interfaces/device_factory.mojom.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::_;
 
 namespace content {
@@ skipping 50 matching lines @@
   void RunLaunchingDeviceIsAbortedTest(
       video_capture::mojom::DeviceAccessResultCode service_result_code);
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   MockDeviceFactory mock_device_factory_;
   MockVideoCaptureDeviceLauncherCallbacks mock_callbacks_;
   video_capture::mojom::DeviceFactoryPtr device_factory_;
   std::unique_ptr<mojo::Binding<video_capture::mojom::DeviceFactory>>
       factory_binding_;
   std::unique_ptr<ServiceVideoCaptureDeviceLauncher> launcher_;
-  base::MockCallback<base::OnceClosure> done_cb;
+  base::MockCallback<base::OnceClosure> connection_lost_cb_;
+  base::MockCallback<base::OnceClosure> done_cb_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceVideoCaptureDeviceLauncherTest);
 };
 
 TEST_F(ServiceVideoCaptureDeviceLauncherTest, LaunchingDeviceSucceeds) {
   base::RunLoop run_loop;
 
   EXPECT_CALL(mock_device_factory_, DoCreateDevice(kStubDeviceId, _, _))
       .WillOnce(Invoke([](const std::string& device_id,
@@ skipping 10 matching lines @@
                    const video_capture::mojom::DeviceFactory::
                        CreateDeviceCallback& callback) {
                   callback.Run(
                       video_capture::mojom::DeviceAccessResultCode::SUCCESS);
                 },
                 base::Passed(device_request), callback));
       }));
   EXPECT_CALL(mock_callbacks_, DoOnDeviceLaunched(_)).Times(1);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchAborted()).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchFailed()).Times(0);
-  EXPECT_CALL(done_cb, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
+  EXPECT_CALL(connection_lost_cb_, Run()).Times(0);
+  EXPECT_CALL(done_cb_, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
     run_loop.Quit();
   }));
 
   // Exercise
   launcher_->LaunchDeviceAsync(
       kStubDeviceId, content::MEDIA_DEVICE_VIDEO_CAPTURE, kArbitraryParams,
-      kNullReceiver, &mock_callbacks_, done_cb.Get());
+      kNullReceiver, connection_lost_cb_.Get(), &mock_callbacks_,
+      done_cb_.Get());
 
   run_loop.Run();
 }
 
 TEST_F(ServiceVideoCaptureDeviceLauncherTest,
        LaunchingDeviceIsAbortedBeforeServiceRespondsWithSuccess) {
   RunLaunchingDeviceIsAbortedTest(
       video_capture::mojom::DeviceAccessResultCode::SUCCESS);
 }
 
@@ skipping 28 matching lines @@
                const video_capture::mojom::DeviceFactory::CreateDeviceCallback&
                    callback,
                video_capture::mojom::DeviceAccessResultCode
                    service_result_code) { callback.Run(service_result_code); },
             base::Passed(device_request), callback, service_result_code);
         step_1_run_loop.Quit();
       }));
   EXPECT_CALL(mock_callbacks_, DoOnDeviceLaunched(_)).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchAborted()).Times(1);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchFailed()).Times(0);
-  EXPECT_CALL(done_cb, Run()).WillOnce(InvokeWithoutArgs([&step_2_run_loop]() {
+  EXPECT_CALL(connection_lost_cb_, Run()).Times(0);
+  EXPECT_CALL(done_cb_, Run()).WillOnce(InvokeWithoutArgs([&step_2_run_loop]() {
     step_2_run_loop.Quit();
   }));
 
   // Exercise
   launcher_->LaunchDeviceAsync(
       kStubDeviceId, content::MEDIA_DEVICE_VIDEO_CAPTURE, kArbitraryParams,
-      kNullReceiver, &mock_callbacks_, done_cb.Get());
+      kNullReceiver, connection_lost_cb_.Get(), &mock_callbacks_,
+      done_cb_.Get());
   step_1_run_loop.Run();
   launcher_->AbortLaunch();
 
   create_device_success_answer_cb.Run();
   step_2_run_loop.Run();
 }
 
 TEST_F(ServiceVideoCaptureDeviceLauncherTest,
        LaunchingDeviceFailsBecauseDeviceNotFound) {
   base::RunLoop run_loop;
@@ skipping 15 matching lines @@
                            CreateDeviceCallback& callback) {
                       callback.Run(
                           video_capture::mojom::DeviceAccessResultCode::
                               ERROR_DEVICE_NOT_FOUND);
                     },
                     base::Passed(device_request), callback));
           }));
   EXPECT_CALL(mock_callbacks_, DoOnDeviceLaunched(_)).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchAborted()).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchFailed()).Times(1);
-  EXPECT_CALL(done_cb, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
+  EXPECT_CALL(connection_lost_cb_, Run()).Times(0);
+  EXPECT_CALL(done_cb_, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
     run_loop.Quit();
   }));
 
   // Exercise
   launcher_->LaunchDeviceAsync(
       kStubDeviceId, content::MEDIA_DEVICE_VIDEO_CAPTURE, kArbitraryParams,
-      kNullReceiver, &mock_callbacks_, done_cb.Get());
+      kNullReceiver, connection_lost_cb_.Get(), &mock_callbacks_,
+      done_cb_.Get());
 
   run_loop.Run();
 }
 
 TEST_F(ServiceVideoCaptureDeviceLauncherTest,
        LaunchingDeviceFailsBecauseFactoryIsUnbound) {
   base::RunLoop run_loop;
 
   EXPECT_CALL(mock_callbacks_, DoOnDeviceLaunched(_)).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchAborted()).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchFailed()).Times(1);
-  EXPECT_CALL(done_cb, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
+  EXPECT_CALL(connection_lost_cb_, Run()).Times(0);
+  EXPECT_CALL(done_cb_, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
     run_loop.Quit();
   }));
 
   // Exercise
   device_factory_.reset();
   launcher_->LaunchDeviceAsync(
       kStubDeviceId, content::MEDIA_DEVICE_VIDEO_CAPTURE, kArbitraryParams,
-      kNullReceiver, &mock_callbacks_, done_cb.Get());
+      kNullReceiver, connection_lost_cb_.Get(), &mock_callbacks_,
+      done_cb_.Get());
 
   run_loop.Run();
 }
 
 TEST_F(ServiceVideoCaptureDeviceLauncherTest,
        LaunchingDeviceFailsBecauseConnectionLostWhileLaunching) {
   base::RunLoop run_loop;
 
   video_capture::mojom::DeviceFactory::CreateDeviceCallback create_device_cb;
   EXPECT_CALL(mock_device_factory_, DoCreateDevice(kStubDeviceId, _, _))
       .WillOnce(Invoke(
           [&create_device_cb](
               const std::string& device_id,
               video_capture::mojom::DeviceRequest* device_request,
               const video_capture::mojom::DeviceFactory::CreateDeviceCallback&
                   callback) {
             // Simulate connection lost by not invoking |callback| and releasing
             // |device_request|. We have to save |callback| and invoke it later
             // to avoid hitting a DCHECK.
             create_device_cb = callback;
           }));
   EXPECT_CALL(mock_callbacks_, DoOnDeviceLaunched(_)).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchAborted()).Times(0);
   EXPECT_CALL(mock_callbacks_, OnDeviceLaunchFailed()).Times(1);
-  EXPECT_CALL(done_cb, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
+  // Note: |connection_lost_cb_| is only meant to be called when the connection
+  // to a successfully-launched device is lost, which is not the case here.
+  EXPECT_CALL(connection_lost_cb_, Run()).Times(0);
+  EXPECT_CALL(done_cb_, Run()).WillOnce(InvokeWithoutArgs([&run_loop]() {
     run_loop.Quit();
   }));
 
   // Exercise
   launcher_->LaunchDeviceAsync(
       kStubDeviceId, content::MEDIA_DEVICE_VIDEO_CAPTURE, kArbitraryParams,
-      kNullReceiver, &mock_callbacks_, done_cb.Get());
+      kNullReceiver, connection_lost_cb_.Get(), &mock_callbacks_,
+      done_cb_.Get());
 
   run_loop.Run();
 
   // Cut the connection to the factory, so that the outstanding
   // |create_device_cb| will be dropped.
   factory_binding_.reset();
   // We have to invoke the callback, because not doing so triggers a DCHECK.
   const video_capture::mojom::DeviceAccessResultCode arbitrary_result_code =
       video_capture::mojom::DeviceAccessResultCode::SUCCESS;
   create_device_cb.Run(arbitrary_result_code);
 }
 
+TEST_F(ServiceVideoCaptureDeviceLauncherTest,
+       ConnectionLostAfterSuccessfulLaunch) {
+  video_capture::mojom::DeviceRequest device_request_owned_by_service;
+  EXPECT_CALL(mock_device_factory_, DoCreateDevice(kStubDeviceId, _, _))
+      .WillOnce(Invoke([&device_request_owned_by_service](
+                           const std::string& device_id,
+                           video_capture::mojom::DeviceRequest* device_request,
+                           const video_capture::mojom::DeviceFactory::
+                               CreateDeviceCallback& callback) {
+        // The service holds on to the |device_request|.
+        device_request_owned_by_service = std::move(*device_request);
+        base::ThreadTaskRunnerHandle::Get()->PostTask(
+            FROM_HERE,
+            base::Bind(
+                [](const video_capture::mojom::DeviceFactory::
+                       CreateDeviceCallback& callback) {
+                  callback.Run(
+                      video_capture::mojom::DeviceAccessResultCode::SUCCESS);
+                },
+                callback));
+      }));
+  std::unique_ptr<LaunchedVideoCaptureDevice> launched_device;
+  EXPECT_CALL(mock_callbacks_, DoOnDeviceLaunched(_))
+      .WillOnce(
+          Invoke([&launched_device](
+                     std::unique_ptr<LaunchedVideoCaptureDevice>* device) {
+            // We must keep the launched device alive, because otherwise it will
+            // no longer listen for connection errors.
+            launched_device = std::move(*device);
+          }));
+  base::RunLoop step_1_run_loop;
+  EXPECT_CALL(done_cb_, Run()).WillOnce(InvokeWithoutArgs([&step_1_run_loop]() {
+    step_1_run_loop.Quit();
+  }));
+  // Exercise step 1
+  launcher_->LaunchDeviceAsync(
+      kStubDeviceId, content::MEDIA_DEVICE_VIDEO_CAPTURE, kArbitraryParams,
+      kNullReceiver, connection_lost_cb_.Get(), &mock_callbacks_,
+      done_cb_.Get());
+  step_1_run_loop.Run();
+
+  base::RunLoop step_2_run_loop;
+  EXPECT_CALL(connection_lost_cb_, Run()).WillOnce(Invoke([&step_2_run_loop]() {
+    step_2_run_loop.Quit();
+  }));
+  // Exercise step 2: The service cuts/loses the connection
+  device_request_owned_by_service = nullptr;
+  step_2_run_loop.Run();
+}
+
 }  // namespace content