[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 61 matching lines @@
     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),
+      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;
   }
 
+  if (!has_called_get_device_infos_) {
+    capture_system_->GetDeviceInfosAsync(base::Bind(
+        &DeviceFactoryMediaToMojoAdapter::DiscardDeviceInfosAndCallContinuation,
+        weak_factory_.GetWeakPtr(),
+        base::Bind(&DeviceFactoryMediaToMojoAdapter::CreateAndAddNewDevice,
+                   weak_factory_.GetWeakPtr(), device_id,
+                   base::Passed(&device_request), callback)));
+  } else {
+    CreateAndAddNewDevice(device_id, std::move(device_request),
+                          std::move(callback));
+  }

[mcasas, 2017/04/26 22:12:31]

This if-else reads complex, what about:

  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));


Which includes my next comment on making
DiscardDeviceInfosAndCallContinuation file-static and not member.

[chfremer, 2017/04/26 23:33:35]

Done.

+}
+
+void DeviceFactoryMediaToMojoAdapter::DiscardDeviceInfosAndCallContinuation(

[mcasas, 2017/04/26 22:12:31]

This doesn't need to be a member: make it file-static.

[chfremer, 2017/04/26 23:33:35]

Done.

+    base::Closure continuation,
+    const std::vector<media::VideoCaptureDeviceInfo>&) {
+  continuation.Run();
+}
+
+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