[Cross-Site Isolation] Migrate entire MediaStream verticals to be per-RenderFrame.

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 207 matching lines @@
 // 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 {
  public:
-  WebContentsCaptureMachine(int render_process_id, int render_view_id);
+  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|.
@@ skipping 55 matching lines @@
           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();
 
   // Parameters saved in constructor.
   const int initial_render_process_id_;
-  const int initial_render_view_id_;
+  const int initial_main_render_frame_id_;
 
   // 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_;
@@ skipping 236 matching lines @@
           static_cast<int>(measured_fps));
       VLOG(1) << "Current measured frame rate for "
               << "WebContentsVideoCaptureDevice is " << measured_fps << " FPS.";
       last_frame_rate_log_time_ = frame_time;
       count_frames_rendered_ = 0;
     }
   }
 }
 
 WebContentsCaptureMachine::WebContentsCaptureMachine(int render_process_id,
-                                                     int render_view_id)
+                                                     int main_render_frame_id)
     : initial_render_process_id_(render_process_id),
-      initial_render_view_id_(render_view_id),
+      initial_main_render_frame_id_(main_render_frame_id),
       fullscreen_widget_id_(MSG_ROUTING_NONE),
       weak_ptr_factory_(this) {}
 
 WebContentsCaptureMachine::~WebContentsCaptureMachine() {
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&DeleteOnWorkerThread, base::Passed(&render_thread_),
                  base::Bind(&base::DoNothing)));
 }
 
@@ skipping 91 matching lines @@
         base::Bind(&WebContentsCaptureMachine::DidCopyFromBackingStore,
                    weak_ptr_factory_.GetWeakPtr(),
                    start_time,
                    target,
                    deliver_frame_cb),
         kN32_SkColorType);
   }
 }
 
 bool WebContentsCaptureMachine::StartObservingWebContents() {
-  // Look-up the RenderViewHost and, from that, the WebContents that wraps it.
+  // 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 RenderView
+  // 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 RenderView may have gone away.
-  RenderViewHost* const rvh =
-      RenderViewHost::FromID(initial_render_process_id_,
-                             initial_render_view_id_);
-  DVLOG_IF(1, !rvh) << "RenderViewHost::FromID("
-                    << initial_render_process_id_ << ", "
-                    << initial_render_view_id_ << ") returned NULL.";
-  Observe(rvh ? WebContents::FromRenderViewHost(rvh) : NULL);
+  // 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(oracle_proxy_->GetCaptureSize());
     fullscreen_widget_id_ = contents->GetFullscreenWidgetRoutingID();
     RenewFrameSubscription();
     return true;
   }
-
-  DVLOG(1) << "WebContents::FromRenderViewHost(" << rvh << ") returned NULL.";
   return false;
 }
 
 void WebContentsCaptureMachine::WebContentsDestroyed() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   subscription_.reset();
   web_contents()->DecrementCapturerCount();
   oracle_proxy_->ReportError("WebContentsDestroyed()");
 }
@@ skipping 68 matching lines @@
     return;
 
   subscription_.reset(new ContentCaptureSubscription(*rwh, oracle_proxy_,
       base::Bind(&WebContentsCaptureMachine::Capture,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
 }  // namespace
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
-    int render_process_id, int render_view_id)
+    int render_process_id, int main_render_frame_id)
     : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>(
-        new WebContentsCaptureMachine(render_process_id, render_view_id)))) {}
+        new WebContentsCaptureMachine(
+            render_process_id, main_render_frame_id)))) {}
 
 WebContentsVideoCaptureDevice::~WebContentsVideoCaptureDevice() {
   DVLOG(2) << "WebContentsVideoCaptureDevice@" << this << " destroying.";
 }
 
 // static
 media::VideoCaptureDevice* WebContentsVideoCaptureDevice::Create(
     const std::string& device_id) {
   // Parse device_id into render_process_id and render_view_id.
   int render_process_id = -1;
-  int render_view_id = -1;
+  int main_render_frame_id = -1;
   if (!WebContentsCaptureUtil::ExtractTabCaptureTarget(
-           device_id, &render_process_id, &render_view_id)) {
+           device_id, &render_process_id, &main_render_frame_id)) {
     return NULL;
   }
 
-  return new WebContentsVideoCaptureDevice(render_process_id, render_view_id);
+  return new WebContentsVideoCaptureDevice(
+      render_process_id, main_render_frame_id);
 }
 
 void WebContentsVideoCaptureDevice::AllocateAndStart(
     const media::VideoCaptureParams& params,
     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