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

chrome/browser/media/media_capture_devices_dispatcher.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.
 
 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
 
 #include "apps/app_window.h"
 #include "apps/app_window_registry.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "content/public/browser/media_capture_devices.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/media_stream_request.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "grit/generated_resources.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/media_switches.h"
 #include "net/base/net_util.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_types.h"
@@ skipping 136 matching lines @@
       ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
           IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT_DELEGATED,
           registered_extension_name,
           application_title));
     }
   }
 
   return ui.Pass();
 }
 
+// Returns the WebContents instance that contains the RenderFrameHost referenced
+// by the given |request|.
+content::WebContents* GetWebContentsFromRequest(
+    const content::MediaStreamRequest& request) {
+  return content::WebContents::FromRenderFrameHost(
+      content::RenderFrameHost::FromID(request.render_process_id,
+                                       request.render_frame_id));
+}
+
 #if defined(AUDIO_STREAM_MONITORING)
 
 AudioStreamMonitor* AudioStreamMonitorFromRenderFrame(
     int render_process_id,
     int render_frame_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::WebContents* const web_contents =
       content::WebContents::FromRenderFrameHost(
           content::RenderFrameHost::FromID(render_process_id, render_frame_id));
   if (!web_contents)
@@ skipping 182 matching lines @@
   // (i.e. chooseDesktopMedia() API wasn't used to generate device id).
   if (request.requested_video_device_id.empty()) {
     ProcessScreenCaptureAccessRequest(
         web_contents, request, callback, extension);
     return;
   }
 
   // The extension name that the stream is registered with.
   std::string original_extension_name;
   // Resolve DesktopMediaID for the specified device id.
-  content::DesktopMediaID media_id =
-      GetDesktopStreamsRegistry()->RequestMediaForStreamId(
-          request.requested_video_device_id, request.render_process_id,
-          request.render_view_id, request.security_origin,
-          &original_extension_name);
+  content::DesktopMediaID media_id;
+  // TODO(miu): Replace "main RenderFrame" IDs with the request's actual
+  // RenderFrame IDs once the desktop capture extension API implementation is
+  // fixed.  http://crbug.com/304341
+  content::WebContents* const web_contents_for_stream =
+      GetWebContentsFromRequest(request);
+  content::RenderFrameHost* const main_frame = web_contents_for_stream ?
+      web_contents_for_stream->GetMainFrame() : NULL;
+  if (main_frame) {
+    media_id = GetDesktopStreamsRegistry()->RequestMediaForStreamId(
+        request.requested_video_device_id,
+        main_frame->GetProcess()->GetID(),
+        main_frame->GetRoutingID(),

[ncarter (slow), 2014/07/11 22:32:24]

This ultimately should be request.render_process_id/request.render_frame ID,
right?

Why wouldn't that work right now?

[miu, 2014/07/12 03:16:29]

See TODO(miu) comment about 10 lines above.  ;-)

The problem is due to ExtensionFunction currently only supporting use of
render_view_host() and not render_frame_host().  The desktop capture API impl
has no way of knowing the exact RF that requested the stream, so it registers
the request with DesktopStreamsRegistry using the main RF's ID.  Therefore,
here, we have no choice but to request the media stream by the main RF ID.

[ncarter (slow), 2014/07/14 17:51:05]

Ah got it now. I'd seen the TODO but it hadn't quite clicked. So it's not that
request.render_frame_id isn't a valid frame (it is), but rather that the ID we
use here has to match code elsewhere.

+        request.security_origin,
+        &original_extension_name);
+  }
 
   // Received invalid device id.
   if (media_id.type == content::DesktopMediaID::TYPE_NONE) {
     callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
     return;
   }
 
   bool loopback_audio_supported = false;
 #if defined(USE_CRAS) || defined(OS_WIN)
   // Currently loopback audio capture is supported only on Windows and ChromeOS.
@@ skipping 126 matching lines @@
 #if defined(ENABLE_EXTENSIONS)
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   extensions::TabCaptureRegistry* tab_capture_registry =
       extensions::TabCaptureRegistry::Get(profile);
   if (!tab_capture_registry) {
     NOTREACHED();
     callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
     return;
   }
-  bool tab_capture_allowed =
-      tab_capture_registry->VerifyRequest(request.render_process_id,
-                                          request.render_view_id);
+  const bool tab_capture_allowed = tab_capture_registry->VerifyRequest(
+      GetWebContentsFromRequest(request), extension->id());
 
   if (request.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE &&
       tab_capture_allowed &&
       extension->permissions_data()->HasAPIPermission(
           extensions::APIPermission::kTabCapture)) {
     devices.push_back(content::MediaStreamDevice(
         content::MEDIA_TAB_AUDIO_CAPTURE, std::string(), std::string()));
   }
 
   if (request.video_type == content::MEDIA_TAB_VIDEO_CAPTURE &&
@@ skipping 236 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &MediaCaptureDevicesDispatcher::NotifyVideoDevicesChangedOnUIThread,
           base::Unretained(this)));
 }
 
 void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     int page_request_id,
     const GURL& security_origin,
-    const content::MediaStreamDevice& device,
+    content::MediaStreamType stream_type,
     content::MediaRequestState state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread,
-          base::Unretained(this), render_process_id, render_view_id,
-          page_request_id, security_origin, device, state));
+          base::Unretained(this), render_process_id, render_frame_id,
+          page_request_id, security_origin, stream_type, state));
 }
 
 void MediaCaptureDevicesDispatcher::OnAudioStreamPlaying(
     int render_process_id,
     int render_frame_id,
     int stream_id,
     const ReadPowerAndClipCallback& read_power_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 #if defined(AUDIO_STREAM_MONITORING)
   BrowserThread::PostTask(
@@ skipping 41 matching lines @@
 }
 
 void MediaCaptureDevicesDispatcher::NotifyVideoDevicesChangedOnUIThread() {
   MediaStreamDevices devices = GetVideoCaptureDevices();
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnUpdateVideoDevices(devices));
 }
 
 void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     int page_request_id,
     const GURL& security_origin,
-    const content::MediaStreamDevice& device,
+    content::MediaStreamType stream_type,
     content::MediaRequestState state) {
   // Track desktop capture sessions.  Tracking is necessary to avoid unbalanced
   // session counts since not all requests will reach MEDIA_REQUEST_STATE_DONE,
   // but they will all reach MEDIA_REQUEST_STATE_CLOSING.
-  if (device.type == content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
+  if (stream_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
     if (state == content::MEDIA_REQUEST_STATE_DONE) {
-      DesktopCaptureSession session = { render_process_id, render_view_id,
+      DesktopCaptureSession session = { render_process_id, render_frame_id,
                                         page_request_id };
       desktop_capture_sessions_.push_back(session);
     } else if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
       for (DesktopCaptureSessions::iterator it =
                desktop_capture_sessions_.begin();
            it != desktop_capture_sessions_.end();
            ++it) {
         if (it->render_process_id == render_process_id &&
-            it->render_view_id == render_view_id &&
+            it->render_frame_id == render_frame_id &&
             it->page_request_id == page_request_id) {
           desktop_capture_sessions_.erase(it);
           break;
         }
       }
     }
   }
 
   // Cancel the request.
   if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
     bool found = false;
     for (RequestsQueues::iterator rqs_it = pending_requests_.begin();
          rqs_it != pending_requests_.end(); ++rqs_it) {
       RequestsQueue& queue = rqs_it->second;
       for (RequestsQueue::iterator it = queue.begin();
            it != queue.end(); ++it) {
         if (it->request.render_process_id == render_process_id &&
-            it->request.render_view_id == render_view_id &&
+            it->request.render_frame_id == render_frame_id &&
             it->request.page_request_id == page_request_id) {
           queue.erase(it);
           found = true;
           break;
         }
       }
       if (found)
         break;
     }
   }
 
 #if defined(OS_CHROMEOS)
-  if (IsOriginForCasting(security_origin) && IsVideoMediaType(device.type)) {
+  if (IsOriginForCasting(security_origin) && IsVideoMediaType(stream_type)) {
     // Notify ash that casting state has changed.
     if (state == content::MEDIA_REQUEST_STATE_DONE) {
       ash::Shell::GetInstance()->OnCastingSessionStartedOrStopped(true);
     } else if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
       ash::Shell::GetInstance()->OnCastingSessionStartedOrStopped(false);
     }
   }
 #endif
 
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnRequestUpdate(render_process_id,
-                                    render_view_id,
-                                    device,
+                                    render_frame_id,
+                                    stream_type,
                                     state));
 }
 
 void MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread(
     int render_process_id,
     int render_frame_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnCreatingAudioStream(render_process_id, render_frame_id));
 #if defined(AUDIO_STREAM_MONITORING)
@@ skipping 16 matching lines @@
 
 void MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices(
     const MediaStreamDevices& devices) {
   test_audio_devices_ = devices;
 }
 
 void MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices(
     const MediaStreamDevices& devices) {
   test_video_devices_ = devices;
 }