Site Isolation: RenderView-->RenderFrame for WebContentsVideoCaptureDevice and WebContentsAudioInpu…

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
 //      shared-memory IPC buffer is reserved. There are only a few of these;
 //      when they run out, it indicates that the downstream client -- likely a
 //      video encoder -- is the performance bottleneck, and that the rate of
 //      frame capture should be throttled back.
 //
-//   2. Capture: A bitmap is snapshotted/copied from the RenderView's backing
+//   2. Capture: A bitmap is snapshotted/copied from the RenderWidget's backing
 //      store. This is initiated on the UI BrowserThread, and often occurs
 //      asynchronously. Where supported, the GPU scales and color converts
 //      frames to our desired size, and the readback happens directly into the
 //      shared-memory buffer. But this is not always possible, particularly when
 //      accelerated compositing is disabled.
 //
 //   3. Render (if needed): If the web contents cannot be captured directly into
 //      our target size and color format, scaling and colorspace conversion must
 //      be done on the CPU. A dedicated thread is used for this operation, to
 //      avoid blocking the UI thread. The Render stage always reads from a
@@ skipping 31 matching lines @@
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "content/browser/media/capture/content_video_capture_device_core.h"
 #include "content/browser/media/capture/video_capture_oracle.h"
 #include "content/browser/media/capture/web_contents_capture_util.h"
+#include "content/browser/media/capture/web_contents_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
-#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
-#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
-#include "content/public/browser/web_contents_observer.h"
+#include "content/public/browser/web_contents.h"
 #include "media/base/video_util.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/screen.h"
 
@@ skipping 98 matching lines @@
   virtual ~ContentCaptureSubscription();
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   void OnTimer();
 
+  // Maintain a weak reference to the RenderWidgetHost (via its routing ID),
+  // since the instance could be destroyed externally during the lifetime of
+  // |this|.
   const int render_process_id_;
-  const int render_view_id_;
+  const int render_widget_id_;
 
   VideoFrameDeliveryLog delivery_log_;
   FrameSubscriber paint_subscriber_;
   FrameSubscriber timer_subscriber_;
   content::NotificationRegistrar registrar_;
   CaptureCallback capture_callback_;
   base::Timer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentCaptureSubscription);
 };
 
 // Render the SkBitmap |input| into the given VideoFrame buffer |output|, then
 // invoke |done_cb| to indicate success or failure. |input| is expected to be
 // ARGB. |output| must be YV12 or I420. Colorspace conversion is always done.
 // Scaling and letterboxing will be done as needed.
 //
 // This software implementation should be used only when GPU acceleration of
 // these activities is not possible. This operation may be expensive (tens to
 // hundreds of milliseconds), so the caller should ensure that it runs on a
 // thread where such a pause would cause UI jank.
 void RenderVideoFrame(const SkBitmap& input,
                       const scoped_refptr<media::VideoFrame>& output,
                       const base::Callback<void(bool)>& done_cb);
 
-// Keeps track of the RenderView to be sourced, and executes copying of the
-// backing store on the UI BrowserThread.
-//
-// TODO(nick): It would be nice to merge this with WebContentsTracker, but its
-// implementation is currently asynchronous -- in our case, the "rvh changed"
-// notification would get posted back to the UI thread and processed later, and
-// this seems disadvantageous.
-class WebContentsCaptureMachine
-    : public VideoCaptureMachine,
-      public WebContentsObserver {
+// Renews capture subscriptions based on feedback from WebContentsTracker, and
+// also executes copying of the backing store on the UI BrowserThread.
+class WebContentsCaptureMachine : public VideoCaptureMachine {
  public:
   WebContentsCaptureMachine(int render_process_id, int main_render_frame_id);
   virtual ~WebContentsCaptureMachine();
 
   // VideoCaptureMachine overrides.
   virtual bool Start(const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
                      const media::VideoCaptureParams& params) OVERRIDE;
   virtual void Stop(const base::Closure& callback) 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);
 
-  // content::WebContentsObserver implementation.
-  virtual void DidShowFullscreenWidget(int routing_id) OVERRIDE {
-    fullscreen_widget_id_ = routing_id;
-    RenewFrameSubscription();
-  }
+ private:
+  bool IsStarted() const;
 
-  virtual void DidDestroyFullscreenWidget(int routing_id) OVERRIDE {
-    DCHECK_EQ(fullscreen_widget_id_, routing_id);
-    fullscreen_widget_id_ = MSG_ROUTING_NONE;
-    RenewFrameSubscription();
-  }
-
-  virtual void RenderViewReady() OVERRIDE {
-    RenewFrameSubscription();
-  }
-
-  virtual void AboutToNavigateRenderView(RenderViewHost* rvh) OVERRIDE {
-    RenewFrameSubscription();
-  }
-
-  virtual void DidNavigateMainFrame(
-      const LoadCommittedDetails& details,
-      const FrameNavigateParams& params) OVERRIDE {
-    RenewFrameSubscription();
-  }
-
-  virtual void WebContentsDestroyed() OVERRIDE;
-
- private:
   // Computes the preferred size of the target RenderWidget for optimal capture.
   gfx::Size ComputeOptimalTargetSize() const;
 
-  // Starts observing the web contents, returning false if lookup fails.
-  bool StartObservingWebContents();
-
-  // Helper function to determine the view that we are currently tracking.
-  RenderWidgetHost* GetTarget() const;
-
   // Response callback for RenderWidgetHost::CopyFromBackingStore().
   void DidCopyFromBackingStore(
       const base::TimeTicks& start_time,
       const scoped_refptr<media::VideoFrame>& target,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       bool success,
       const SkBitmap& bitmap);
 
   // Response callback for RWHVP::CopyFromCompositingSurfaceToVideoFrame().
   void DidCopyFromCompositingSurfaceToVideoFrame(
       const base::TimeTicks& start_time,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       bool success);
 
-  // Remove the old subscription, and start a new one. This should be called
-  // after any change to the WebContents that affects the RenderWidgetHost or
-  // attached views.
-  void RenewFrameSubscription();
+  // Remove the old subscription, and start a new one if |rwh| is not NULL.
+  void RenewFrameSubscription(RenderWidgetHost* rwh);
 
   // 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_;
+
   // 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<ThreadSafeCaptureOracle> oracle_proxy_;
 
   // Video capture parameters that this machine is started with.
   media::VideoCaptureParams capture_params_;
 
-  // 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_;
 
   // Responsible for forwarding events from the active RenderWidgetHost to the
   // oracle, and initiating captures accordingly.
   scoped_ptr<ContentCaptureSubscription> subscription_;
 
   // Weak pointer factory used to invalidate callbacks.
   // NOTE: Weak pointers must be invalidated before all other member variables.
   base::WeakPtrFactory<WebContentsCaptureMachine> weak_ptr_factory_;
@@ skipping 18 matching lines @@
   if (oracle_decision)
     delivery_log_->ChronicleFrameDelivery(present_time);
   return oracle_decision;
 }
 
 ContentCaptureSubscription::ContentCaptureSubscription(
     const RenderWidgetHost& source,
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
     const CaptureCallback& capture_callback)
     : render_process_id_(source.GetProcess()->GetID()),
-      render_view_id_(source.GetRoutingID()),
+      render_widget_id_(source.GetRoutingID()),
       delivery_log_(),
       paint_subscriber_(VideoCaptureOracle::kSoftwarePaint, oracle_proxy,
                         &delivery_log_),
       timer_subscriber_(VideoCaptureOracle::kTimerPoll, oracle_proxy,
                         &delivery_log_),
       capture_callback_(capture_callback),
       timer_(true, true) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
-      source.GetView());
+  RenderWidgetHostView* const view = source.GetView();
 
   // Subscribe to accelerated presents. These will be serviced directly by the
   // oracle.
   if (view && kAcceleratedSubscriberIsSupported) {
     scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
         new FrameSubscriber(VideoCaptureOracle::kCompositorUpdate,
             oracle_proxy, &delivery_log_));
     view->BeginFrameSubscription(subscriber.Pass());
   }
 
@@ skipping 12 matching lines @@
 
 ContentCaptureSubscription::~ContentCaptureSubscription() {
   // If the BrowserThreads have been torn down, then the browser is in the final
   // stages of exiting and it is dangerous to take any further action.  We must
   // return early.  http://crbug.com/396413
   if (!BrowserThread::IsMessageLoopValid(BrowserThread::UI))
     return;
 
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (kAcceleratedSubscriberIsSupported) {
-    RenderViewHost* source = RenderViewHost::FromID(render_process_id_,
-                                                    render_view_id_);
-    if (source) {
-      RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
-          source->GetView());
-      if (view)
-        view->EndFrameSubscription();
-    }
+    RenderWidgetHost* const source =
+        RenderWidgetHost::FromID(render_process_id_, render_widget_id_);
+    RenderWidgetHostView* const view = source ? source->GetView() : NULL;
+    if (view)
+      view->EndFrameSubscription();
   }
 }
 
 void ContentCaptureSubscription::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE, type);
 
@@ skipping 143 matching lines @@
       last_frame_rate_log_time_ = frame_time;
       count_frames_rendered_ = 0;
     }
   }
 }
 
 WebContentsCaptureMachine::WebContentsCaptureMachine(int render_process_id,
                                                      int main_render_frame_id)
     : initial_render_process_id_(render_process_id),
       initial_main_render_frame_id_(main_render_frame_id),
-      fullscreen_widget_id_(MSG_ROUTING_NONE),
+      tracker_(new WebContentsTracker(true)),
       weak_ptr_factory_(this) {}
 
 WebContentsCaptureMachine::~WebContentsCaptureMachine() {}
 
+bool WebContentsCaptureMachine::IsStarted() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return weak_ptr_factory_.HasWeakPtrs();
+}
+
 bool WebContentsCaptureMachine::Start(
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(!weak_ptr_factory_.HasWeakPtrs());  // Should not be started.
+  DCHECK(!IsStarted());
 
   DCHECK(oracle_proxy.get());
   oracle_proxy_ = oracle_proxy;
   capture_params_ = params;
 
   render_thread_.reset(new base::Thread("WebContentsVideo_RenderThread"));
   if (!render_thread_->Start()) {
     DVLOG(1) << "Failed to spawn render thread.";
     render_thread_.reset();
     return false;
   }
 
-  if (!StartObservingWebContents()) {
-    DVLOG(1) << "Failed to observe web contents.";
-    render_thread_.reset();
-    return false;
-  }
+  // Note: Creation of the first WeakPtr in the following statement will cause
+  // IsStarted() to return true from now on.
+  tracker_->Start(initial_render_process_id_, initial_main_render_frame_id_,
+                  base::Bind(&WebContentsCaptureMachine::RenewFrameSubscription,
+                             weak_ptr_factory_.GetWeakPtr()));
 
   return true;
 }
 
 void WebContentsCaptureMachine::Stop(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  subscription_.reset();
-  if (web_contents()) {
-    web_contents()->DecrementCapturerCount();
-    Observe(NULL);
+
+  if (!IsStarted()) {
+    callback.Run();
+    return;
   }
 
-  // Any callback that intend to use render_thread_ will not work after it is
-  // passed.
+  // 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(NULL);
+  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_.get()) {
     BrowserThread::PostBlockingPoolTask(
         FROM_HERE,
         base::Bind(&DeleteOnWorkerThread, base::Passed(&render_thread_),
                    callback));
   }
 }
 
 void WebContentsCaptureMachine::Capture(
     const base::TimeTicks& start_time,
     const scoped_refptr<media::VideoFrame>& target,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  RenderWidgetHost* rwh = GetTarget();
+  RenderWidgetHost* rwh = tracker_->GetTargetRenderWidgetHost();
   RenderWidgetHostViewBase* view =
       rwh ? static_cast<RenderWidgetHostViewBase*>(rwh->GetView()) : NULL;
-  if (!view || !rwh) {
+  if (!view) {
     deliver_frame_cb.Run(base::TimeTicks(), false);
     return;
   }
 
   gfx::Size video_size = target->coded_size();
   gfx::Size view_size = view->GetViewBounds().size();
   gfx::Size fitted_size;
   if (!view_size.IsEmpty()) {
     fitted_size = ComputeYV12LetterboxRegion(video_size, view_size).size();
   }
@@ skipping 30 matching lines @@
 gfx::Size WebContentsCaptureMachine::ComputeOptimalTargetSize() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   gfx::Size optimal_size = oracle_proxy_->GetCaptureSize();
 
   // If the ratio between physical and logical pixels is greater than 1:1,
   // shrink |optimal_size| by that amount.  Then, when external code resizes the
   // render widget to the "preferred size," the widget will be physically
   // rendered at the exact capture size, thereby eliminating unnecessary scaling
   // operations in the graphics pipeline.
-  RenderWidgetHost* const rwh = GetTarget();
+  RenderWidgetHost* const rwh = tracker_->GetTargetRenderWidgetHost();
   RenderWidgetHostView* const rwhv = rwh ? rwh->GetView() : NULL;
   if (rwhv) {
     const gfx::NativeView view = rwhv->GetNativeView();
     gfx::Screen* const screen = gfx::Screen::GetScreenFor(view);
     if (screen->IsDIPEnabled()) {
       const gfx::Display display = screen->GetDisplayNearestWindow(view);
       const float scale = display.device_scale_factor();
       if (scale > 1.0f) {
         const gfx::Size shrunk_size(
             gfx::ToFlooredSize(gfx::ScaleSize(optimal_size, 1.0f / scale)));
         if (shrunk_size.width() > 0 && shrunk_size.height() > 0)
           optimal_size = shrunk_size;
       }
     }
   }
 
   VLOG(1) << "Computed optimal target size: " << optimal_size.ToString();
   return optimal_size;
 }
 
-bool WebContentsCaptureMachine::StartObservingWebContents() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  // Look-up the RenderFrameHost and, from that, the WebContents that wraps it.
-  // If successful, begin observing the WebContents instance.
-  //
-  // Why this can be unsuccessful: The request for mirroring originates in a
-  // render process, and this request is based on the current main RenderFrame
-  // 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 RenderFrame may have gone away.
-  Observe(WebContents::FromRenderFrameHost(RenderFrameHost::FromID(
-      initial_render_process_id_, initial_main_render_frame_id_)));
-  DVLOG_IF(1, !web_contents())
-      << "Could not find WebContents associated with main RenderFrameHost "
-      << "referenced by render_process_id=" << initial_render_process_id_
-      << ", routing_id=" << initial_main_render_frame_id_;
-
-  WebContentsImpl* contents = static_cast<WebContentsImpl*>(web_contents());
-  if (contents) {
-    contents->IncrementCapturerCount(ComputeOptimalTargetSize());
-    fullscreen_widget_id_ = contents->GetFullscreenWidgetRoutingID();
-    RenewFrameSubscription();
-    return true;
-  }
-  return false;
-}
-
-void WebContentsCaptureMachine::WebContentsDestroyed() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  subscription_.reset();
-  web_contents()->DecrementCapturerCount();
-  oracle_proxy_->ReportError("WebContentsDestroyed()");
-}
-
-RenderWidgetHost* WebContentsCaptureMachine::GetTarget() const {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents())
-    return NULL;
-
-  RenderWidgetHost* rwh = NULL;
-  if (fullscreen_widget_id_ != MSG_ROUTING_NONE) {
-    RenderProcessHost* process = web_contents()->GetRenderProcessHost();
-    if (process)
-      rwh = RenderWidgetHost::FromID(process->GetID(), fullscreen_widget_id_);
-  } else {
-    rwh = web_contents()->GetRenderViewHost();
-  }
-
-  return rwh;
-}
-
 void WebContentsCaptureMachine::DidCopyFromBackingStore(
     const base::TimeTicks& start_time,
     const scoped_refptr<media::VideoFrame>& target,
     const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
         deliver_frame_cb,
     bool success,
     const SkBitmap& bitmap) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::TimeTicks now = base::TimeTicks::Now();
@@ skipping 22 matching lines @@
 
   if (success) {
     UMA_HISTOGRAM_TIMES("TabCapture.CopyTimeVideoFrame", now - start_time);
   } else {
     // Capture can fail due to transient issues, so just skip this frame.
     DVLOG(1) << "CopyFromCompositingSurface failed; skipping frame.";
   }
   deliver_frame_cb.Run(start_time, success);
 }
 
-void WebContentsCaptureMachine::RenewFrameSubscription() {
+void WebContentsCaptureMachine::RenewFrameSubscription(RenderWidgetHost* rwh) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Always destroy the old subscription before creating a new one.
+  const bool had_subscription = !!subscription_;
   subscription_.reset();
 
-  RenderWidgetHost* rwh = GetTarget();
-  if (!rwh || !rwh->GetView())
+  DVLOG(1) << "Renewing frame subscription to RWH@" << rwh
+           << ", had_subscription=" << had_subscription;
+
+  if (!rwh) {
+    if (had_subscription && tracker_->web_contents())
+      tracker_->web_contents()->DecrementCapturerCount();
+    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("WebContents and/or main frame are gone.");
+    }
     return;
+  }
+
+  if (!had_subscription && tracker_->web_contents()) {
+    tracker_->web_contents()->IncrementCapturerCount(
+        ComputeOptimalTargetSize());
+  }
 
   subscription_.reset(new ContentCaptureSubscription(*rwh, oracle_proxy_,
       base::Bind(&WebContentsCaptureMachine::Capture,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
 }  // namespace
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     int render_process_id, int main_render_frame_id)
@@ skipping 25 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