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

content/browser/frame_host/render_frame_host_impl.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_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 101 matching lines @@
                                                  int routing_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   RoutingIDFrameMap* frames = g_routing_id_frame_map.Pointer();
   RoutingIDFrameMap::iterator it = frames->find(
       RenderFrameHostID(process_id, routing_id));
   return it == frames->end() ? NULL : it->second;
 }
 
 RenderFrameHostImpl::RenderFrameHostImpl(RenderViewHostImpl* render_view_host,
                                          RenderFrameHostDelegate* delegate,
+                                         RenderWidgetHostDelegate* rwh_delegate,
                                          FrameTree* frame_tree,
                                          FrameTreeNode* frame_tree_node,
                                          int routing_id,
                                          int flags)
     : render_view_host_(render_view_host),
       delegate_(delegate),
       cross_process_frame_connector_(NULL),
       render_frame_proxy_host_(NULL),
       frame_tree_(frame_tree),
       frame_tree_node_(frame_tree_node),
       routing_id_(routing_id),
       render_frame_created_(false),
       navigations_suspended_(false),
       is_waiting_for_beforeunload_ack_(false),
       unload_ack_is_for_cross_site_transition_(false),
       accessibility_reset_token_(0),
       accessibility_reset_count_(0),
       no_create_browser_accessibility_manager_for_testing_(false),
       weak_ptr_factory_(this) {
   bool is_swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
+  bool hidden = !!(flags & CREATE_RF_HIDDEN);
   frame_tree_->RegisterRenderFrameHost(this);
   GetProcess()->AddRoute(routing_id_, this);
   g_routing_id_frame_map.Get().insert(std::make_pair(
       RenderFrameHostID(GetProcess()->GetID(), routing_id_),
       this));
 
   if (is_swapped_out) {
     rfh_state_ = STATE_SWAPPED_OUT;
   } else {
     rfh_state_ = STATE_DEFAULT;
     GetSiteInstance()->increment_active_frame_count();
   }
 
   SetUpMojoIfNeeded();
   swapout_event_monitor_timeout_.reset(new TimeoutMonitor(base::Bind(
       &RenderFrameHostImpl::OnSwappedOut, weak_ptr_factory_.GetWeakPtr())));
+
+  if (flags & CREATE_RF_NEEDS_RENDER_WIDGET_HOST) {
+    render_widget_host_.reset(new RenderWidgetHostImpl(
+        rwh_delegate, GetProcess(), MSG_ROUTING_NONE, hidden));
+    render_widget_host_->InitForFrame();

[Charlie Reis, 2015/01/07 23:58:41]

It's not clear to me that this is the right place to call InitForFrame.  If it
is, it might be for very subtle reasons.

In general, the process isn't necessarily created when the RenderFrameHost is
created.  We had to be very careful with
RenderFrameHostImpl::set_render_frame_created in
https://codereview.chromium.org/552683004 to make sure that IsRenderFrameLive
was called at the right times.

Should we be doing this call there (in the case that we have a
render_widget_host_)?  Or are we assuming that the process will exist here
because we know it's a subframe and thus we must have already created the
process for the main frame's RenderFrameProxy?

I suppose the DCHECK will catch it if we're wrong, but we should at least
document the assumption here.

[kenrb, 2015/01/14 18:13:56]

I didn't know that RFHs could be created before the process. I don't think there
would be a problem with deferring its creation, if that makes sense -- is there
a better time to call InitForFrame()?

[Charlie Reis, 2015/01/14 20:56:58]

Hmm, my answer may change now that you've added more code to InitForFrame.

I was going to recommend putting it in RFHI::set_render_frame_created (which
becomes SetRenderFrameCreated since it's no longer trivial), since both were
intended for tracking whether the renderer-side counterpart object exists.

Now InitForFrame also sets owned_by_render_frame_host_, which may be important
even if the process never attaches.

I'll suggest splitting that method in two, so that we can track whether the
corresponding RenderWidget exists separately from whether it's owned by a RFH.

[kenrb, 2015/01/15 22:41:46]

Done.

+  }
 }
 
 RenderFrameHostImpl::~RenderFrameHostImpl() {
   GetProcess()->RemoveRoute(routing_id_);
   g_routing_id_frame_map.Get().erase(
       RenderFrameHostID(GetProcess()->GetID(), routing_id_));
 
   if (delegate_)
     delegate_->RenderFrameDeleted(this);
 
@@ skipping 44 matching lines @@
     return false;
   return GetSiteInstance() !=
       parent_node->current_frame_host()->GetSiteInstance();
 }
 
 GURL RenderFrameHostImpl::GetLastCommittedURL() {
   return frame_tree_node_->current_url();
 }
 
 gfx::NativeView RenderFrameHostImpl::GetNativeView() {
   RenderWidgetHostView* view = render_view_host_->GetView();

[Charlie Reis, 2015/01/07 23:58:41]

There are a bunch of other render_view_host_->GetView() calls in this class.  Do
we need to update them as well, as we're doing in RFHM?

[kenrb, 2015/01/14 18:13:56]

RenderWidgetHostViewChildFrame doesn't have a native view, so that won't work
anyway. All the other ones are related to accessibility and I don't have a clear
picture of how that should work, so I would rather leave them. It might be right
to continue using the RenderViewHost for those.

   if (!view)
     return NULL;
   return view->GetNativeView();
 }
 
 void RenderFrameHostImpl::ExecuteJavaScript(
     const base::string16& javascript) {
   Send(new FrameMsg_JavaScriptExecuteRequest(routing_id_,
                                              javascript,
                                              0, false));
@@ skipping 269 matching lines @@
 
   // The process may (if we're sharing a process with another host that already
   // initialized it) or may not (we have our own process or the old process
   // crashed) have been initialized. Calling Init multiple times will be
   // ignored, so this is safe.
   if (!GetProcess()->Init())
     return false;
 
   DCHECK(GetProcess()->HasConnection());
 
-  Send(new FrameMsg_NewFrame(routing_id_, parent_routing_id, proxy_routing_id));
+  FrameMsg_NewFrame_WidgetParams widget_params;
+  if (render_widget_host_) {
+    widget_params.routing_id = render_widget_host_->GetRoutingID();
+    widget_params.surface_id = render_widget_host_->surface_id();
+    widget_params.hidden = render_widget_host_->is_hidden();
+  } else {
+    // MSG_ROUTING_NONE will prevent a new RenderWidget from being created in
+    // the renderer process.
+    widget_params.routing_id = MSG_ROUTING_NONE;
+    widget_params.surface_id = 0;
+    widget_params.hidden = true;
+  }
+
+  Send(new FrameMsg_NewFrame(routing_id_, parent_routing_id, proxy_routing_id,
+                             widget_params));
+
+  // The RenderWidgetHost takes ownership of its view. It is tied to the
+  // lifetime of the current RenderProcessHost for this RenderFrameHost.
+  if (render_widget_host_) {
+    RenderWidgetHostView* rwhv =
+        new RenderWidgetHostViewChildFrame(render_widget_host_.get());
+    rwhv->Hide();
+  }
 
   // The renderer now has a RenderFrame for this RenderFrameHost.  Note that
   // this path is only used for out-of-process iframes.  Main frame RenderFrames
   // are created with their RenderView, and same-site iframes are created at the
   // time of OnCreateChildFrame.
   set_render_frame_created(true);
 
   return true;
 }
 
@@ skipping 191 matching lines @@
 
 void RenderFrameHostImpl::OnDidDropNavigation() {
   // At the end of Navigate(), the delegate's DidStartLoading is called to force
   // the spinner to start, even if the renderer didn't yet begin the load. If it
   // turns out that the renderer dropped the navigation, we need to turn off the
   // spinner.
   delegate_->DidStopLoading(this);
 }
 
 RenderWidgetHostImpl* RenderFrameHostImpl::GetRenderWidgetHost() {
-  return static_cast<RenderWidgetHostImpl*>(render_view_host_);
+  if (render_widget_host_)
+    return render_widget_host_.get();
+
+  // TODO(kenrb): When RenderViewHost no longer inherits RenderWidgetHost,
+  // we can remove this fallback. Currently it is only used for the main
+  // frame.
+  if (!GetParent())
+    return static_cast<RenderWidgetHostImpl*>(render_view_host_);
+
+  return nullptr;
+}
+
+RenderWidgetHostView* RenderFrameHostImpl::GetView() {
+  RenderFrameHostImpl* frame = this;
+  while (frame) {
+    if (frame->render_widget_host_)
+      return frame->render_widget_host_->GetView();
+    frame = static_cast<RenderFrameHostImpl*>(frame->GetParent());
+  }
+
+  return render_view_host_->GetView();
 }
 
 int RenderFrameHostImpl::GetEnabledBindings() {
   return render_view_host_->GetEnabledBindings();
 }
 
 void RenderFrameHostImpl::OnCrossSiteResponse(
     const GlobalRequestID& global_request_id,
     scoped_ptr<CrossSiteTransferringRequest> cross_site_transferring_request,
     const std::vector<GURL>& transfer_url_chain,
@@ skipping 873 matching lines @@
 void RenderFrameHostImpl::DidUseGeolocationPermission() {
   RenderFrameHost* top_frame = frame_tree_node()->frame_tree()->GetMainFrame();
   GetContentClient()->browser()->RegisterPermissionUsage(
       PERMISSION_GEOLOCATION,
       delegate_->GetAsWebContents(),
       GetLastCommittedURL().GetOrigin(),
       top_frame->GetLastCommittedURL().GetOrigin());
 }
 
 }  // namespace content