Give the main frame a RenderWidget.

content/renderer/render_frame_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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 549 matching lines @@
 // static
 RenderFrameImpl* RenderFrameImpl::FromRoutingID(int routing_id) {
   RoutingIDFrameMap::iterator iter =
       g_routing_id_frame_map.Get().find(routing_id);
   if (iter != g_routing_id_frame_map.Get().end())
     return iter->second;
   return NULL;
 }
 
 // static
-RenderFrameImpl* RenderFrameImpl::CreateMainFrame(RenderViewImpl* render_view,
-                                                  int32 routing_id) {
+RenderFrameImpl* RenderFrameImpl::CreateMainFrame(
+    RenderViewImpl* render_view,
+    int32 routing_id,
+    int32 widget_routing_id,
+    bool hidden,
+    const blink::WebScreenInfo& screen_info,
+    CompositorDependencies* compositor_deps) {
+  // A main frame RenderFrame must have a RenderWidget.
+  DCHECK_NE(MSG_ROUTING_NONE, widget_routing_id);
+
   RenderFrameImpl* render_frame =
       RenderFrameImpl::Create(render_view, routing_id);
   WebLocalFrame* web_frame =
       WebLocalFrame::create(blink::WebTreeScopeType::Document, render_frame);
   render_frame->SetWebFrame(web_frame);
   render_view->webview()->setMainFrame(web_frame);
+  render_frame->render_widget_ = RenderWidget::CreateForFrame(
+      widget_routing_id, hidden, screen_info, compositor_deps, web_frame);
+  // TODO(kenrb): Observing shouldn't be necessary when we sort out
+  // WasShown and WasHidden, separating page-level visibility from
+  // frame-level visibility.
+  // TODO(avi): This DCHECK is to track cleanup for https://crbug.com/545684
+  DCHECK_EQ(render_view, render_frame->render_widget_)
+      << "Main frame is no longer reusing the RenderView as its widget! "
+      << "Does the RenderFrame need to register itself with the RenderWidget?";
   return render_frame;
 }
 
 // static
 void RenderFrameImpl::CreateFrame(
     int routing_id,
     int proxy_routing_id,
     int opener_routing_id,
     int parent_routing_id,
     int previous_sibling_routing_id,
@@ skipping 35 matching lines @@
         proxy->web_frame(), WebString::fromUTF8(replicated_state.name),
         replicated_state.sandbox_flags);
   }
   render_frame->SetWebFrame(web_frame);
   CHECK_IMPLIES(parent_routing_id == MSG_ROUTING_NONE, !web_frame->parent());
 
   WebFrame* opener = ResolveOpener(opener_routing_id, nullptr);
   web_frame->setOpener(opener);
 
   if (widget_params.routing_id != MSG_ROUTING_NONE) {
-    CHECK(SiteIsolationPolicy::AreCrossProcessFramesPossible());
+    CHECK_IMPLIES(web_frame->parent(),
+                  SiteIsolationPolicy::AreCrossProcessFramesPossible());
     render_frame->render_widget_ = RenderWidget::CreateForFrame(
         widget_params.routing_id, widget_params.hidden,
         render_frame->render_view_->screen_info(), compositor_deps, web_frame);
     // TODO(kenrb): Observing shouldn't be necessary when we sort out
     // WasShown and WasHidden, separating page-level visibility from
     // frame-level visibility.
     render_frame->render_widget_->RegisterRenderFrame(render_frame);

[ncarter (slow), 2015/10/21 22:15:48]

The error message in the DCHECK on line 592 suggests that extra code will be
needed for the main frame to register itself with the RenderWidget. But it looks
like that's happening here, and the CHECK_IMPLIES on line 650 that we can reach
this for non-oopif main frames.

That looks inconsistent to me. What am I missing?

[dcheng, 2015/10/21 23:46:51]

The CHECK_IMPLIES is one of the bits of plumbing left over from the days when
the main frame had a distinct RenderWidget (similar to how we still plumb widget
IDs through even though widget ID always == view ID). I opted to leave most of
that plumbing is in place, to make it easier for the eventual switch over. I'd
be OK removing it though.

   }
 
   render_frame->Initialize();
 }
 
 // static
 RenderFrame* RenderFrame::FromWebFrame(blink::WebFrame* web_frame) {
   return RenderFrameImpl::FromWebFrame(web_frame);
 }
 
@@ skipping 3276 matching lines @@
 }
 
 void RenderFrameImpl::WasHidden() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WasHidden());
 }
 
 void RenderFrameImpl::WasShown() {
   // TODO(kenrb): Need to figure out how to do this better. Should
   // VisibilityState remain a page-level concept or move to frames?
   // The semantics of 'Show' might have to change here.
-  if (render_widget_) {
+  // TODO(avi): This DCHECK is to track cleanup for https://crbug.com/545684
+  DCHECK_IMPLIES(IsMainFrame(), render_widget_.get() == render_view_.get())
+      << "The main render frame is no longer reusing the RenderView as its "
+      << "RenderWidget!";
+  if (render_widget_ && render_view_.get() != render_widget_.get()) {
     static_cast<blink::WebFrameWidget*>(render_widget_->webwidget())->
         setVisibilityState(blink::WebPageVisibilityStateVisible, false);
   }
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WasShown());
 }
 
 void RenderFrameImpl::WidgetWillClose() {
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_, WidgetWillClose());
 }
 
@@ skipping 1260 matching lines @@
   mojo::ServiceProviderPtr service_provider;
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   mojo_shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
                                     nullptr, nullptr,
                                     base::Bind(&OnGotContentHandlerID));
   return service_provider.Pass();
 }
 
 }  // namespace content