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

chrome/browser/extensions/api/tab_capture/tab_capture_api.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.
 
 // Implements the Chrome Extensions Tab Capture API.
 
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_api.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
-#include "content/public/browser/render_view_host.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 
 using extensions::api::tab_capture::MediaStreamConstraint;
 
 namespace TabCapture = extensions::api::tab_capture;
 namespace GetCapturedTabs = TabCapture::GetCapturedTabs;
@@ skipping 60 matching lines @@
           switches::kWhitelistedExtensionID) != extension_id &&
       !SimpleFeature::IsIdInList(
           extension_id,
           std::set<std::string>(
               whitelisted_extensions,
               whitelisted_extensions + arraysize(whitelisted_extensions)))) {
     error_ = kGrantError;
     return false;
   }
 
-  content::RenderViewHost* const rvh = target_contents->GetRenderViewHost();
-  int render_process_id = rvh->GetProcess()->GetID();
-  int routing_id = rvh->GetRoutingID();
-
   // Create a constraints vector. We will modify all the constraints in this
   // vector to append our chrome specific constraints.
   std::vector<MediaStreamConstraint*> constraints;
   bool has_audio = params->options.audio.get() && *params->options.audio.get();
   bool has_video = params->options.video.get() && *params->options.video.get();
 
   if (!has_audio && !has_video) {
     error_ = kNoAudioOrVideo;
     return false;
   }
 
   if (has_audio) {
     if (!params->options.audio_constraints.get())
       params->options.audio_constraints.reset(new MediaStreamConstraint);
 
     constraints.push_back(params->options.audio_constraints.get());
   }
   if (has_video) {
     if (!params->options.video_constraints.get())
       params->options.video_constraints.reset(new MediaStreamConstraint);
 
     constraints.push_back(params->options.video_constraints.get());
   }
 
   // Device id we use for Tab Capture.
-  std::string device_id =
-      base::StringPrintf("%i:%i", render_process_id, routing_id);
+  content::RenderFrameHost* const main_frame = target_contents->GetMainFrame();
+  // TODO(miu): We should instead use a "randomly generated device ID" scheme,
+  // like that employed by the desktop capture API.  http://crbug.com/163100
+  const std::string device_id = base::StringPrintf(
+      "web-contents-media-stream://%i:%i",

[ncarter (slow), 2014/07/10 01:17:51]

Does introducing the scheme here fix a bug? How is this different from the
scheme applied by web_contents_capture_util?

https://code.google.com/p/chromium/codesearch#chromium/src/content/browser/me...

[miu, 2014/07/10 22:16:11]

It addresses crbug.com/163100.  There isn't really a difference, except that the
code in WCCaptureUtil to "append" and "strip" the scheme was deemed unnecessary
due to the major refactoring work done in MediaStreamManager.  In short, the
device ID string can just be generated here, and then remain unmodified
throughout the media request pipeline.

Also, per the TODO comment here, I'd like to see the tab capture API employ the
secure mechanism used by the desktop capture API, where random device ID strings
are created and then later verified.  Thus, the direction I'm starting to take
here is to move device ID string generation into the chrome/ layer; and
ultimately I'd like to eliminate the parsing of the device ID string in
libcontent entirely (just like desktop capture).

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

Acknowledged.

+      main_frame->GetProcess()->GetID(),
+      main_frame->GetRoutingID());
 
   // Append chrome specific tab constraints.
   for (std::vector<MediaStreamConstraint*>::iterator it = constraints.begin();
        it != constraints.end(); ++it) {
     base::DictionaryValue* constraint = &(*it)->mandatory.additional_properties;
     constraint->SetString(kMediaStreamSource, kMediaStreamSourceTab);
     constraint->SetString(kMediaStreamSourceId, device_id);
   }
 
   extensions::TabCaptureRegistry* registry =
       extensions::TabCaptureRegistry::Get(GetProfile());
-  if (!registry->AddRequest(render_process_id,
-                            routing_id,
+  if (!registry->AddRequest(target_contents,
                             extension_id,
                             tab_id,
                             tab_capture::TAB_CAPTURE_STATE_NONE)) {
     error_ = kCapturingSameTab;
     return false;
   }
 
   // Copy the result from our modified input parameters. This will be
   // intercepted by custom bindings which will build and send the special
   // WebRTC user media request.
@@ skipping 18 matching lines @@
     info->tab_id = it->first;
     info->status = it->second;
     list->Append(info->ToValue().release());
   }
 
   SetResult(list);
   return true;
 }
 
 }  // namespace extensions