Tab capture: Tracking continues after renderer crash.

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 137 matching lines @@
   scoped_refptr<media::ThreadSafeCaptureOracle> oracle_proxy_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the cursor renderer.
   base::WeakPtr<CursorRenderer> cursor_renderer_;
   // We need a weak pointer since FrameSubscriber is owned externally and
   // may outlive the ui activity tracker.
   base::WeakPtr<WindowActivityTracker> window_activity_tracker_;
   base::WeakPtrFactory<FrameSubscriber> weak_ptr_factory_;
 };
 
-// ContentCaptureSubscription is the relationship between a RenderWidgetHost
+// ContentCaptureSubscription is the relationship between a RenderWidgetHostView
 // whose content is updating, a subscriber that is deciding which of these
 // updates to capture (and where to deliver them to), and a callback that
 // knows how to do the capture and prepare the result for delivery.
 //
 // In practice, this means (a) installing a RenderWidgetHostFrameSubscriber in
 // the RenderWidgetHostView, to process compositor updates, and (b) occasionally
 // initiating forced, non-event-driven captures needed by downstream consumers
 // that request "refresh frames" of unchanged content.
 //
 // All of this happens on the UI thread, although the
 // RenderWidgetHostViewFrameSubscriber we install may be dispatching updates
 // autonomously on some other thread.
 class ContentCaptureSubscription {
  public:
   typedef base::Callback<void(
       const base::TimeTicks&,
       const scoped_refptr<media::VideoFrame>&,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&)>
       CaptureCallback;
 
   // Create a subscription. Whenever a manual capture is required, the
   // subscription will invoke |capture_callback| on the UI thread to do the
   // work.
   ContentCaptureSubscription(
-      const RenderWidgetHost& source,
+      base::WeakPtr<RenderWidgetHostViewBase> source_view,
       const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
       const CaptureCallback& capture_callback);
   ~ContentCaptureSubscription();
 
   void MaybeCaptureForRefresh();
 
  private:
   // Called for active frame refresh requests, or mouse activity events.
   void OnEvent(FrameSubscriber* subscriber);
 
-  // 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_widget_id_;
+  const base::WeakPtr<RenderWidgetHostViewBase> source_view_;
 
   std::unique_ptr<FrameSubscriber> refresh_subscriber_;
   std::unique_ptr<FrameSubscriber> mouse_activity_subscriber_;
   CaptureCallback capture_callback_;
 
   // Responsible for tracking the cursor state and input events to make
   // decisions and then render the mouse cursor on the video frame after
   // capture is completed.
   std::unique_ptr<content::CursorRenderer> cursor_renderer_;
 
@@ skipping 72 matching lines @@
       ReadbackResponse response);
 
   // Response callback for RWHVP::CopyFromCompositingSurfaceToVideoFrame().
   void DidCopyFromCompositingSurfaceToVideoFrame(
       const base::TimeTicks& start_time,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       const gfx::Rect& region_in_frame,
       bool success);
 
-  // Remove the old subscription, and attempt to start a new one if |had_target|
-  // is true.
-  void RenewFrameSubscription(bool had_target);
+  // Remove the old subscription, and attempt to start a new one. If
+  // |is_still_tracking| is false, emit an error rather than attempt to start a
+  // new subscription.
+  void RenewFrameSubscription(bool is_still_tracking);
 
   // Called whenever the render widget is resized.
   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.
+  // capture on the correct RenderWidgetHostView.
   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.
   std::unique_ptr<base::Thread> render_thread_;
@@ skipping 83 matching lines @@
     if (ui_activity && !animation_active) {
       interactive_mode = true;
     } else if (animation_active && window_activity_tracker_.get()) {
       window_activity_tracker_->Reset();
     }
   }
   return interactive_mode;
 }
 
 ContentCaptureSubscription::ContentCaptureSubscription(
-    const RenderWidgetHost& source,
+    base::WeakPtr<RenderWidgetHostViewBase> source_view,
     const scoped_refptr<media::ThreadSafeCaptureOracle>& oracle_proxy,
     const CaptureCallback& capture_callback)
-    : render_process_id_(source.GetProcess()->GetID()),
-      render_widget_id_(source.GetRoutingID()),
-      capture_callback_(capture_callback) {
+    : source_view_(source_view), capture_callback_(capture_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(source_view_);
 
-  RenderWidgetHostView* const view = source.GetView();
 #if defined(USE_AURA) || defined(OS_MACOSX)
-  if (view) {
-    cursor_renderer_ = CursorRenderer::Create(view->GetNativeView());
-    window_activity_tracker_ =
-        WindowActivityTracker::Create(view->GetNativeView());
-  }
+  cursor_renderer_ = CursorRenderer::Create(source_view_->GetNativeView());
+  window_activity_tracker_ =
+      WindowActivityTracker::Create(source_view_->GetNativeView());
 #endif
   refresh_subscriber_.reset(new FrameSubscriber(
       media::VideoCaptureOracle::kActiveRefreshRequest, oracle_proxy,
       cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
                        : base::WeakPtr<CursorRenderer>(),
       window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                : base::WeakPtr<WindowActivityTracker>()));
   mouse_activity_subscriber_.reset(new FrameSubscriber(
       media::VideoCaptureOracle::kMouseCursorUpdate, oracle_proxy,
       cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
                        : base::WeakPtr<CursorRenderer>(),
       window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
                                : base::WeakPtr<WindowActivityTracker>()));
 
   // Subscribe to compositor updates. These will be serviced directly by the
   // oracle.
-  if (view) {
-    std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
-        new FrameSubscriber(
-            media::VideoCaptureOracle::kCompositorUpdate, oracle_proxy,
-            cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
-                             : base::WeakPtr<CursorRenderer>(),
-            window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
-                                     : base::WeakPtr<WindowActivityTracker>()));
-    view->BeginFrameSubscription(std::move(subscriber));
-  }
+  std::unique_ptr<RenderWidgetHostViewFrameSubscriber> subscriber(
+      new FrameSubscriber(
+          media::VideoCaptureOracle::kCompositorUpdate, oracle_proxy,
+          cursor_renderer_ ? cursor_renderer_->GetWeakPtr()
+                           : base::WeakPtr<CursorRenderer>(),
+          window_activity_tracker_ ? window_activity_tracker_->GetWeakPtr()
+                                   : base::WeakPtr<WindowActivityTracker>()));
+  source_view_->BeginFrameSubscription(std::move(subscriber));
 
   // Subscribe to mouse movement and mouse cursor update events.
   if (window_activity_tracker_) {
     window_activity_tracker_->RegisterMouseInteractionObserver(
         base::Bind(&ContentCaptureSubscription::OnEvent, base::Unretained(this),
                    mouse_activity_subscriber_.get()));
   }
 }
 
 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);
-  RenderWidgetHost* const source =
-      RenderWidgetHost::FromID(render_process_id_, render_widget_id_);
-  RenderWidgetHostView* const view = source ? source->GetView() : NULL;
-  if (view)
-    view->EndFrameSubscription();
+  // If the RWHV weak pointer is still valid, make sure the view is still
+  // associated with a RWH before attempting to end the frame subscription. This
+  // is because a null RWH indicates the RWHV has had its Destroy() method
+  // called, which makes it invalid to call any of its methods that assume the
+  // compositor is present.
+  if (source_view_ && source_view_->GetRenderWidgetHost())
+    source_view_->EndFrameSubscription();
 }
 
 void ContentCaptureSubscription::MaybeCaptureForRefresh() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   OnEvent(refresh_subscriber_.get());
 }
 
 void ContentCaptureSubscription::OnEvent(FrameSubscriber* subscriber) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT0("gpu.capture", "ContentCaptureSubscription::OnEvent");
@@ skipping 154 matching lines @@
       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);
+    RenewFrameSubscription(tracker_->is_still_tracking());
 }
 
 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);
+    RenewFrameSubscription(tracker_->is_still_tracking());
 }
 
 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) {
@@ skipping 37 matching lines @@
     subscription_->MaybeCaptureForRefresh();
 }
 
 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 = tracker_->GetTargetRenderWidgetHost();
-  RenderWidgetHostViewBase* view =
-      rwh ? static_cast<RenderWidgetHostViewBase*>(rwh->GetView()) : NULL;
+  auto* const view =
+      static_cast<RenderWidgetHostViewBase*>(tracker_->GetTargetView());
   if (!view) {
     deliver_frame_cb.Run(base::TimeTicks(), gfx::Rect(), false);
     return;
   }
 
   const gfx::Size view_size = view->GetViewBounds().size();
   if (view->CanCopyToVideoFrame()) {
     view->CopyFromCompositingSurfaceToVideoFrame(
         gfx::Rect(view_size), target,
         base::Bind(&WebContentsCaptureMachine::
                        DidCopyFromCompositingSurfaceToVideoFrame,
                    weak_ptr_factory_.GetWeakPtr(), start_time,
                    deliver_frame_cb));
   } else {
     const gfx::Size fitted_size =
         view_size.IsEmpty()
             ? gfx::Size()
             : media::ComputeLetterboxRegion(target->visible_rect(), view_size)
                   .size();
-    rwh->CopyFromBackingStore(
-        gfx::Rect(),
-        fitted_size,  // Size here is a request not always honored.
-        base::Bind(&WebContentsCaptureMachine::DidCopyFromBackingStore,
-                   weak_ptr_factory_.GetWeakPtr(), start_time, target,
-                   deliver_frame_cb),
-        kN32_SkColorType);
+    if (auto* rwh = view->GetRenderWidgetHost()) {
+      rwh->CopyFromBackingStore(
+          gfx::Rect(),
+          fitted_size,  // Size here is a request not always honored.
+          base::Bind(&WebContentsCaptureMachine::DidCopyFromBackingStore,
+                     weak_ptr_factory_.GetWeakPtr(), start_time, target,
+                     deliver_frame_cb),
+          kN32_SkColorType);
+    }
   }
 }
 
 gfx::Size WebContentsCaptureMachine::ComputeOptimalViewSize() const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // TODO(miu): Propagate capture frame size changes as new "preferred size"
   // updates, rather than just using the max frame size.
   // http://crbug.com/350491
   gfx::Size optimal_size = oracle_proxy_->max_frame_size();
@@ skipping 32 matching lines @@
       // Else, do not make an adjustment.
       break;
     }
   }
 
   // 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 = tracker_->GetTargetRenderWidgetHost();
-  RenderWidgetHostView* const rwhv = rwh ? rwh->GetView() : NULL;
-  if (rwhv) {
+  if (auto* rwhv = tracker_->GetTargetView()) {
     const gfx::NativeView view = rwhv->GetNativeView();
     const float scale = ui::GetScaleFactorForNativeView(view);
     if (scale > 1.0f) {
       const gfx::Size shrunk_size =
           gfx::ScaleToFlooredSize(optimal_size, 1.0f / scale);
       if (shrunk_size.width() > 0 && shrunk_size.height() > 0)
         optimal_size = shrunk_size;
     }
   }
 
@@ skipping 31 matching lines @@
         deliver_frame_cb,
     const gfx::Rect& region_in_frame,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Capture can fail due to transient issues, so just skip this frame.
   DVLOG_IF(1, !success) << "CopyFromCompositingSurface failed; skipping frame.";
   deliver_frame_cb.Run(start_time, region_in_frame, success);
 }
 
-void WebContentsCaptureMachine::RenewFrameSubscription(bool had_target) {
+void WebContentsCaptureMachine::RenewFrameSubscription(bool is_still_tracking) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  RenderWidgetHost* const rwh =
-      had_target ? tracker_->GetTargetRenderWidgetHost() : nullptr;
-
   // Always destroy the old subscription before creating a new one.
   if (subscription_) {
-    DVLOG(1) << "Cancelling existing ContentCaptureSubscription.";
+    DVLOG(1) << "Cancelling existing subscription.";
     subscription_.reset();
   }
 
-  if (!rwh) {
-    DVLOG(1) << "Cannot renew ContentCaptureSubscription: no RWH target.";
+  if (!is_still_tracking) {
     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 (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())));
+  if (!frame_capture_active_) {
+    DVLOG(1) << "Not renewing subscription: Frame capture is suspended.";
+    return;
   }
+
+  auto* const view =
+      static_cast<RenderWidgetHostViewBase*>(tracker_->GetTargetView());
+  if (!view) {
+    DVLOG(1) << "Cannot renew subscription: No view to capture.";
+    return;
+  }
+
+  DVLOG(1) << "Renewing subscription to RenderWidgetHostView@" << view;
+  subscription_.reset(new ContentCaptureSubscription(
+      view->GetWeakPtr(), 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;
+  RenderWidgetHostView* const view = tracker_->GetTargetView();
   if (!view)
     return;
 
   // Convert the view's size from the DIP coordinate space to the pixel
   // coordinate space.  When the view is being rendered on a high-DPI display,
   // this allows the high-resolution image detail to propagate through to the
   // captured video.
   const gfx::Size view_size = view->GetViewBounds().size();
   const gfx::Size physical_size = gfx::ConvertSizeToPixel(
       ui::GetScaleFactorForNativeView(view->GetNativeView()), view_size);
@@ skipping 56 matching lines @@
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 void WebContentsVideoCaptureDevice::OnUtilizationReport(int frame_feedback_id,
                                                         double utilization) {
   core_->OnConsumerReportingUtilization(frame_feedback_id, utilization);
 }
 
 }  // namespace content