Release the camera when WebRTC is not visible in Android

content/browser/renderer_host/media/video_capture_controller.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_controller.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 85 matching lines @@
   ControllerClient(const VideoCaptureControllerID& id,
                    VideoCaptureControllerEventHandler* handler,
                    base::ProcessHandle render_process,
                    media::VideoCaptureSessionId session_id,
                    const media::VideoCaptureParams& params)
       : controller_id(id),
         event_handler(handler),
         render_process_handle(render_process),
         session_id(session_id),
         parameters(params),
-        session_closed(false) {}
+        session_closed(false),
+        paused(false) {}
 
   ~ControllerClient() {}
 
   // ID used for identifying this object.
   const VideoCaptureControllerID controller_id;
   VideoCaptureControllerEventHandler* const event_handler;
 
   // Handle to the render process that will receive the capture buffers.
   const base::ProcessHandle render_process_handle;
   const media::VideoCaptureSessionId session_id;
@@ skipping 11 matching lines @@
   // transitions to true as soon as StopSession() occurs, at which point the
   // client is sent an OnEnded() event. However, because the client retains a
   // VideoCaptureController* pointer, its ControllerClient entry lives on until
   // it unregisters itself via RemoveClient(), which may happen asynchronously.
   //
   // TODO(nick): If we changed the semantics of VideoCaptureHost so that
   // OnEnded() events were processed synchronously (with the RemoveClient() done
   // implicitly), we could avoid tracking this state here in the Controller, and
   // simplify the code in both places.
   bool session_closed;
+
+  // Indicates whether the client is paused, if true, VideoCaptureController
+  // stops updating its buffer.
+  bool paused;
 };
 
 // Receives events from the VideoCaptureDevice and posts them to a
 // VideoCaptureController on the IO thread. An instance of this class may safely
 // outlive its target VideoCaptureController.
 //
 // Methods of this class may be called from any thread, and in practice will
 // often be called on some auxiliary thread depending on the platform and the
 // device type; including, for example, the DirectShow thread on Windows, the
 // v4l2_thread on Linux, and the UI thread for tab capture.
@@ skipping 114 matching lines @@
   }
   client->active_buffers.clear();
 
   int session_id = client->session_id;
   controller_clients_.remove(client);
   delete client;
 
   return session_id;
 }
 
+void VideoCaptureController::PauseOrResumeClient(
+    const VideoCaptureControllerID& id,
+    VideoCaptureControllerEventHandler* event_handler,
+    bool pause) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DVLOG(1) << "VideoCaptureController::PauseOrResumeClient, id "
+           << id.device_id << ", " << pause;
+
+  ControllerClient* client = FindClient(id, event_handler, controller_clients_);
+  if (!client)
+    return;

[tommi (sloooow) - chröme, 2014/10/01 07:17:03]

should the event handler be notified of this somehow?

[michaelbai, 2014/10/01 22:09:33]

That's what I wondered in the first place, I think it depends on how we want to
handle pause, it seems VideoCaptureControllerEventHandler has nothing to do even
it knows video was paused.

[tommi (sloooow) - chröme, 2014/10/02 11:10:39]

Acknowledged.

+
+  client->paused = pause;
+}
+
 void VideoCaptureController::StopSession(int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::StopSession, id " << session_id;
 
   ControllerClient* client = FindClient(session_id, controller_clients_);
 
   if (client) {
     client->session_closed = true;
     client->event_handler->OnEnded(client->controller_id);
   }
@@ skipping 284 matching lines @@
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(buffer->id(), VideoCaptureBufferPool::kInvalidId);
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     for (ControllerClients::iterator client_it = controller_clients_.begin();
          client_it != controller_clients_.end(); ++client_it) {
       ControllerClient* client = *client_it;
-      if (client->session_closed)
+      if (client->session_closed || client->paused)
         continue;
 
       if (frame->format() == media::VideoFrame::NATIVE_TEXTURE) {
         client->event_handler->OnMailboxBufferReady(client->controller_id,
                                                     buffer->id(),
                                                     *frame->mailbox_holder(),
                                                     buffer_format,
                                                     timestamp);
       } else {
         bool is_new_buffer = client->known_buffers.insert(buffer->id()).second;
@@ skipping 95 matching lines @@
     }
   }
   return NULL;
 }
 
 int VideoCaptureController::GetClientCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return controller_clients_.size();
 }
 
+int VideoCaptureController::GetActiveClientCount() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  int active_client_count = 0;
+  for (ControllerClient* client : controller_clients_) {

[tommi (sloooow) - chröme, 2014/10/01 07:17:03]

oooh...! :)

[michaelbai, 2014/10/01 22:09:33]

I am happy that how simple it is :)

+    if (!client->paused)
+      active_client_count++;

[tommi (sloooow) - chröme, 2014/10/01 07:17:02]

++active_client_count

[michaelbai, 2014/10/01 22:09:33]

Done.

+  }
+  return active_client_count;
+}
+
 }  // namespace content