Give the main frame a RenderWidget.

chrome/browser/ui/browser.cc

 // Copyright 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  // defined(OS_WIN)
@@ skipping 1638 matching lines @@
   chrome::ViewSource(this, source, frame_url, frame_page_state);
 }
 
 void Browser::ShowRepostFormWarningDialog(WebContents* source) {
   TabModalConfirmDialog::Create(new RepostFormWarningController(source),
                                 source);
 }
 
 bool Browser::ShouldCreateWebContents(
     WebContents* web_contents,
-    int route_id,
-    int main_frame_route_id,
+    int32_t route_id,
+    int32_t main_frame_route_id,
+    int32_t main_frame_widget_route_id,
     WindowContainerType window_container_type,
     const std::string& frame_name,
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
   if (window_container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
     // If a BackgroundContents is created, suppress the normal WebContents.
-    return !MaybeCreateBackgroundContents(route_id,
-                                          main_frame_route_id,
-                                          web_contents,
-                                          frame_name,
-                                          target_url,
-                                          partition_id,
-                                          session_storage_namespace);
+    return !MaybeCreateBackgroundContents(
+        route_id, main_frame_route_id, main_frame_widget_route_id, web_contents,
+        frame_name, target_url, partition_id, session_storage_namespace);
   }
 
   return true;
 }
 
 void Browser::WebContentsCreated(WebContents* source_contents,
                                  int opener_render_frame_id,
                                  const std::string& frame_name,
                                  const GURL& target_url,
                                  WebContents* new_contents) {
@@ skipping 928 matching lines @@
   //    environment is still active.
   if (host_desktop_type() == chrome::HOST_DESKTOP_TYPE_NATIVE)
     return !ash::Shell::HasInstance();
   if (host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH)
     return BrowserList::GetInstance(chrome::HOST_DESKTOP_TYPE_NATIVE)->empty();
 #endif
   return true;
 }
 
 bool Browser::MaybeCreateBackgroundContents(
-    int route_id,
-    int main_frame_route_id,
+    int32_t route_id,
+    int32_t main_frame_route_id,
+    int32_t main_frame_widget_route_id,
     WebContents* opener_web_contents,
     const std::string& frame_name,
     const GURL& target_url,
     const std::string& partition_id,
     content::SessionStorageNamespace* session_storage_namespace) {
   GURL opener_url = opener_web_contents->GetURL();
   ExtensionService* extensions_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
 
   if (!opener_url.is_valid() ||
@@ skipping 42 matching lines @@
   }
 
   // If script access is not allowed, create the the background contents in a
   // new SiteInstance, so that a separate process is used.
   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_instance.get(),
-                                        route_id,
-                                        main_frame_route_id,
-                                        profile_,
-                                        frame_name,
-                                        base::ASCIIToUTF16(extension->id()),
-                                        partition_id,
-                                        session_storage_namespace);
+  BackgroundContents* contents = service->CreateBackgroundContents(
+      site_instance.get(), route_id, main_frame_route_id,
+      main_frame_widget_route_id, profile_, frame_name,
+      base::ASCIIToUTF16(extension->id()), partition_id,
+      session_storage_namespace);
 
   // 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(),
         ui::PAGE_TRANSITION_LINK,
         std::string());  // No extra headers.
   }
 
   return contents != NULL;
 }