Release the camera when WebRTC is not visible in Android

content/browser/renderer_host/media/video_capture_manager.cc

 // Copyright (c) 2012 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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 290 matching lines @@
   if (!entry) {
     done_cb.Run(base::WeakPtr<VideoCaptureController>());
     return;
   }
 
   DCHECK(entry->video_capture_controller);
 
   LogVideoCaptureEvent(VIDEO_CAPTURE_EVENT_START_CAPTURE);
 
   // First client starts the device.
-  if (entry->video_capture_controller->GetClientCount() == 0) {
+  if (entry->video_capture_controller->GetActiveClientCount() == 0) {
     DVLOG(1) << "VideoCaptureManager starting device (type = "
              << entry->stream_type << ", id = " << entry->id << ")";
 
     device_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &VideoCaptureManager::DoStartDeviceOnDeviceThread,
             this,
             session_id,
             entry,
@@ skipping 38 matching lines @@
   // Detach client from controller.
   media::VideoCaptureSessionId session_id =
       controller->RemoveClient(client_id, client_handler);
   DVLOG(1) << "VideoCaptureManager::StopCaptureForClient, session_id = "
            << session_id;
 
   // If controller has no more clients, delete controller and device.
   DestroyDeviceEntryIfNoClients(entry);
 }
 
+void VideoCaptureManager::PauseCaptureForClient(
+    VideoCaptureController* controller,
+    VideoCaptureControllerID client_id,
+    VideoCaptureControllerEventHandler* client_handler) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(controller);
+  DCHECK(client_handler);
+  DeviceEntry* entry = GetDeviceEntryForController(controller);
+  if (!entry) {
+    NOTREACHED();
+    return;
+  }
+
+  // We only pause the MEDIA_DEVICE_VIDEO_CAPTURE entry to release camera to
+  // system.
+  if (entry->stream_type != MEDIA_DEVICE_VIDEO_CAPTURE)
+    return;
+
+  controller->PauseOrResumeClient(client_id, client_handler, true);
+  if (controller->GetActiveClientCount() != 0)
+    return;
+
+  // There is no more client, release the camera.
+  device_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
+                 base::Unretained(entry)));
+}
+
+void VideoCaptureManager::ResumeCaptureForClient(
+    media::VideoCaptureSessionId session_id,
+    const media::VideoCaptureParams& params,
+    VideoCaptureController* controller,
+    VideoCaptureControllerID client_id,
+    VideoCaptureControllerEventHandler* client_handler) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(controller);
+  DCHECK(client_handler);
+
+  DeviceEntry* entry = GetDeviceEntryForController(controller);
+  if (!entry) {
+    NOTREACHED();
+    return;
+  }
+
+  // We only pause/resume the MEDIA_DEVICE_VIDEO_CAPTURE entry.
+  if (entry->stream_type != MEDIA_DEVICE_VIDEO_CAPTURE)
+    return;
+
+  controller->PauseOrResumeClient(client_id, client_handler, false);

[Mike West, 2014/10/02 11:24:39]

Nit: The bool at the end makes this is pretty hard to read, both here and above.
Consider changing it to an enum in a future CL, 'PAUSE' or 'RESUME' would be
significantly better than 'true' and 'false'.

[michaelbai, 2014/10/02 18:55:39]

Yes, it is a little bit hard to read, but there are a lot of this kind of usage
in chromium code.

On 2014/10/02 11:24:39, Mike West (OOO until 6th) wrote:

+  if (controller->GetActiveClientCount() != 1)
+    return;
+
+  // This is first active client, allocate the camera.

[Mike West, 2014/10/02 11:24:39]

Since resuming capture assumes that the user has already granted permission for
the device, I'm worried that it might bypass those checks if a corrupted
renderer sent a "resume" message rather than a "start recording" message.

Where is the user asked to grant permission for device access? Can we assert
something here about the permission grant?

+  device_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &VideoCaptureManager::DoStartDeviceOnDeviceThread,
+          this,
+          session_id,
+          entry,
+          params,
+          base::Passed(entry->video_capture_controller->NewDeviceClient())));
+}
+
 bool VideoCaptureManager::GetDeviceSupportedFormats(
     media::VideoCaptureSessionId capture_session_id,
     media::VideoCaptureFormats* supported_formats) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(supported_formats->empty());
 
   SessionMap::iterator it = sessions_.find(capture_session_id);
   if (it == sessions_.end())
     return false;
   DVLOG(1) << "GetDeviceSupportedFormats for device: " << it->second.name;
@@ skipping 277 matching lines @@
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
   DCHECK(notification_window_ids_.find(session_id) ==
          notification_window_ids_.end());
   notification_window_ids_[session_id] = window_id;
   VLOG(2) << "Screen capture notification window saved for session "
           << session_id << " on device thread.";
 }
 
 }  // namespace content