Make window.open() IPCs be frame-based

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 2260 matching lines @@
 ChromeContentBrowserClient::GetPlatformNotificationService() {
 #if defined(ENABLE_NOTIFICATIONS)
   return PlatformNotificationServiceImpl::GetInstance();
 #else
   NOTIMPLEMENTED();
   return NULL;
 #endif
 }
 
 bool ChromeContentBrowserClient::CanCreateWindow(
+    int opener_render_process_id,
+    int opener_render_frame_id,
     const GURL& opener_url,
     const GURL& opener_top_level_frame_url,
     const GURL& source_origin,
     WindowContainerType container_type,
     const GURL& target_url,
     const content::Referrer& referrer,
     const std::string& frame_name,
     WindowOpenDisposition disposition,
     const WebWindowFeatures& features,
     bool user_gesture,
     bool opener_suppressed,
     content::ResourceContext* context,
-    int render_process_id,
-    int opener_render_view_id,
-    int opener_render_frame_id,
     bool* no_javascript_access) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   *no_javascript_access = false;
 
   // If the opener is trying to create a background window but doesn't have
   // the appropriate permission, fail the attempt.
   if (container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
     ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
     InfoMap* map = io_data->GetExtensionInfoMap();
-    if (!map->SecurityOriginHasAPIPermission(
-            source_origin,
-            render_process_id,
-            APIPermission::kBackground)) {
+    if (!map->SecurityOriginHasAPIPermission(source_origin,
+                                             opener_render_process_id,
+                                             APIPermission::kBackground)) {
       return false;
     }
 
     // Note: this use of GetExtensionOrAppByURL is safe but imperfect.  It may
     // return a recently installed Extension even if this CanCreateWindow call
     // was made by an old copy of the page in a normal web process.  That's ok,
     // because the permission check above would have caused an early return
     // already. We must use the full URL to find hosted apps, though, and not
     // just the origin.
     const Extension* extension =
         map->extensions().GetExtensionOrAppByURL(opener_url);
     if (extension && !extensions::BackgroundInfo::AllowJSAccess(extension))
       *no_javascript_access = true;
 #endif
 
     return true;
   }
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   if (extensions::WebViewRendererState::GetInstance()->IsGuest(
-      render_process_id)) {
+          opener_render_process_id)) {
     return true;
   }
 
   if (target_url.SchemeIs(extensions::kExtensionScheme) ||
       target_url.SchemeIs(extensions::kExtensionResourceScheme)) {
     // Intentionally duplicating |io_data| and |map| code from above because we
     // want to reduce calls to retrieve them as this function is a SYNC IPC
     // handler.
     ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
     InfoMap* map = io_data->GetExtensionInfoMap();
@@ skipping 18 matching lines @@
 
   HostContentSettingsMap* content_settings =
       ProfileIOData::FromResourceContext(context)->GetHostContentSettingsMap();
 
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (FlashDownloadInterception::ShouldStopFlashDownloadAction(
           content_settings, opener_top_level_frame_url, target_url,
           user_gesture)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&HandleFlashDownloadActionOnUIThread, render_process_id,
-                   opener_render_frame_id, opener_top_level_frame_url));
+        base::Bind(&HandleFlashDownloadActionOnUIThread,
+                   opener_render_process_id, opener_render_frame_id,
+                   opener_top_level_frame_url));
     return false;
   }
 #endif
 
-  BlockedWindowParams blocked_params(target_url,
-                                     referrer,
-                                     frame_name,
-                                     disposition,
-                                     features,
-                                     user_gesture,
-                                     opener_suppressed,
-                                     render_process_id,
-                                     opener_render_frame_id);
+  BlockedWindowParams blocked_params(
+      target_url, referrer, frame_name, disposition, features, user_gesture,
+      opener_suppressed, opener_render_process_id, opener_render_frame_id);
 
   if (!user_gesture &&
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisablePopupBlocking)) {
     if (content_settings->GetContentSetting(opener_top_level_frame_url,
                                             opener_top_level_frame_url,
                                             CONTENT_SETTINGS_TYPE_POPUPS,
                                             std::string()) !=
         CONTENT_SETTING_ALLOW) {
       BrowserThread::PostTask(BrowserThread::UI,
                               FROM_HERE,
                               base::Bind(&HandleBlockedPopupOnUIThread,
                                          blocked_params));
       return false;
     }
   }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
-  if (SingleTabModeTabHelper::IsRegistered(render_process_id,
-                                           opener_render_view_id)) {
+  if (SingleTabModeTabHelper::IsRegistered(opener_render_process_id,
+                                           opener_render_frame_id)) {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&HandleSingleTabModeBlockOnUIThread,
                                        blocked_params));
     return false;
   }
 #endif
 
   return true;
 }
@@ skipping 899 matching lines @@
       render_frame_host, std::move(source), std::move(request));
 #else
   // Chrome's media remoting implementation depends on the Media Router
   // infrastructure to identify remote sinks and provide the user interface for
   // sink selection. In the case where the Media Router is not present, simply
   // drop the interface request. This will prevent code paths for media remoting
   // in the renderer process from activating.
 #endif
 }
 #endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING)