[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 338 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 =
+      content::WebContents::FromRenderFrameHost(
+          content::RenderFrameHost::FromID(request.render_process_id,
+                                           request.render_frame_id));
+  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(),
+        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(
+      request.render_process_id, request.render_frame_id, 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 &&
       tab_capture_allowed &&
       extension->permissions_data()->HasAPIPermission(
           extensions::APIPermission::kTabCapture)) {
     devices.push_back(content::MediaStreamDevice(
         content::MEDIA_TAB_VIDEO_CAPTURE, std::string(), std::string()));
   }
 
   if (!devices.empty()) {
     ui = media_stream_capture_indicator_->RegisterMediaStream(
         web_contents, devices);
   }
   callback.Run(
     devices,
     devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
                       content::MEDIA_DEVICE_OK,
     ui.Pass());
 #else  // defined(ENABLE_EXTENSIONS)
   callback.Run(devices, content::MEDIA_DEVICE_TAB_CAPTURE_FAILURE, ui.Pass());
-#endif  // !defined(OS_ANDROID)
+#endif  // defined(ENABLE_EXTENSIONS)
 }
 
 void MediaCaptureDevicesDispatcher::
     ProcessMediaAccessRequestFromPlatformAppOrExtension(
         content::WebContents* web_contents,
         const content::MediaStreamRequest& request,
         const content::MediaResponseCallback& callback,
         const extensions::Extension* extension) {
   content::MediaStreamDevices devices;
   Profile* profile =
@@ skipping 207 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;
 }