Make it so that allow_js_access: false can be used with background pages created by window.open.

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 2271 matching lines @@
 
 void Browser::OpenBookmarkManagerForNode(int64 node_id) {
   OpenBookmarkManagerWithHash("", node_id);
 }
 
 void Browser::OpenBookmarkManagerEditNode(int64 node_id) {
   OpenBookmarkManagerWithHash("e=", node_id);
 }
 
 bool Browser::MaybeCreateBackgroundContents(int route_id,
-                                            SiteInstance* site,
-                                            const GURL& opener_url,
-                                            const string16& frame_name) {
+                                            WebContents* opener_web_contents,
+                                            const string16& frame_name,
+                                            const GURL& target_url) {
+  GURL opener_url = opener_web_contents->GetURL();
   ExtensionService* extensions_service = profile_->GetExtensionService();
 
   if (!opener_url.is_valid() ||
       frame_name.empty() ||
       !extensions_service ||
       !extensions_service->is_ready())
     return false;
 
   // Only hosted apps have web extents, so this ensures that only hosted apps
   // can create BackgroundContents. We don't have to check for background
   // permission as that is checked in RenderMessageFilter when the CreateWindow
   // message is processed.
   const Extension* extension =
       extensions_service->extensions()->GetHostedAppByURL(
           ExtensionURLInfo(opener_url));
   if (!extension)
     return false;
 
   // No BackgroundContents allowed if BackgroundContentsService doesn't exist.
   BackgroundContentsService* service =
       BackgroundContentsServiceFactory::GetForProfile(profile_);
   if (!service)
     return false;
 
   // Ensure that we're trying to open this from the extension's process.
+  SiteInstance* opener_site_instance = opener_web_contents->GetSiteInstance();
   extensions::ProcessMap* process_map = extensions_service->process_map();
-  if (!site->GetProcess() ||
-      !process_map->Contains(extension->id(), site->GetProcess()->GetID())) {
+  if (!opener_site_instance->GetProcess() ||
+      !process_map->Contains(
+          extension->id(), opener_site_instance->GetProcess()->GetID())) {
     return false;
   }
 
   // Only allow a single background contents per app. If one already exists,
   // close it (even if it was specified in the manifest).
   BackgroundContents* existing =
       service->GetAppBackgroundContents(ASCIIToUTF16(extension->id()));
   if (existing) {
     DLOG(INFO) << "Closing existing BackgroundContents for " << opener_url;
     delete existing;
   }
 
+  // If script access is not allowed, create the the background contents in a
+  // new SiteInstance, so that a separate process is used.
+  bool allow_js_access = extension->allow_background_js_access();
+  scoped_refptr<content::SiteInstance> site_instance =
+      allow_js_access ?
+      opener_site_instance :
+      content::SiteInstance::Create(opener_web_contents->GetBrowserContext());
+
   // Passed all the checks, so this should be created as a BackgroundContents.
-  BackgroundContents* contents =
-      service->CreateBackgroundContents(site, route_id, profile_, frame_name,
-                                        ASCIIToUTF16(extension->id()));
+  BackgroundContents* contents = service->CreateBackgroundContents(
+      site_instance,
+      route_id,
+      profile_,
+      frame_name,
+      ASCIIToUTF16(extension->id()));
+
+  // When a separate process is used, the original renderer cannot access the
+  // new window later, thus we need to navigate the window now.
+  if (contents && !allow_js_access) {
+    contents->web_contents()->GetController().LoadURL(
+        target_url,
+        content::Referrer(),
+        content::PAGE_TRANSITION_LINK,
+        std::string());  // No extra headers.
+  }
+
   return contents != NULL;
 }
 
 void Browser::ShowAppMenu() {
   // We record the user metric for this event in WrenchMenu::RunMenu.
   window_->ShowAppMenu();
 }
 
 void Browser::ShowAvatarMenu() {
   window_->ShowAvatarBubbleFromAvatarButton();
@@ skipping 1716 matching lines @@
     const history::HistoryAddPageArgs& add_page_args,
     content::NavigationType navigation_type) {
   // Don't update history if running as app.
   return !IsApplication();
 }
 
 bool Browser::ShouldCreateWebContents(
     WebContents* web_contents,
     int route_id,
     WindowContainerType window_container_type,
-    const string16& frame_name) {
+    const string16& frame_name,
+    const GURL& target_url) {
   if (window_container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
     // If a BackgroundContents is created, suppress the normal WebContents.
     return !MaybeCreateBackgroundContents(
-        route_id,
-        web_contents->GetSiteInstance(),
-        web_contents->GetURL(),
-        frame_name);
+        route_id, web_contents, frame_name, target_url);
   }
 
   return true;
 }
 
 void Browser::WebContentsCreated(WebContents* source_contents,
                                  int64 source_frame_id,
                                  const GURL& target_url,
                                  WebContents* new_contents) {
   // Create a TabContentsWrapper now, so all observers are in place, as the
@@ skipping 1583 matching lines @@
   } else {
     LoginUIServiceFactory::GetForProfile(
         profile()->GetOriginalProfile())->ShowLoginUI(false);
   }
 #endif
 }
 
 void Browser::ToggleSpeechInput() {
   GetSelectedWebContents()->GetRenderViewHost()->ToggleSpeechInput();
 }