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

services/video_capture/device_factory_media_to_mojo_adapter.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 "services/video_capture/device_factory_media_to_mojo_adapter.h"
 
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 43 matching lines @@
         continue;
       translated_device_info.supported_formats.push_back(translated_format);
     }
     if (translated_device_info.supported_formats.empty())
       continue;
     translated_device_infos.push_back(translated_device_info);
   }
   callback.Run(translated_device_infos);
 }
 
+static void DiscardDeviceInfosAndCallContinuation(
+    base::Closure continuation,
+    const std::vector<media::VideoCaptureDeviceInfo>&) {
+  continuation.Run();
+}
+
 }  // anonymous namespace
 
 namespace video_capture {
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::ActiveDeviceEntry() =
     default;
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::~ActiveDeviceEntry() =
     default;
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::ActiveDeviceEntry(
     DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&& other) = default;
 
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&
 DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry::operator=(
     DeviceFactoryMediaToMojoAdapter::ActiveDeviceEntry&& other) = default;
 
 DeviceFactoryMediaToMojoAdapter::DeviceFactoryMediaToMojoAdapter(
+    std::unique_ptr<service_manager::ServiceContextRef> service_ref,
     std::unique_ptr<media::VideoCaptureSystem> capture_system,
     const media::VideoCaptureJpegDecoderFactoryCB&
         jpeg_decoder_factory_callback)
-    : capture_system_(std::move(capture_system)),
-      jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback) {}
+    : service_ref_(std::move(service_ref)),
+      capture_system_(std::move(capture_system)),
+      jpeg_decoder_factory_callback_(jpeg_decoder_factory_callback),
+      has_called_get_device_infos_(false),
+      weak_factory_(this) {}
 
 DeviceFactoryMediaToMojoAdapter::~DeviceFactoryMediaToMojoAdapter() = default;
 
 void DeviceFactoryMediaToMojoAdapter::GetDeviceInfos(
     const GetDeviceInfosCallback& callback) {
   capture_system_->GetDeviceInfosAsync(
       base::Bind(&TranslateDeviceInfos, callback));
+  has_called_get_device_infos_ = true;
 }
 
 void DeviceFactoryMediaToMojoAdapter::CreateDevice(
     const std::string& device_id,
     mojom::DeviceRequest device_request,
     const CreateDeviceCallback& callback) {
   auto active_device_iter = active_devices_by_id_.find(device_id);
   if (active_device_iter != active_devices_by_id_.end()) {
     // The requested device is already in use.
     // Revoke the access and close the device, then bind to the new request.
     ActiveDeviceEntry& device_entry = active_device_iter->second;
     device_entry.binding->Unbind();
     device_entry.device->Stop();
     device_entry.binding->Bind(std::move(device_request));
     device_entry.binding->set_connection_error_handler(base::Bind(
         &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
         base::Unretained(this), device_id));
     callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
     return;
   }
 
+  const auto create_and_add_new_device_cb =
+      base::Bind(&DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice,
+                 weak_factory_.GetWeakPtr(), device_id,
+                 base::Passed(&device_request), callback);
+
+  if (has_called_get_device_infos_) {
+    create_and_add_new_device_cb.Run();
+    return;
+  }
+
+  capture_system_->GetDeviceInfosAsync(base::Bind(
+      &DiscardDeviceInfosAndCallContinuation, create_and_add_new_device_cb));
+}
+
+void DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice(
+    const std::string& device_id,
+    mojom::DeviceRequest device_request,
+    const CreateDeviceCallback& callback) {
   std::unique_ptr<media::VideoCaptureDevice> media_device =
       capture_system_->CreateDevice(device_id);
   if (media_device == nullptr) {
     callback.Run(mojom::DeviceAccessResultCode::ERROR_DEVICE_NOT_FOUND);
     return;
   }
 
   // Add entry to active_devices to keep track of it
   ActiveDeviceEntry device_entry;
   device_entry.device = base::MakeUnique<DeviceMediaToMojoAdapter>(
-      std::move(media_device), jpeg_decoder_factory_callback_);
+      service_ref_->Clone(), std::move(media_device),
+      jpeg_decoder_factory_callback_);
   device_entry.binding = base::MakeUnique<mojo::Binding<mojom::Device>>(
       device_entry.device.get(), std::move(device_request));
   device_entry.binding->set_connection_error_handler(base::Bind(
       &DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose,
       base::Unretained(this), device_id));
   active_devices_by_id_[device_id] = std::move(device_entry);
 
   callback.Run(mojom::DeviceAccessResultCode::SUCCESS);
 }
 
 void DeviceFactoryMediaToMojoAdapter::OnClientConnectionErrorOrClose(
     const std::string& device_id) {
   active_devices_by_id_[device_id].device->Stop();
   active_devices_by_id_.erase(device_id);
 }
 
 }  // namespace video_capture