Automatic resolution throttling for screen capture pipeline.

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 193 matching lines @@
   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 Stop(const base::Closure& callback) override;
+  bool IsAutoThrottlingEnabled() const override {
+    return auto_throttling_enabled_;
+  }
 
   // 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);
@@ skipping 32 matching lines @@
   void UpdateCaptureSize();
 
   // Parameters saved in constructor.
   const int initial_render_process_id_;
   const int initial_main_render_frame_id_;
 
   // Tracks events and calls back to RenewFrameSubscription() to maintain
   // capture on the correct RenderWidgetHost.
   const scoped_refptr<WebContentsTracker> tracker_;
 
+  // Set to false to prevent the capture size from automatically adjusting in
+  // response to end-to-end utilization.  This is enabled via the throttling
+  // option in the WebContentsVideoCaptureDevice device ID.
+  const bool auto_throttling_enabled_;
+
   // A dedicated worker thread on which SkBitmap->VideoFrame conversion will
   // occur. Only used when this activity cannot be done on the GPU.
   scoped_ptr<base::Thread> render_thread_;
 
   // Makes all the decisions about which frames to copy, and how.
   scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
 
   // Video capture parameters that this machine is started with.
   media::VideoCaptureParams capture_params_;
 
@@ skipping 201 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),
       weak_ptr_factory_(this) {
-  // TODO(miu): Use |enable_auto_throttling| to enable/disable the automatic
-  // video resolution changes based on resource utilization.
-  // http://crbug.com/156767.
   DVLOG(1) << "Created WebContentsCaptureMachine for "
            << render_process_id << ':' << main_render_frame_id
-           << (enable_auto_throttling ? " with auto-throttling enabled" : "");
+           << (auto_throttling_enabled_ ? " with auto-throttling enabled" : "");
 }
 
 WebContentsCaptureMachine::~WebContentsCaptureMachine() {}
 
 bool WebContentsCaptureMachine::IsStarted() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return weak_ptr_factory_.HasWeakPtrs();
 }
 
 void WebContentsCaptureMachine::Start(
@@ skipping 289 matching lines @@
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   core_->AllocateAndStart(params, client.Pass());
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content