Screen Video Capture: Implement suspend optimization.

content/browser/media/capture/web_contents_video_capture_device.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: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the client's
@@ skipping 43 matching lines @@
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/cursor_renderer.h"
 #include "content/browser/media/capture/web_contents_tracker.h"
@@ skipping 183 matching lines @@
  public:
   WebContentsCaptureMachine(int render_process_id,
                             int main_render_frame_id,
                             bool enable_auto_throttling);
   ~WebContentsCaptureMachine() override;
 
   // VideoCaptureMachine overrides.
   void Start(const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
              const media::VideoCaptureParams& params,
              const base::Callback<void(bool)> callback) override;
+  void Suspend() override;
+  void Resume() override;
   void Stop(const base::Closure& callback) override;
   bool IsAutoThrottlingEnabled() const override {
     return auto_throttling_enabled_;
   }
   void MaybeCaptureForRefresh() override;
 
   // Starts a copy from the backing store or the composited surface. Must be run
   // on the UI BrowserThread. |deliver_frame_cb| will be run when the operation
   // completes. The copy will occur to |target|.
   //
   // This may be used as a ContentCaptureSubscription::CaptureCallback.
   void Capture(const base::TimeTicks& start_time,
                const scoped_refptr<media::VideoFrame>& target,
                const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
                    deliver_frame_cb);
 
  private:
   bool InternalStart(
       const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
       const media::VideoCaptureParams& params);
+  void InternalSuspend();
+  void InternalResume();
   void InternalStop(const base::Closure& callback);
   void InternalMaybeCaptureForRefresh();
   bool IsStarted() const;
 
   // Computes the preferred size of the target RenderWidget for optimal capture.
   gfx::Size ComputeOptimalViewSize() const;
 
   // Response callback for RenderWidgetHost::CopyFromBackingStore().
   void DidCopyFromBackingStore(
       const base::TimeTicks& start_time,
@@ skipping 41 matching lines @@
   // Video capture parameters that this machine is started with.
   media::VideoCaptureParams capture_params_;
 
   // Last known RenderView size.
   gfx::Size last_view_size_;
 
   // Responsible for forwarding events from the active RenderWidgetHost to the
   // oracle, and initiating captures accordingly.
   std::unique_ptr<ContentCaptureSubscription> subscription_;
 
+  // False while frame capture has been suspended. This prevents subscriptions
+  // from being created by RenewFrameSubscription() until frame capture is
+  // resumed.
+  bool frame_capture_active_;
+
   // Weak pointer factory used to invalidate callbacks.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<WebContentsCaptureMachine> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsCaptureMachine);
 };
 
 bool FrameSubscriber::ShouldCaptureFrame(
     const gfx::Rect& damage_rect,
     base::TimeTicks present_time,
@@ skipping 253 matching lines @@
 }
 
 WebContentsCaptureMachine::WebContentsCaptureMachine(
     int render_process_id,
     int main_render_frame_id,
     bool enable_auto_throttling)
     : initial_render_process_id_(render_process_id),
       initial_main_render_frame_id_(main_render_frame_id),
       tracker_(new WebContentsTracker(true)),
       auto_throttling_enabled_(enable_auto_throttling),
+      frame_capture_active_(true),
       weak_ptr_factory_(this) {
   DVLOG(1) << "Created WebContentsCaptureMachine for " << render_process_id
            << ':' << main_render_frame_id
            << (auto_throttling_enabled_ ? " with auto-throttling enabled" : "");
 }
 
 WebContentsCaptureMachine::~WebContentsCaptureMachine() {}
 
 bool WebContentsCaptureMachine::IsStarted() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 30 matching lines @@
   }
 
   // Note: Creation of the first WeakPtr in the following statement will cause
   // IsStarted() to return true from now on.
   tracker_->SetResizeChangeCallback(
       base::Bind(&WebContentsCaptureMachine::UpdateCaptureSize,
                  weak_ptr_factory_.GetWeakPtr()));
   tracker_->Start(initial_render_process_id_, initial_main_render_frame_id_,
                   base::Bind(&WebContentsCaptureMachine::RenewFrameSubscription,
                              weak_ptr_factory_.GetWeakPtr()));
+  if (WebContents* contents = tracker_->web_contents())
+    contents->IncrementCapturerCount(ComputeOptimalViewSize());
 
   return true;
 }
 
+void WebContentsCaptureMachine::Suspend() {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&WebContentsCaptureMachine::InternalSuspend,
+                 base::Unretained(this)));
+}
+
+void WebContentsCaptureMachine::InternalSuspend() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!frame_capture_active_)
+    return;
+  frame_capture_active_ = false;
+  if (IsStarted())
+    RenewFrameSubscription(true);
+}
+
+void WebContentsCaptureMachine::Resume() {
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(&WebContentsCaptureMachine::InternalResume,
+                                     base::Unretained(this)));
+}
+
+void WebContentsCaptureMachine::InternalResume() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (frame_capture_active_)
+    return;
+  frame_capture_active_ = true;
+  if (IsStarted())
+    RenewFrameSubscription(true);
+}
+
 void WebContentsCaptureMachine::Stop(const base::Closure& callback) {
   // Stops the capture machine asynchronously.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(&WebContentsCaptureMachine::InternalStop,
                                      base::Unretained(this), callback));
 }
 
 void WebContentsCaptureMachine::InternalStop(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!IsStarted()) {
     callback.Run();
     return;
   }
 
   // The following cancels any outstanding callbacks and causes IsStarted() to
   // return false from here onward.
   weak_ptr_factory_.InvalidateWeakPtrs();
 
-  // Note: RenewFrameSubscription() must be called before stopping |tracker_| so
-  // the web_contents() can be notified that the capturing is ending.
   RenewFrameSubscription(false);
+  if (WebContents* contents = tracker_->web_contents())
+    contents->DecrementCapturerCount();
   tracker_->Stop();
 
   // The render thread cannot be stopped on the UI thread, so post a message
   // to the thread pool used for blocking operations.
   if (render_thread_) {
     BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(&DeleteOnWorkerThread,
                               base::Passed(&render_thread_), callback));
   }
 }
@@ skipping 170 matching lines @@
   deliver_frame_cb.Run(start_time, region_in_frame, success);
 }
 
 void WebContentsCaptureMachine::RenewFrameSubscription(bool had_target) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   RenderWidgetHost* const rwh =
       had_target ? tracker_->GetTargetRenderWidgetHost() : nullptr;
 
   // Always destroy the old subscription before creating a new one.
-  const bool had_subscription = !!subscription_;
-  subscription_.reset();
-
-  DVLOG(1) << "Renewing frame subscription to RWH@" << rwh
-           << ", had_subscription=" << had_subscription;
+  if (subscription_) {
+    DVLOG(1) << "Cancelling existing ContentCaptureSubscription.";
+    subscription_.reset();
+  }
 
   if (!rwh) {
-    if (had_subscription && tracker_->web_contents())
-      tracker_->web_contents()->DecrementCapturerCount();
+    DVLOG(1) << "Cannot renew ContentCaptureSubscription: no RWH target.";
     if (IsStarted()) {
       // Tracking of WebContents and/or its main frame has failed before Stop()
       // was called, so report this as an error:
       oracle_proxy_->ReportError(FROM_HERE,
                                  "WebContents and/or main frame are gone.");
     }
     return;
   }
 
-  if (!had_subscription && tracker_->web_contents())
-    tracker_->web_contents()->IncrementCapturerCount(ComputeOptimalViewSize());
-
-  subscription_.reset(new ContentCaptureSubscription(
-      *rwh, oracle_proxy_, base::Bind(&WebContentsCaptureMachine::Capture,
-                                      weak_ptr_factory_.GetWeakPtr())));
+  if (frame_capture_active_) {
+    DVLOG(1) << "Renewing ContentCaptureSubscription to RWH@" << rwh;
+    subscription_.reset(new ContentCaptureSubscription(
+        *rwh, oracle_proxy_, base::Bind(&WebContentsCaptureMachine::Capture,
+                                        weak_ptr_factory_.GetWeakPtr())));
+  }
 }
 
 void WebContentsCaptureMachine::UpdateCaptureSize() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!oracle_proxy_)
     return;
   RenderWidgetHost* const rwh = tracker_->GetTargetRenderWidgetHost();
   RenderWidgetHostView* const view = rwh ? rwh->GetView() : nullptr;
   if (!view)
@@ skipping 48 matching lines @@
     const media::VideoCaptureParams& params,
     std::unique_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   core_->AllocateAndStart(params, std::move(client));
 }
 
 void WebContentsVideoCaptureDevice::RequestRefreshFrame() {
   core_->RequestRefreshFrame();
 }
 
+void WebContentsVideoCaptureDevice::MaybeSuspend() {
+  core_->Suspend();
+}
+
+void WebContentsVideoCaptureDevice::Resume() {
+  core_->Resume();
+}
+
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content