Allow TabCapture to capture full screen flash widgets.

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 38 matching lines @@
 #include "base/callback_forward.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "content/browser/renderer_host/media/web_contents_capture_util.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "media/base/bind_to_loop.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
@@ skipping 86 matching lines @@
   // 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);
 
+  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:
   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_;
 
+  // Routing ID of any active fullscreen render widget or MSG_ROUTING_NONE
+  // otherwise.
+  int fullscreen_widget_id_;
+
   // Last known RenderView size.
   gfx::Size last_view_size_;
 
   // If the following is NULL (normal behavior), the implementation should
   // access RenderWidgetHost via web_contents().
   RenderWidgetHost* rwh_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(BackingStoreCopier);
 };
 
@@ skipping 79 matching lines @@
   base::Time last_frame_rate_log_time_;
   int count_frames_rendered_;
   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),
-      rwh_for_testing_(NULL) {}
+      fullscreen_widget_id_(MSG_ROUTING_NONE), rwh_for_testing_(NULL) {}
 
 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 (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;
 }
 
 void BackingStoreCopier::StartCopy(int frame_number,
                                    int desired_width, int desired_height,
                                    const DoneCB& done_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TRACE_EVENT_ASYNC_BEGIN1("mirroring", "Capture", this,
                            "frame_number", frame_number);
 
   RenderWidgetHost* rwh;
   if (rwh_for_testing_) {
     rwh = rwh_for_testing_;
   } else {
     if (!web_contents()) {  // No source yet.
       LookUpAndObserveWebContents();
       if (!web_contents()) {  // No source ever.
         done_cb.Run(NO_SOURCE,
                     scoped_ptr<skia::PlatformBitmap>(NULL), base::Time());
         return;
       }
     }
-    rwh = web_contents()->GetRenderViewHost();
+
+    if (fullscreen_widget_id_ != MSG_ROUTING_NONE) {
+      RenderProcessHost* process = web_contents()->GetRenderProcessHost();
+      rwh = process ? process->GetRenderWidgetHostByID(fullscreen_widget_id_)
+                    : NULL;
+    } else {
+      rwh = web_contents()->GetRenderViewHost();
+    }
+
     if (!rwh) {
       // Transient failure state (e.g., a RenderView is being replaced).
       done_cb.Run(TRANSIENT_ERROR,
                   scoped_ptr<skia::PlatformBitmap>(NULL), base::Time());
       return;
     }
   }
 
   gfx::Size fitted_size;
   if (RenderWidgetHostView* const view = rwh->GetView()) {
@@ skipping 730 matching lines @@
   capturer_->SetConsumer(NULL);
   capturer_->DeAllocate();
 }
 
 const media::VideoCaptureDevice::Name&
 WebContentsVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 }  // namespace content