[Mojo Video Capture] Stop service when last client disconnects.

services/video_capture/device_factory_provider_impl.cc

Index: services/video_capture/device_factory_provider_impl.cc
diff --git a/services/video_capture/service_impl.cc b/services/video_capture/device_factory_provider_impl.cc
similarity index 59%
copy from services/video_capture/service_impl.cc
copy to services/video_capture/device_factory_provider_impl.cc
index cb1b98d9578e46bc5bbf4a423bca9f6b24b71a80..3d4d7c310d5c6af5a45f85bd9b86d4ffe2fba922 100644
--- a/services/video_capture/service_impl.cc
+++ b/services/video_capture/device_factory_provider_impl.cc
@@ -1,11 +1,10 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// 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 "services/video_capture/service_impl.h"
+#include "services/video_capture/device_factory_provider_impl.h"
 
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "media/capture/video/fake_video_capture_device_factory.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video/video_capture_buffer_tracker.h"
@@ -26,54 +25,51 @@ std::unique_ptr<media::VideoCaptureJpegDecoder> CreateJpegDecoder() {
 
 namespace video_capture {
 
-ServiceImpl::ServiceImpl() {
-  registry_.AddInterface<mojom::Service>(this);
-}
-
-ServiceImpl::~ServiceImpl() = default;
-
-void ServiceImpl::OnBindInterface(
-    const service_manager::ServiceInfo& source_info,
-    const std::string& interface_name,
-    mojo::ScopedMessagePipeHandle interface_pipe) {
-  registry_.BindInterface(source_info.identity, interface_name,
-                          std::move(interface_pipe));
-}
+DeviceFactoryProviderImpl::DeviceFactoryProviderImpl(
+    std::unique_ptr<service_manager::ServiceContextRef> service_ref,
+    base::Callback<void(float)> set_shutdown_delay_cb)
+    : service_ref_(std::move(service_ref)),
+      set_shutdown_delay_cb_(std::move(set_shutdown_delay_cb)) {}
 
-void ServiceImpl::Create(const service_manager::Identity& remote_identity,
-                         mojom::ServiceRequest request) {
-  service_bindings_.AddBinding(this, std::move(request));
-}
+DeviceFactoryProviderImpl::~DeviceFactoryProviderImpl() {}
 
-void ServiceImpl::ConnectToDeviceFactory(mojom::DeviceFactoryRequest request) {
+void DeviceFactoryProviderImpl::ConnectToDeviceFactory(
+    mojom::DeviceFactoryRequest request) {
   LazyInitializeDeviceFactory();
   factory_bindings_.AddBinding(device_factory_.get(), std::move(request));
 }
 
-void ServiceImpl::ConnectToFakeDeviceFactory(
+void DeviceFactoryProviderImpl::ConnectToFakeDeviceFactory(
     mojom::DeviceFactoryRequest request) {
   LazyInitializeFakeDeviceFactory();
   fake_factory_bindings_.AddBinding(fake_device_factory_.get(),
                                     std::move(request));
 }
 
-void ServiceImpl::LazyInitializeDeviceFactory() {
+void DeviceFactoryProviderImpl::SetShutdownDelayInSeconds(float seconds) {
+  set_shutdown_delay_cb_.Run(seconds);
+}
+
+void DeviceFactoryProviderImpl::LazyInitializeDeviceFactory() {
   if (device_factory_)
     return;
 
   // Create the platform-specific device factory.
-  // Task runner does not seem to actually be used.
+  // The task runner passed to CreateFactory is used for things that need to
+  // happen on a "UI thread equivalent", e.g. obtaining screen rotation on
+  // Chrome OS.
   std::unique_ptr<media::VideoCaptureDeviceFactory> media_device_factory =
       media::VideoCaptureDeviceFactory::CreateFactory(
-          base::MessageLoop::current()->task_runner());
+          base::ThreadTaskRunnerHandle::Get());
   auto video_capture_system = base::MakeUnique<media::VideoCaptureSystemImpl>(
       std::move(media_device_factory));
 
   device_factory_ = base::MakeUnique<DeviceFactoryMediaToMojoAdapter>(
-      std::move(video_capture_system), base::Bind(CreateJpegDecoder));
+      service_ref_->Clone(), std::move(video_capture_system),
+      base::Bind(CreateJpegDecoder));
 }
 
-void ServiceImpl::LazyInitializeFakeDeviceFactory() {
+void DeviceFactoryProviderImpl::LazyInitializeFakeDeviceFactory() {
   if (fake_device_factory_)
     return;
 
@@ -82,7 +78,8 @@ void ServiceImpl::LazyInitializeFakeDeviceFactory() {
       base::MakeUnique<media::VideoCaptureSystemImpl>(std::move(factory));
 
   fake_device_factory_ = base::MakeUnique<DeviceFactoryMediaToMojoAdapter>(
-      std::move(video_capture_system), base::Bind(&CreateJpegDecoder));
+      service_ref_->Clone(), std::move(video_capture_system),
+      base::Bind(&CreateJpegDecoder));
 }
 
 }  // namespace video_capture