Revert of Start using RenderFrameProxyHost objects.

content/renderer/render_frame_proxy.cc

 // Copyright 2014 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_proxy.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "content/common/frame_messages.h"
@@ skipping 20 matching lines @@
 }  // namespace
 
 // static
 RenderFrameProxy* RenderFrameProxy::CreateProxyToReplaceFrame(
     RenderFrameImpl* frame_to_replace,
     int routing_id) {
   CHECK_NE(routing_id, MSG_ROUTING_NONE);
 
   scoped_ptr<RenderFrameProxy> proxy(
       new RenderFrameProxy(routing_id, frame_to_replace->GetRoutingID()));
-
+#if 0
+  // TODO(nick): Enable this code when we're ready to create WebRemoteFrames.
   blink::WebRemoteFrame* web_frame = NULL;
   if (frame_to_replace->GetWebFrame()->parent() &&
       frame_to_replace->GetWebFrame()->parent()->isWebRemoteFrame()) {
     blink::WebRemoteFrame* parent_web_frame =
         frame_to_replace->GetWebFrame()->parent()->toWebRemoteFrame();
     web_frame = parent_web_frame->createRemoteChild("", proxy.get());
   } else {
     web_frame = blink::WebRemoteFrame::create(proxy.get());
   }
-
+#else
+  blink::WebFrame* web_frame = frame_to_replace->GetWebFrame();
+#endif
   proxy->Init(web_frame, frame_to_replace->render_view());
   return proxy.release();
 }
 
 RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(
     int routing_id,
     int parent_routing_id,
     int render_view_routing_id) {
   scoped_ptr<RenderFrameProxy> proxy(
       new RenderFrameProxy(routing_id, MSG_ROUTING_NONE));
   RenderViewImpl* render_view = NULL;
   blink::WebRemoteFrame* web_frame = NULL;
   if (parent_routing_id == MSG_ROUTING_NONE) {
     // Create a top level frame.
     render_view = RenderViewImpl::FromRoutingID(render_view_routing_id);
     web_frame = blink::WebRemoteFrame::create(proxy.get());
     render_view->webview()->setMainFrame(web_frame);
   } else {
-    // Create a frame under an existing parent. The parent is always expected
-    // to be a RenderFrameProxy, because navigations initiated by local frames
+    // Create a frame under an existing parent. The parent is always expected to
+    // be a RenderFrameProxy, because navigations initiated by local frames
     // should not wind up here.
     RenderFrameProxy* parent =
         RenderFrameProxy::FromRoutingID(parent_routing_id);
-    web_frame = parent->web_frame()->createRemoteChild("", proxy.get());
+    CHECK(parent);
+    CHECK(parent->web_frame()->isWebRemoteFrame());
+    web_frame = parent->web_frame()->toWebRemoteFrame()->createRemoteChild(
+        "", proxy.get());
     render_view = parent->render_view();
   }
 
   proxy->Init(web_frame, render_view);
 
   return proxy.release();
 }
 
 // static
 RenderFrameProxy* RenderFrameProxy::FromRoutingID(int32 routing_id) {
@@ skipping 33 matching lines @@
   g_frame_map.Get().erase(it);
 
   RenderThread::Get()->RemoveRoute(routing_id_);
   g_routing_id_proxy_map.Get().erase(routing_id_);
 
   // TODO(nick): Call close unconditionally when web_frame() is always remote.
   if (web_frame()->isWebRemoteFrame())
     web_frame()->close();
 }
 
-void RenderFrameProxy::Init(blink::WebRemoteFrame* web_frame,
+void RenderFrameProxy::Init(blink::WebFrame* web_frame,
                             RenderViewImpl* render_view) {
   CHECK(web_frame);
   CHECK(render_view);
 
   web_frame_ = web_frame;
   render_view_ = render_view;
 
   // TODO(nick): Should all RenderFrameProxies remain observers of their views?
   render_view_->RegisterRenderFrameProxy(this);
 
@@ skipping 80 matching lines @@
     compositing_helper_->EnableCompositing(true);
   }
   compositing_helper_->OnCompositorFrameSwapped(frame.Pass(),
                                                 param.a.producing_route_id,
                                                 param.a.output_surface_id,
                                                 param.a.producing_host_id,
                                                 param.a.shared_memory_handle);
 }
 
 }  // namespace