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

content/browser/renderer_host/media/media_stream_manager.cc

Index: content/browser/renderer_host/media/media_stream_manager.cc
diff --git a/content/browser/renderer_host/media/media_stream_manager.cc b/content/browser/renderer_host/media/media_stream_manager.cc
index 2b337cafa7849329481813673e58f75d98338f05..21d2aa4ce2e1ce7c0da8cbdc3fbe1b9887938152 100644
--- a/content/browser/renderer_host/media/media_stream_manager.cc
+++ b/content/browser/renderer_host/media/media_stream_manager.cc
@@ -183,7 +183,7 @@ class MediaStreamManager::DeviceRequest {
  public:
   DeviceRequest(MediaStreamRequester* requester,
                 int requesting_process_id,
-                int requesting_view_id,
+                int requesting_frame_id,
                 int page_request_id,
                 const GURL& security_origin,
                 bool have_permission,
@@ -193,7 +193,7 @@ class MediaStreamManager::DeviceRequest {
                 const ResourceContext::SaltCallback& salt_callback)
       : requester(requester),
         requesting_process_id(requesting_process_id),
-        requesting_view_id(requesting_view_id),
+        requesting_frame_id(requesting_frame_id),
         page_request_id(page_request_id),
         security_origin(security_origin),
         have_permission(have_permission),
@@ -230,7 +230,7 @@ class MediaStreamManager::DeviceRequest {
                        const std::string& requested_video_device_id) {
     DCHECK(!ui_request_);
     ui_request_.reset(new MediaStreamRequest(requesting_process_id,
-                                             requesting_view_id,
+                                             requesting_frame_id,
                                              page_request_id,
                                              security_origin,
                                              user_gesture,
@@ -243,12 +243,12 @@ class MediaStreamManager::DeviceRequest {
 
   // Creates a tab capture specific MediaStreamRequest object that is used by
   // this request when UI is asked for permission and device selection.
-  void CreateTabCatureUIRequest(int target_render_process_id,
-                                int target_render_view_id,
-                                const std::string& tab_capture_id) {
+  void CreateTabCaptureUIRequest(int target_render_process_id,
+                                 int target_render_frame_id,
+                                 const std::string& tab_capture_id) {
     DCHECK(!ui_request_);
     ui_request_.reset(new MediaStreamRequest(target_render_process_id,
-                                             target_render_view_id,
+                                             target_render_frame_id,
                                              page_request_id,
                                              security_origin,
                                              user_gesture,
@@ -283,17 +283,10 @@ class MediaStreamManager::DeviceRequest {
     if (!ui_request_)
       return;
 
-    // If we appended a device_id scheme, we want to remove it when notifying
-    // observers which may be in different modules since this scheme is only
-    // used internally within the content module.
-    std::string device_id =
-        WebContentsCaptureUtil::StripWebContentsDeviceScheme(
-            ui_request_->tab_capture_device_id);
-
     media_observer->OnMediaRequestStateChanged(
-        ui_request_->render_process_id, ui_request_->render_view_id,
+        ui_request_->render_process_id, ui_request_->render_frame_id,
         ui_request_->page_request_id, ui_request_->security_origin,
-        MediaStreamDevice(stream_type, device_id, device_id), new_state);
+        stream_type, new_state);
   }
 
   MediaRequestState state(MediaStreamType stream_type) const {
@@ -309,13 +302,13 @@ class MediaStreamManager::DeviceRequest {
   // specifies the target renderer from which audio and video is captured.
   const int requesting_process_id;
 
-  // The render view id that requested this stream to be generated and that
+  // The render frame id that requested this stream to be generated and that
   // will receive a handle to the MediaStream. This may be different from
-  // MediaStreamRequest::render_view_id which in the tab capture case
+  // MediaStreamRequest::render_frame_id which in the tab capture case
   // specifies the target renderer from which audio and video is captured.
-  const int requesting_view_id;
+  const int requesting_frame_id;
 
-  // An ID the render view provided to identify this request.
+  // An ID the render frame provided to identify this request.
   const int page_request_id;
 
   const GURL security_origin;
@@ -414,7 +407,7 @@ AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() {
 
 std::string MediaStreamManager::MakeMediaAccessRequest(
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     int page_request_id,
     const StreamOptions& options,
     const GURL& security_origin,
@@ -425,7 +418,7 @@ std::string MediaStreamManager::MakeMediaAccessRequest(
   // suggests that this is the wrong design. Can this be refactored?
   DeviceRequest* request = new DeviceRequest(NULL,
                                              render_process_id,
-                                             render_view_id,
+                                             render_frame_id,
                                              page_request_id,
                                              security_origin,
                                              true,
@@ -451,7 +444,7 @@ std::string MediaStreamManager::MakeMediaAccessRequest(
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
-                                        int render_view_id,
+                                        int render_frame_id,
                                         const ResourceContext::SaltCallback& sc,
                                         int page_request_id,
                                         const StreamOptions& options,
@@ -466,7 +459,7 @@ void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
-                                             render_view_id,
+                                             render_frame_id,
                                              page_request_id,
                                              security_origin,
                                              true,
@@ -489,13 +482,13 @@ void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
 }
 
 void MediaStreamManager::CancelRequest(int render_process_id,
-                                       int render_view_id,
+                                       int render_frame_id,
                                        int page_request_id) {
   for (DeviceRequests::const_iterator request_it = requests_.begin();
        request_it != requests_.end(); ++request_it) {
     const DeviceRequest* request = request_it->second;
     if (request->requesting_process_id == render_process_id &&
-        request->requesting_view_id == render_view_id &&
+        request->requesting_frame_id == render_frame_id &&
         request->page_request_id == page_request_id) {
       CancelRequest(request_it->first);
       return;
@@ -557,19 +550,19 @@ void MediaStreamManager::CancelAllRequests(int render_process_id) {
 }
 
 void MediaStreamManager::StopStreamDevice(int render_process_id,
-                                          int render_view_id,
+                                          int render_frame_id,
                                           const std::string& device_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DVLOG(1) << "StopStreamDevice({render_view_id = " << render_view_id <<  "} "
+  DVLOG(1) << "StopStreamDevice({render_frame_id = " << render_frame_id <<  "} "
            << ", {device_id = " << device_id << "})";
-  // Find the first request for this |render_process_id| and |render_view_id|
+  // Find the first request for this |render_process_id| and |render_frame_id|
   // of type MEDIA_GENERATE_STREAM that has requested to use |device_id| and
   // stop it.
   for (DeviceRequests::iterator request_it = requests_.begin();
-       request_it  != requests_.end(); ++request_it) {
+       request_it != requests_.end(); ++request_it) {
     DeviceRequest* request = request_it->second;
     if (request->requesting_process_id != render_process_id ||
-        request->requesting_view_id != render_view_id ||
+        request->requesting_frame_id != render_frame_id ||
         request->request_type != MEDIA_GENERATE_STREAM) {
       continue;
     }
@@ -648,7 +641,7 @@ void MediaStreamManager::CloseDevice(MediaStreamType type, int session_id) {
 std::string MediaStreamManager::EnumerateDevices(
     MediaStreamRequester* requester,
     int render_process_id,
-    int render_view_id,
+    int render_frame_id,
     const ResourceContext::SaltCallback& sc,
     int page_request_id,
     MediaStreamType type,
@@ -662,7 +655,7 @@ std::string MediaStreamManager::EnumerateDevices(
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
-                                             render_view_id,
+                                             render_frame_id,
                                              page_request_id,
                                              security_origin,
                                              have_permission,
@@ -733,8 +726,7 @@ void MediaStreamManager::DoEnumerateDevices(const std::string& label) {
   DVLOG(1) << "Enumerate Devices ({label = " << label <<  "})";
 }
 
-void MediaStreamManager::EnumerateAudioOutputDevices(
-    const std::string& label) {
+void MediaStreamManager::EnumerateAudioOutputDevices(const std::string& label) {
   DCHECK(device_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<media::AudioDeviceNames> device_names(
@@ -786,7 +778,7 @@ void MediaStreamManager::AudioOutputDevicesEnumerated(
 
 void MediaStreamManager::OpenDevice(MediaStreamRequester* requester,
                                     int render_process_id,
-                                    int render_view_id,
+                                    int render_frame_id,
                                     const ResourceContext::SaltCallback& sc,
                                     int page_request_id,
                                     const std::string& device_id,
@@ -810,7 +802,7 @@ void MediaStreamManager::OpenDevice(MediaStreamRequester* requester,
   }
   DeviceRequest* request = new DeviceRequest(requester,
                                              render_process_id,
-                                             render_view_id,
+                                             render_frame_id,
                                              page_request_id,
                                              security_origin,
                                              true,
@@ -910,7 +902,7 @@ void MediaStreamManager::StopRemovedDevice(const MediaStreamDevice& device) {
         session_ids.push_back(device_it->session_id);
         if (it->second->requester) {
           it->second->requester->DeviceStopped(
-              it->second->requesting_view_id,
+              it->second->requesting_frame_id,
               it->first,
               *device_it);
         }
@@ -1295,17 +1287,10 @@ bool MediaStreamManager::SetupTabCaptureRequest(DeviceRequest* request) {
 
   // Customize options for a WebContents based capture.
   int target_render_process_id = 0;
-  int target_render_view_id = 0;
-
-  // TODO(justinlin): Can't plumb audio mirroring using stream type right
-  // now, so plumbing by device_id. Will revisit once it's refactored.
-  // http://crbug.com/163100
-  std::string tab_capture_device_id =
-      WebContentsCaptureUtil::AppendWebContentsDeviceScheme(capture_device_id);
+  int target_render_frame_id = 0;
 
   bool has_valid_device_id = WebContentsCaptureUtil::ExtractTabCaptureTarget(
-      tab_capture_device_id, &target_render_process_id,
-      &target_render_view_id);
+      capture_device_id, &target_render_process_id, &target_render_frame_id);
   if (!has_valid_device_id ||
       (request->audio_type() != MEDIA_TAB_AUDIO_CAPTURE &&
        request->audio_type() != MEDIA_NO_SERVICE) ||
@@ -1314,15 +1299,15 @@ bool MediaStreamManager::SetupTabCaptureRequest(DeviceRequest* request) {
     return false;
   }
 
-  request->CreateTabCatureUIRequest(target_render_process_id,
-                                    target_render_view_id,
-                                    tab_capture_device_id);
+  request->CreateTabCaptureUIRequest(target_render_process_id,
+                                     target_render_frame_id,
+                                     capture_device_id);
 
   DVLOG(3) << "SetupTabCaptureRequest "
-           << ", {tab_capture_device_id = " << tab_capture_device_id <<  "}"
+           << ", {capture_device_id = " << capture_device_id <<  "}"
            << ", {target_render_process_id = " << target_render_process_id
            << "}"
-           << ", {target_render_view_id = " << target_render_view_id << "}";
+           << ", {target_render_frame_id = " << target_render_frame_id << "}";
   return true;
 }
 
@@ -1394,7 +1379,7 @@ bool MediaStreamManager::FindExistingRequestedDeviceInfo(
        it != requests_.end() ; ++it) {
     const DeviceRequest* request = it->second;
     if (request->requesting_process_id == new_request.requesting_process_id &&
-        request->requesting_view_id == new_request.requesting_view_id &&
+        request->requesting_frame_id == new_request.requesting_frame_id &&
         request->request_type == new_request.request_type) {
       for (StreamDeviceInfoArray::const_iterator device_it =
                request->devices.begin();
@@ -1431,7 +1416,7 @@ void MediaStreamManager::FinalizeGenerateStream(const std::string& label,
   }
 
   request->requester->StreamGenerated(
-      request->requesting_view_id,
+      request->requesting_frame_id,
       request->page_request_id,
       label, audio_devices, video_devices);
 }
@@ -1442,7 +1427,7 @@ void MediaStreamManager::FinalizeRequestFailed(
     content::MediaStreamRequestResult result) {
   if (request->requester)
     request->requester->StreamGenerationFailed(
-        request->requesting_view_id,
+        request->requesting_frame_id,
         request->page_request_id,
         result);
 
@@ -1457,7 +1442,7 @@ void MediaStreamManager::FinalizeRequestFailed(
 void MediaStreamManager::FinalizeOpenDevice(const std::string& label,
                                             DeviceRequest* request) {
   const StreamDeviceInfoArray& requested_devices = request->devices;
-  request->requester->DeviceOpened(request->requesting_view_id,
+  request->requester->DeviceOpened(request->requesting_frame_id,
                                    request->page_request_id,
                                    label, requested_devices.front());
 }
@@ -1480,7 +1465,7 @@ void MediaStreamManager::FinalizeEnumerateDevices(const std::string& label,
     ClearDeviceLabels(&request->devices);
 
   request->requester->DevicesEnumerated(
-      request->requesting_view_id,
+      request->requesting_frame_id,
       request->page_request_id,
       label,
       request->devices);
@@ -1817,8 +1802,6 @@ void MediaStreamManager::HandleAccessRequestResponse(
     StreamDeviceInfo device_info;
     device_info.device = *device_it;
 
-    // TODO(justinlin): Nicer way to do this?
-    // Re-append the device's id since we lost it when posting request to UI.
     if (device_info.device.type == content::MEDIA_TAB_VIDEO_CAPTURE ||
         device_info.device.type == content::MEDIA_TAB_AUDIO_CAPTURE) {
       device_info.device.id = request->UIRequest()->tab_capture_device_id;
@@ -1847,7 +1830,7 @@ void MediaStreamManager::HandleAccessRequestResponse(
     }
 
     // If this is request for a new MediaStream, a device is only opened once
-    // per render view. This is so that the permission to use a device can be
+    // per render frame. This is so that the permission to use a device can be
     // revoked by a single call to StopStreamDevice regardless of how many
     // MediaStreams it is being used in.
     if (request->request_type == MEDIA_GENERATE_STREAM) {
@@ -1900,7 +1883,7 @@ void MediaStreamManager::StopMediaStreamFromBrowser(const std::string& label) {
   if (request->requester) {
     for (StreamDeviceInfoArray::iterator device_it = request->devices.begin();
          device_it != request->devices.end(); ++device_it) {
-      request->requester->DeviceStopped(request->requesting_view_id,
+      request->requester->DeviceStopped(request->requesting_frame_id,
                                         label,
                                         *device_it);
     }