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

chrome/browser/extensions/api/desktop_capture/desktop_capture_api.cc

 // Copyright 2013 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/extensions/api/desktop_capture/desktop_capture_api.h"
 
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 // static
 void DesktopCaptureChooseDesktopMediaFunction::SetPickerFactoryForTests(
     PickerFactory* factory) {
   g_picker_factory = factory;
 }
 
 DesktopCaptureChooseDesktopMediaFunction::
-    DesktopCaptureChooseDesktopMediaFunction()
-    : render_process_id_(0),
-      render_view_id_(0) {
+    DesktopCaptureChooseDesktopMediaFunction() {
 }
 
 DesktopCaptureChooseDesktopMediaFunction::
     ~DesktopCaptureChooseDesktopMediaFunction() {
   // RenderViewHost may be already destroyed.
   if (render_view_host()) {

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

As you are probably aware, these would ideally be render_frame_host()'s, but the
ExtensionFunctionDispatcher isn't quite wired up to let that happen yet.

     DesktopCaptureRequestsRegistry::GetInstance()->RemoveRequest(
         render_view_host()->GetProcess()->GetID(), request_id_);
   }
 }
 
 void DesktopCaptureChooseDesktopMediaFunction::Cancel() {
   // Keep reference to |this| to ensure the object doesn't get destroyed before
   // we return.
   scoped_refptr<DesktopCaptureChooseDesktopMediaFunction> self(this);
   if (picker_) {
     picker_.reset();
     SetResult(new base::StringValue(std::string()));
     SendResponse(true);
   }
 }
 
 bool DesktopCaptureChooseDesktopMediaFunction::RunAsync() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetSize() > 0);
 
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &request_id_));
   args_->Remove(0, NULL);
 
   scoped_ptr<api::desktop_capture::ChooseDesktopMedia::Params> params =
       api::desktop_capture::ChooseDesktopMedia::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   DesktopCaptureRequestsRegistry::GetInstance()->AddRequest(
       render_view_host()->GetProcess()->GetID(), request_id_, this);
 
+  // |web_contents_for_stream| is the WebContents for which the stream is
+  // created.  On the other hand, |web_contents_for_picker| is used to determine
+  // where to show the picker's UI.
+  content::WebContents* web_contents_for_stream = NULL;
   gfx::NativeWindow parent_window = NULL;
-  content::RenderViewHost* render_view = NULL;
-  content::WebContents* web_contents = NULL;
+  content::WebContents* web_contents_for_picker = NULL;

[Sergey Ulanov, 2014/07/09 18:06:24]

The same WebContents should be used for both picker and for the stream, i.e.
picker should be shown in the context of the tab/window that will be using the
stream.

[miu, 2014/07/09 23:28:04]

Done.  However, I should point out I wasn't actually changing the prior behavior
here.  Please see next comment response for more details...

   base::string16 target_name;
   if (params->target_tab) {
     if (!params->target_tab->url) {
       error_ = kNoUrlError;
       return false;
     }
     origin_ = GURL(*(params->target_tab->url)).GetOrigin();
 
     if (!CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAllowHttpScreenCapture) &&
         !origin_.SchemeIsSecure()) {
       error_ = kTabUrlNotSecure;
       return false;
     }
     target_name = base::UTF8ToUTF16(origin_.SchemeIsSecure() ?
         net::GetHostAndOptionalPort(origin_) : origin_.spec());
 
     if (!params->target_tab->id) {
       error_ = kNoTabIdError;
       return false;
     }
 
-    if (!ExtensionTabUtil::GetTabById(*(params->target_tab->id), GetProfile(),
-                                      true, NULL, NULL, &web_contents, NULL)) {
+    if (!ExtensionTabUtil::GetTabById(
+            *(params->target_tab->id), GetProfile(), true, NULL, NULL,
+            &web_contents_for_stream, NULL)) {
       error_ = kInvalidTabIdError;
       return false;
     }
+    DCHECK(web_contents_for_stream);
 
     GURL current_origin_ =
-        web_contents->GetLastCommittedURL().GetOrigin();
+        web_contents_for_stream->GetLastCommittedURL().GetOrigin();
     if (current_origin_ != origin_) {
       error_ = kTabUrlChangedError;
       return false;
     }
 
-    // Register to be notified when the tab is closed.
-    Observe(web_contents);
-
-    render_view = web_contents->GetRenderViewHost();
-    parent_window = web_contents->GetTopLevelNativeWindow();
+    web_contents_for_picker = web_contents_for_stream;
+    parent_window = web_contents_for_picker->GetTopLevelNativeWindow();
   } else {
     origin_ = GetExtension()->url();
     target_name = base::UTF8ToUTF16(GetExtension()->name());
-    render_view = render_view_host();
-
-    web_contents = GetAssociatedWebContents();
-    if (web_contents) {
-      parent_window = web_contents->GetTopLevelNativeWindow();
+    web_contents_for_stream =
+        content::WebContents::FromRenderViewHost(render_view_host());
+    DCHECK(web_contents_for_stream);
+    web_contents_for_picker = GetAssociatedWebContents();

[Sergey Ulanov, 2014/07/09 18:06:24]

I think this will always return the same WebContents that you get in line 140
(WebContents this call came from).

[miu, 2014/07/09 23:28:04]

It doesn't.  The DesktopCaptureApiTest.ChooseDesktopMedia test was failing for
the chooseMediaAndGetStream() step.  The root cause was that
GetAssociatedWebContents() was returning the WebContents for the currently
active tab, rather than the one requesting the stream.  See:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...

I've fixed everything to use the WebContents for the current JS context (the
consumer of the stream).  Let me know if I should revert.

+    if (web_contents_for_picker) {
+      parent_window = web_contents_for_picker->GetTopLevelNativeWindow();
     } else {
 #if defined(USE_ASH)
       if (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_ASH)
         parent_window = ash::Shell::GetPrimaryRootWindow();
 #endif
     }
   }
 
-  render_process_id_ = render_view->GetProcess()->GetID();
-  render_view_id_ = render_view->GetRoutingID();
+  // Register to be notified when the tab is closed.
+  Observe(web_contents_for_stream);
 
   bool show_screens = false;
   bool show_windows = false;
 
   for (std::vector<api::desktop_capture::DesktopCaptureSourceType>::iterator
        it = params->sources.begin(); it != params->sources.end(); ++it) {
     switch (*it) {
       case api::desktop_capture::DESKTOP_CAPTURE_SOURCE_TYPE_NONE:
         error_ = kInvalidSourceNameError;
         return false;
@@ skipping 48 matching lines @@
 #if defined(TOOLKIT_VIEWS) || defined(OS_MACOSX)
     picker_ = DesktopMediaPicker::Create();
 #else
     error_ = "Desktop Capture API is not yet implemented for this platform.";
     return false;
 #endif
   }
   DesktopMediaPicker::DoneCallback callback = base::Bind(
       &DesktopCaptureChooseDesktopMediaFunction::OnPickerDialogResults, this);
 
-  picker_->Show(web_contents,
+  picker_->Show(web_contents_for_picker,
                 parent_window, parent_window,
                 base::UTF8ToUTF16(GetExtension()->name()),
                 target_name,
                 media_list.Pass(), callback);
   return true;
 }
 
 void DesktopCaptureChooseDesktopMediaFunction::WebContentsDestroyed() {
   Cancel();
 }
 
 void DesktopCaptureChooseDesktopMediaFunction::OnPickerDialogResults(
     content::DesktopMediaID source) {
   std::string result;
-  if (source.type != content::DesktopMediaID::TYPE_NONE) {
+  if (source.type != content::DesktopMediaID::TYPE_NONE &&
+      web_contents()) {
     DesktopStreamsRegistry* registry =
         MediaCaptureDevicesDispatcher::GetInstance()->
         GetDesktopStreamsRegistry();
     result = registry->RegisterStream(
-        render_process_id_,
-        render_view_id_,
+        web_contents(),
         origin_,
         source,
         GetExtension()->name());
   }
 
   SetResult(new base::StringValue(result));
   SendResponse(true);
 }
 
 DesktopCaptureRequestsRegistry::RequestId::RequestId(int process_id,
@@ skipping 49 matching lines @@
 
 void DesktopCaptureRequestsRegistry::CancelRequest(int process_id,
                                                    int request_id) {
   RequestsMap::iterator it = requests_.find(RequestId(process_id, request_id));
   if (it != requests_.end())
     it->second->Cancel();
 }
 
 
 }  // namespace extensions