Create RenderFrame/RenderFrameHost for the main frame of a page.

content/browser/renderer_host/render_view_host_impl.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 "content/browser/renderer_host/render_view_host_impl.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 141 matching lines @@
                                                int render_view_id) {
   return static_cast<RenderViewHostImpl*>(
       RenderViewHost::FromID(render_process_id, render_view_id));
 }
 
 RenderViewHostImpl::RenderViewHostImpl(
     SiteInstance* instance,
     RenderViewHostDelegate* delegate,
     RenderWidgetHostDelegate* widget_delegate,
     int routing_id,
+    int main_frame_routing_id,
     bool swapped_out,
     SessionStorageNamespace* session_storage)
     : RenderWidgetHostImpl(widget_delegate, instance->GetProcess(), routing_id),
       delegate_(delegate),
       instance_(static_cast<SiteInstanceImpl*>(instance)),
       waiting_for_drag_context_response_(false),
       enabled_bindings_(0),
       pending_request_id_(-1),
       navigations_suspended_(false),
       suspended_nav_params_(NULL),
@@ skipping 12 matching lines @@
       accessibility_other_callback_(base::Bind(&base::DoNothing)),
       sudden_termination_allowed_(false),
       session_storage_namespace_(
           static_cast<SessionStorageNamespaceImpl*>(session_storage)),
       save_accessibility_tree_for_testing_(false),
       render_view_termination_status_(base::TERMINATION_STATUS_STILL_RUNNING) {
   DCHECK(session_storage_namespace_);
   DCHECK(instance_);
   CHECK(delegate_);  // http://crbug.com/82827
 
+  if (main_frame_routing_id == MSG_ROUTING_NONE) {

[Charlie Reis, 2013/05/30 18:26:59]

nit: No braces needed.

[nasko, 2013/05/30 19:03:48]

Done.

+    main_frame_routing_id = GetProcess()->GetNextRoutingID();
+  }
+  main_render_frame_host_.reset(
+      new RenderFrameHostImpl(this, main_frame_routing_id, is_swapped_out_));
+
   GetProcess()->EnableSendQueue();
 
   for (size_t i = 0; i < g_created_callbacks.Get().size(); i++)
     g_created_callbacks.Get().at(i).Run(this);
 
 #if defined(OS_ANDROID)
   media_player_manager_ = media::MediaPlayerManager::Create(this);
 #endif
 }
 
@@ skipping 42 matching lines @@
   // page ID it might be asked to render.
   int32 next_page_id = 1;
   if (max_page_id > -1)
     next_page_id = max_page_id + 1;
 
   ViewMsg_New_Params params;
   params.renderer_preferences =
       delegate_->GetRendererPrefs(GetProcess()->GetBrowserContext());
   params.web_preferences = delegate_->GetWebkitPrefs();
   params.view_id = GetRoutingID();
+  params.main_frame_routing_id = main_render_frame_host_->routing_id();
   params.surface_id = surface_id();
   params.session_storage_namespace_id = session_storage_namespace_->id();
   params.frame_name = frame_name;
   // Ensure the RenderView sets its opener correctly.
   params.opener_route_id = opener_route_id;
   params.swapped_out = is_swapped_out_;
   params.next_page_id = next_page_id;
   GetWebScreenInfo(&params.screen_info);
   params.accessibility_mode = accessibility_mode();
   params.allow_partial_swap = !GetProcess()->IsGuest();
@@ skipping 762 matching lines @@
 
   RenderWidgetHostImpl::Shutdown();
 }
 
 bool RenderViewHostImpl::IsRenderView() const {
   return true;
 }
 
 void RenderViewHostImpl::CreateNewWindow(
     int route_id,
+    int main_frame_route_id,
     const ViewHostMsg_CreateWindow_Params& params,
     SessionStorageNamespace* session_storage_namespace) {
   ViewHostMsg_CreateWindow_Params validated_params(params);
   ChildProcessSecurityPolicyImpl* policy =
       ChildProcessSecurityPolicyImpl::GetInstance();
   FilterURL(policy, GetProcess(), false, &validated_params.target_url);
   FilterURL(policy, GetProcess(), false, &validated_params.opener_url);
   FilterURL(policy, GetProcess(), true,
             &validated_params.opener_security_origin);
 
-  delegate_->CreateNewWindow(route_id, validated_params,
-                             session_storage_namespace);
+  delegate_->CreateNewWindow(route_id, main_frame_route_id,
+                             validated_params, session_storage_namespace);
 }
 
 void RenderViewHostImpl::CreateNewWidget(int route_id,
                                      WebKit::WebPopupType popup_type) {
   delegate_->CreateNewWidget(route_id, popup_type);
 }
 
 void RenderViewHostImpl::CreateNewFullscreenWidget(int route_id) {
   delegate_->CreateNewFullscreenWidget(route_id);
 }
@@ skipping 1020 matching lines @@
   const std::vector<base::FilePath>& file_paths = state.GetReferencedFiles();
   for (std::vector<base::FilePath>::const_iterator file = file_paths.begin();
        file != file_paths.end(); ++file) {
     if (!policy->CanReadFile(GetProcess()->GetID(), *file))
       return false;
   }
   return true;
 }
 
 }  // namespace content