Make RenderFrame(Host) own a RenderWidget(Host).

content/browser/frame_host/render_frame_host_manager.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 "content/browser/frame_host/render_frame_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 95 matching lines @@
 
 RenderViewHostImpl* RenderFrameHostManager::pending_render_view_host() const {
   if (!pending_render_frame_host_)
     return NULL;
   return pending_render_frame_host_->render_view_host();
 }
 
 RenderWidgetHostView* RenderFrameHostManager::GetRenderWidgetHostView() const {
   if (interstitial_page_)
     return interstitial_page_->GetView();
-  if (!render_frame_host_)
+  if (!render_frame_host_ ||
+      !render_frame_host_->render_view_host()->GetMainFrame())
     return NULL;
-  return render_frame_host_->render_view_host()->GetView();
+  return static_cast<RenderFrameHostImpl*>(
+             render_frame_host_->render_view_host()->GetMainFrame())->GetView();

[nasko, 2014/12/17 22:51:30]

Why return the view of the main frame? Shouldn't this be the view for the
current RFH, which in turn can return the one it or any of its parents own?

[kenrb, 2015/01/05 21:15:30]

Not sure why I did it that way, but your comment seems right. Fixed.

 }
 
 RenderFrameProxyHost* RenderFrameHostManager::GetProxyToParent() {
   if (frame_tree_node_->IsMainFrame())
     return NULL;
 
   RenderFrameProxyHostMap::iterator iter =
       proxy_hosts_.find(frame_tree_node_->parent()
                             ->render_manager()
                             ->current_frame_host()
@@ skipping 72 matching lines @@
     if (!InitRenderView(dest_render_frame_host->render_view_host(),
                         opener_route_id,
                         MSG_ROUTING_NONE,
                         frame_tree_node_->IsMainFrame()))
       return NULL;
 
     // Now that we've created a new renderer, be sure to hide it if it isn't
     // our primary one.  Otherwise, we might crash if we try to call Show()
     // on it later.
     if (dest_render_frame_host != render_frame_host_ &&
-        dest_render_frame_host->render_view_host()->GetView()) {
-      dest_render_frame_host->render_view_host()->GetView()->Hide();
+        dest_render_frame_host->GetView()) {
+      dest_render_frame_host->GetView()->Hide();
     } else {
       // Notify here as we won't be calling CommitPending (which does the
       // notify).
       delegate_->NotifySwappedFromRenderManager(
           NULL, render_frame_host_.get(), frame_tree_node_->IsMainFrame());
     }
   }
 
   // If entry includes the request ID of a request that is being transferred,
   // the destination render frame will take ownership, so release ownership of
@@ skipping 802 matching lines @@
     SiteInstance* old_instance,
     SiteInstance* new_instance,
     bool is_main_frame) {
   int create_render_frame_flags = 0;
   if (is_main_frame)
     create_render_frame_flags |= CREATE_RF_FOR_MAIN_FRAME_NAVIGATION;
 
   if (delegate_->IsHidden())
     create_render_frame_flags |= CREATE_RF_HIDDEN;
 
-  int opener_route_id =
-      CreateOpenerRenderViewsIfNeeded(old_instance, new_instance);
+  int opener_route_id = CreateOpenerRenderViewsIfNeeded(
+      old_instance, new_instance, create_render_frame_flags);
 
   if (pending_render_frame_host_)
     CancelPending();
 
   // Create a non-swapped-out RFH with the given opener.
   pending_render_frame_host_ =
       CreateRenderFrame(new_instance, pending_web_ui(), opener_route_id,
                         create_render_frame_flags, nullptr);
 }
 
 int RenderFrameHostManager::CreateOpenerRenderViewsIfNeeded(
     SiteInstance* old_instance,
-    SiteInstance* new_instance) {
+    SiteInstance* new_instance,
+    int& create_render_frame_flags) {
   int opener_route_id = MSG_ROUTING_NONE;
   if (new_instance->IsRelatedSiteInstance(old_instance)) {
     opener_route_id =
         delegate_->CreateOpenerRenderViewsForRenderManager(new_instance);
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kSitePerProcess)) {
       // Ensure that the frame tree has RenderFrameProxyHosts for the new
       // SiteInstance in all nodes except the current one.
       frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance(
           frame_tree_node_, new_instance);
+      // RenderFrames in different processes from their parent RenderFrames
+      // in the frame tree require RenderWidgets for rendering and processing
+      // input events.
+      if (frame_tree_node_->parent() &&
+          frame_tree_node_->parent()
+                  ->render_manager()
+                  ->current_frame_host()
+                  ->GetSiteInstance() != new_instance)
+        create_render_frame_flags |= CREATE_RF_NEEDS_RENDER_WIDGET_HOST;
     }
   }
   return opener_route_id;
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrameHost(
     SiteInstance* site_instance,
     int view_routing_id,
     int frame_routing_id,
     int flags) {
   if (frame_routing_id == MSG_ROUTING_NONE)
     frame_routing_id = site_instance->GetProcess()->GetNextRoutingID();
 
-  bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
+  bool swapped_out = flags & CREATE_RF_SWAPPED_OUT;

[nasko, 2014/12/17 22:51:30]

Why remove it on one line and not the other?

[kenrb, 2015/01/05 21:15:30]

Merge issue, it wasn't supposed to be removed. Fixed.

   bool hidden = !!(flags & CREATE_RF_HIDDEN);
 
   // Create a RVH for main frames, or find the existing one for subframes.
   FrameTree* frame_tree = frame_tree_node_->frame_tree();
   RenderViewHostImpl* render_view_host = NULL;
   if (frame_tree_node_->IsMainFrame()) {
     render_view_host = frame_tree->CreateRenderViewHost(
         site_instance, view_routing_id, frame_routing_id, swapped_out, hidden);
   } else {
     render_view_host = frame_tree->GetRenderViewHost(site_instance);
 
     CHECK(render_view_host);
   }
 
   // TODO(creis): Pass hidden to RFH.
-  scoped_ptr<RenderFrameHostImpl> render_frame_host =
-      make_scoped_ptr(RenderFrameHostFactory::Create(
-                          render_view_host, render_frame_delegate_, frame_tree,
-                          frame_tree_node_, frame_routing_id, flags).release());
+  scoped_ptr<RenderFrameHostImpl> render_frame_host = make_scoped_ptr(
+      RenderFrameHostFactory::Create(
+          render_view_host, render_frame_delegate_, render_widget_delegate_,
+          frame_tree, frame_tree_node_, frame_routing_id, flags).release());
   return render_frame_host.Pass();
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrame(
     SiteInstance* instance,
     WebUIImpl* web_ui,
     int opener_route_id,
     int flags,
     int* view_routing_id_ptr) {
   bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
@@ skipping 66 matching lines @@
       if (frame_tree_node_->IsMainFrame())
         proxy->TakeFrameHostOwnership(new_render_frame_host.Pass());
     }
 
     success =
         InitRenderView(render_view_host, opener_route_id, proxy_routing_id,
                        !!(flags & CREATE_RF_FOR_MAIN_FRAME_NAVIGATION));
     if (success) {
       if (frame_tree_node_->IsMainFrame()) {
         // Don't show the main frame's view until we get a DidNavigate from it.
-        render_view_host->GetView()->Hide();
+        // Only top-level RenderViewHosts have RenderWidgetHostViews;
+        // RenderWidgetHosts for out-of-process iframes will be created
+        // later and hidden.
+        if (render_view_host->GetView())
+          render_view_host->GetView()->Hide();
       } else if (!swapped_out) {
         // Init the RFH, so a RenderFrame is created in the renderer.
         DCHECK(new_render_frame_host.get());
         success = InitRenderFrame(new_render_frame_host.get());
       }
       if (success) {
         if (view_routing_id_ptr)
           *view_routing_id_ptr = render_view_host->GetRoutingID();
         // If a brand new RFH was created, announce it to observers.
         if (new_render_frame_host) {
@@ skipping 127 matching lines @@
   // committing above and we're done.
   if (!pending_render_frame_host_) {
     if (will_focus_location_bar)
       delegate_->SetFocusToLocationBar(false);
     return;
   }
 
   // Remember if the page was focused so we can focus the new renderer in
   // that case.
   bool focus_render_view = !will_focus_location_bar &&
-      render_frame_host_->render_view_host()->GetView() &&
-      render_frame_host_->render_view_host()->GetView()->HasFocus();
+                           render_frame_host_->GetView() &&
+                           render_frame_host_->GetView()->HasFocus();
 
   bool is_main_frame = frame_tree_node_->IsMainFrame();
 
   // Swap in the pending frame and make it active. Also ensure the FrameTree
   // stays in sync.
   scoped_ptr<RenderFrameHostImpl> old_render_frame_host =
       SetRenderFrameHost(pending_render_frame_host_.Pass());
   if (is_main_frame)
     render_frame_host_->render_view_host()->AttachToFrameTree();
 
   // The process will no longer try to exit, so we can decrement the count.
   render_frame_host_->GetProcess()->RemovePendingView();
 
   // Show the new view (or a sad tab) if necessary.
-  bool new_rfh_has_view = !!render_frame_host_->render_view_host()->GetView();
+  bool new_rfh_has_view = !!render_frame_host_->GetView();
   if (!delegate_->IsHidden() && new_rfh_has_view) {
     // In most cases, we need to show the new view.
-    render_frame_host_->render_view_host()->GetView()->Show();
+    render_frame_host_->GetView()->Show();
   }
   if (!new_rfh_has_view) {
     // If the view is gone, then this RenderViewHost died while it was hidden.
     // We ignored the RenderProcessGone call at the time, so we should send it
     // now to make sure the sad tab shows up, etc.
     DCHECK(!render_frame_host_->IsRenderFrameLive());
     DCHECK(!render_frame_host_->render_view_host()->IsRenderViewLive());
     delegate_->RenderProcessGoneFromRenderManager(
         render_frame_host_->render_view_host());
   }
 
   // For top-level frames, also hide the old RenderViewHost's view.
   // TODO(creis): As long as show/hide are on RVH, we don't want to hide on
   // subframe navigations or we will interfere with the top-level frame.
   if (is_main_frame && old_render_frame_host->render_view_host()->GetView())
     old_render_frame_host->render_view_host()->GetView()->Hide();
 
   // Make sure the size is up to date.  (Fix for bug 1079768.)
   delegate_->UpdateRenderViewSizeForRenderManager();
 
   if (will_focus_location_bar) {
     delegate_->SetFocusToLocationBar(false);
-  } else if (focus_render_view &&
-             render_frame_host_->render_view_host()->GetView()) {
-    render_frame_host_->render_view_host()->GetView()->Focus();
+  } else if (focus_render_view && render_frame_host_->GetView()) {
+    render_frame_host_->GetView()->Focus();
   }
 
   // Notify that we've swapped RenderFrameHosts. We do this before shutting down
   // the RFH so that we can clean up RendererResources related to the RFH first.
   delegate_->NotifySwappedFromRenderManager(
       old_render_frame_host.get(), render_frame_host_.get(), is_main_frame);
 
   // Swap out the old frame now that the new one is visible.
   // This will swap it out and then put it on the proxy list (if there are other
   // active views in its SiteInstance) or schedule it for deletion when the swap
   // out ack arrives (or immediately if the process isn't live).
   // In the --site-per-process case, old subframe RHFs are not kept alive inside
   // the proxy.
   SwapOutOldFrame(old_render_frame_host.Pass());
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
       !is_main_frame) {
     // If this is a subframe, it should have a CrossProcessFrameConnector
     // created already.  Use it to link the new RFH's view to the proxy that
     // belongs to the parent frame's SiteInstance.
     // Note: We do this after swapping out the old RFH because that may create
     // the proxy we're looking for.
     RenderFrameProxyHost* proxy_to_parent = GetProxyToParent();
     if (proxy_to_parent) {
-      proxy_to_parent->SetChildRWHView(
-          render_frame_host_->render_view_host()->GetView());
+      proxy_to_parent->SetChildRWHView(render_frame_host_->GetView());
     }
 
     // Since the new RenderFrameHost is now committed, there must be no proxies
     // for its SiteInstance. Delete any existing ones.
     RenderFrameProxyHostMap::iterator iter =
         proxy_hosts_.find(render_frame_host_->GetSiteInstance()->GetId());
     if (iter != proxy_hosts_.end()) {
       delete iter->second;
       proxy_hosts_.erase(iter);
     }
@@ skipping 271 matching lines @@
 void RenderFrameHostManager::DeleteRenderFrameProxyHost(
     SiteInstance* instance) {
   RenderFrameProxyHostMap::iterator iter = proxy_hosts_.find(instance->GetId());
   if (iter != proxy_hosts_.end()) {
     delete iter->second;
     proxy_hosts_.erase(iter);
   }
 }
 
 }  // namespace content