While screencasting a tab, do not disable rendering updates while hidden.

content/browser/renderer_host/media/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.  Therefore, the process of capturing has been split up into a
 // pipeline of three stages.  Each stage executes on its own thread:
 //
 //   1. Capture: A bitmap is snapshotted/copied from the RenderView's backing
@@ skipping 134 matching lines @@
     OK,
     TRANSIENT_ERROR,
     NO_SOURCE,
   };
   typedef base::Callback<void(Result result,
                               scoped_ptr<skia::PlatformBitmap> capture,
                               const base::Time& capture_time)> DoneCB;
 
   BackingStoreCopier(int render_process_id, int render_view_id);
 
+  virtual ~BackingStoreCopier();
+
   // If non-NULL, use the given |override| to access the backing store.
   // This is used for unit testing.
   void SetRenderWidgetHostForTesting(RenderWidgetHost* override);
 
   // Starts the copy from the backing store.  Must be run on the UI
   // BrowserThread.  |done_cb| is invoked with result status.  When successful
   // (OK), the bitmap of the capture is transferred to the callback along with
   // the timestamp at which the capture was completed.
   void StartCopy(int frame_number, int desired_width, int desired_height,
                  const DoneCB& done_cb);
 
+  // Stops observing an existing WebContents instance, if any.  This must be
+  // called before BackingStoreCopier is destroyed.  Must be run on the UI
+  // BrowserThread.
+  void StopObservingWebContents();
+
   virtual void DidShowFullscreenWidget(int routing_id) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     fullscreen_widget_id_ = routing_id;
   }
 
   virtual void DidDestroyFullscreenWidget(int routing_id) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK_EQ(fullscreen_widget_id_, routing_id);
     fullscreen_widget_id_ = MSG_ROUTING_NONE;
   }
 
  private:
+  virtual void WebContentsDestroyed(WebContents* web_contents) OVERRIDE;
+
   void LookUpAndObserveWebContents();
 
   void CopyFromBackingStoreComplete(int frame_number,
                                     scoped_ptr<skia::PlatformBitmap> capture,
                                     const DoneCB& done_cb, bool success);
 
   // The "starting point" to find the capture source.
   const int render_process_id_;
   const int render_view_id_;
 
@@ skipping 95 matching lines @@
   int last_frame_number_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliverer);
 };
 
 BackingStoreCopier::BackingStoreCopier(int render_process_id,
                                        int render_view_id)
     : render_process_id_(render_process_id), render_view_id_(render_view_id),
       fullscreen_widget_id_(MSG_ROUTING_NONE), rwh_for_testing_(NULL) {}
 
+BackingStoreCopier::~BackingStoreCopier() {
+  DCHECK(!web_contents());
+}
+
+void BackingStoreCopier::StopObservingWebContents() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (web_contents()) {
+    web_contents()->DecrementCapturerCount();
+    Observe(NULL);
+  }
+}
+
+void BackingStoreCopier::WebContentsDestroyed(WebContents* web_contents) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  web_contents->DecrementCapturerCount();
+}
+
 void BackingStoreCopier::LookUpAndObserveWebContents() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Look-up the RenderViewHost and, from that, the WebContents that wraps it.
   // If successful, begin observing the WebContents instance.  If unsuccessful,
   // stop observing and post an error.
   //
   // Why this can be unsuccessful: The request for mirroring originates in a
   // render process, and this request is based on the current RenderView
   // associated with a tab.  However, by the time we get up-and-running here,
   // there have been multiple back-and-forth IPCs between processes, as well as
   // a bit of indirection across threads.  It's easily possible that, in the
   // meantime, the original RenderView may have gone away.
   RenderViewHost* const rvh =
       RenderViewHost::FromID(render_process_id_, render_view_id_);
   DVLOG_IF(1, !rvh) << "RenderViewHost::FromID("
                     << render_process_id_ << ", " << render_view_id_
                     << ") returned NULL.";
   Observe(rvh ? WebContents::FromRenderViewHost(rvh) : NULL);
-  DVLOG_IF(1, !web_contents())
-      << "WebContents::FromRenderViewHost(" << rvh << ") returned NULL.";
+  if (web_contents())
+    web_contents()->IncrementCapturerCount();
+  else
+    DVLOG(1) << "WebContents::FromRenderViewHost(" << rvh << ") returned NULL.";
 
   if (fullscreen_widget_id_ == MSG_ROUTING_NONE && web_contents()) {
     fullscreen_widget_id_ = static_cast<WebContentsImpl*>(web_contents())->
         GetFullscreenWidgetRoutingID();
   }
 }
 
 void BackingStoreCopier::SetRenderWidgetHostForTesting(
     RenderWidgetHost* override) {
   rwh_for_testing_ = override;
@@ skipping 390 matching lines @@
   void SnapshotComplete(int frame_number,
                         const base::Time& start_time,
                         BackingStoreCopier::Result result,
                         scoped_ptr<skia::PlatformBitmap> capture,
                         const base::Time& capture_time);
   void RenderComplete(int frame_number,
                       const base::Time& capture_time,
                       const SkBitmap* frame_buffer);
   void DeliverComplete(const SkBitmap* frame_buffer);
 
+  void DoShutdownTasksOnUIThread();
+
   // Specialized RefCounted traits for CaptureMachine, so that operator delete
   // is called from an "outside" thread.  See comments for "traits" in
   // base/memory/ref_counted.h.
   static void Destruct(const CaptureMachine* x);
   static void DeleteFromOutsideThread(const CaptureMachine* x);
 
   SynchronizedConsumer consumer_;  // Recipient of frames.
 
   // Used to ensure state machine transitions occur synchronously, and that
   // capturing executes at regular intervals.
@@ skipping 106 matching lines @@
 }
 
 void CaptureMachine::DeAllocate() {
   ENSURE_INVOKED_ON_THREAD(manager_thread_,
                            &CaptureMachine::DeAllocate, this);
 
   if (state_ == kCapturing) {
     Stop();
   }
   if (state_ == kAllocated) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&CaptureMachine::DoShutdownTasksOnUIThread, this));
+
     TransitionStateTo(kIdle);
   }
 }
 
 CaptureMachine::~CaptureMachine() {
   DVLOG(1) << "CaptureMachine@" << this << " destroying.";
   state_ = kDestroyed;
   // Note: Implicit destructors will be called after this, which will block the
   // current thread while joining on the other threads.  However, this should be
   // instantaneous since the other threads' task queues *must* be empty at this
@@ skipping 160 matching lines @@
   DCHECK(frame_buffer);
   deliverer_.Deliver(
       frame_number, *frame_buffer, capture_time,
       base::Bind(&CaptureMachine::DeliverComplete, this, frame_buffer));
 }
 
 void CaptureMachine::DeliverComplete(const SkBitmap* frame_buffer) {
   renderer_.Release(frame_buffer);
 }
 
+void CaptureMachine::DoShutdownTasksOnUIThread() {
+  copier_.StopObservingWebContents();
+}
+
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     const media::VideoCaptureDevice::Name& name,
     int render_process_id, int render_view_id)
     : device_name_(name),
       capturer_(new CaptureMachine(render_process_id, render_view_id)) {}
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     RenderWidgetHost* test_source, const base::Closure& destroy_cb)
     : capturer_(new CaptureMachine(-1, -1)) {
   device_name_.device_name = "WebContentsForTesting";
@@ skipping 55 matching lines @@
   capturer_->SetConsumer(NULL);
   capturer_->DeAllocate();
 }
 
 const media::VideoCaptureDevice::Name&
 WebContentsVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 }  // namespace content