Android: not to pause screen capture when Chrome is put to background

content/renderer/media/video_capture_impl_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.
 //
 // Implementation notes about interactions with VideoCaptureImpl.
 //
 // How is VideoCaptureImpl used:
 //
 // VideoCaptureImpl is an IO thread object while VideoCaptureImplManager
 // lives only on the render thread. It is only possible to access an
@@ skipping 28 matching lines @@
   media::VideoCaptureSessionId session_id;
 
   // To be used and destroyed only on the IO thread.
   std::unique_ptr<VideoCaptureImpl> impl;
 
   // Number of clients using |impl|.
   int client_count;
 
   // This is set to true if this device is being suspended, via
   // VideoCaptureImplManager::Suspend().
-  // See also: VideoCaptureImplManager::is_suspending_all_.
   bool is_individually_suspended;
 
   DeviceEntry()
       : session_id(0), client_count(0), is_individually_suspended(false) {}
   DeviceEntry(DeviceEntry&& other) = default;
   DeviceEntry& operator=(DeviceEntry&& other) = default;
   ~DeviceEntry() = default;
 };
 
 VideoCaptureImplManager::VideoCaptureImplManager()
     : next_client_id_(0),
       render_main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      is_suspending_all_(false),
       weak_factory_(this) {}
 
 VideoCaptureImplManager::~VideoCaptureImplManager() {
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   if (devices_.empty())
     return;
   // Forcibly release all video capture resources.
   for (auto& entry : devices_) {
     ChildProcess::current()->io_task_runner()->DeleteSoon(FROM_HERE,
                                                           entry.impl.release());
@@ skipping 71 matching lines @@
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   const auto it = std::find_if(
       devices_.begin(), devices_.end(),
       [id] (const DeviceEntry& entry) { return entry.session_id == id; });
   DCHECK(it != devices_.end());
   if (it->is_individually_suspended)
     return;  // Device has already been individually suspended.
   if (it->client_count > 1)
     return;  // Punt when there is >1 client (see comments in UseDevice()).
   it->is_individually_suspended = true;
-  if (is_suspending_all_)
-    return;  // Device should already be suspended.
   ChildProcess::current()->io_task_runner()->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureImpl::SuspendCapture,
                             base::Unretained(it->impl.get()), true));
 }
 
 void VideoCaptureImplManager::Resume(media::VideoCaptureSessionId id) {
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   const auto it = std::find_if(
       devices_.begin(), devices_.end(),
       [id] (const DeviceEntry& entry) { return entry.session_id == id; });
   DCHECK(it != devices_.end());
   if (!it->is_individually_suspended)
     return;  // Device was not individually suspended.
   it->is_individually_suspended = false;
-  if (is_suspending_all_)
-    return;  // Device must remain suspended until all are resumed.
   ChildProcess::current()->io_task_runner()->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureImpl::SuspendCapture,
                             base::Unretained(it->impl.get()), false));
 }
 
 void VideoCaptureImplManager::GetDeviceSupportedFormats(
     media::VideoCaptureSessionId id,
     const VideoCaptureDeviceFormatsCB& callback) {
   DCHECK(render_main_task_runner_->BelongsToCurrentThread());
   const auto it = std::find_if(
@@ skipping 45 matching lines @@
   DCHECK(it != devices_.end());
   DCHECK_GT(it->client_count, 0);
   --it->client_count;
   if (it->client_count > 0)
     return;
   ChildProcess::current()->io_task_runner()->DeleteSoon(FROM_HERE,
                                                         it->impl.release());
   devices_.erase(it);
 }
 
-void VideoCaptureImplManager::SuspendDevices(bool suspend) {
-  DCHECK(render_main_task_runner_->BelongsToCurrentThread());
-  if (is_suspending_all_ == suspend)
-    return;
-  is_suspending_all_ = suspend;
-  for (auto& entry : devices_) {
-    if (entry.is_individually_suspended)
-      continue;  // Either: 1) Already suspended; or 2) Should not be resumed.
-    ChildProcess::current()->io_task_runner()->PostTask(
-        FROM_HERE, base::Bind(&VideoCaptureImpl::SuspendCapture,
-                              base::Unretained(entry.impl.get()), suspend));
-  }
-}
-
 }  // namespace content