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"
 #include "content/common/swapped_out_messages.h"
 #include "content/renderer/child_frame_compositing_helper.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
+#include "ipc/ipc_logging.h"
+#include "ipc/ipc_message_utils.h"
+
 namespace content {
 
 namespace {
 
 typedef std::map<int, RenderFrameProxy*> RoutingIDProxyMap;
 static base::LazyInstance<RoutingIDProxyMap> g_routing_id_proxy_map =
     LAZY_INSTANCE_INITIALIZER;
 
+typedef std::map<blink::WebFrame*, RenderFrameProxy*> FrameMap;
+base::LazyInstance<FrameMap> g_frame_map = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 // static
-RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(int routing_id,
-                                                     int frame_routing_id) {
-  DCHECK_NE(routing_id, MSG_ROUTING_NONE);
+RenderFrameProxy* RenderFrameProxy::CreateProxyForFrame(int routing_id,
+                                                        int frame_routing_id) {
+  CHECK_NE(routing_id, MSG_ROUTING_NONE);
+  CHECK_NE(frame_routing_id, MSG_ROUTING_NONE);
+
+  LOG(ERROR) << "RFP::CreateProxyForFrame: 2 param version: "
+    << " routing_id:" << routing_id << ", frame:" << frame_routing_id;
+
   RenderFrameProxy* proxy = new RenderFrameProxy(routing_id, frame_routing_id);
+
+  RenderFrameImpl* rf = RenderFrameImpl::FromRoutingID(frame_routing_id);
+  CHECK(rf);
+  LOG(ERROR) << "RFP::CreateProxyForFrame: rf: " << rf;
+  proxy->set_render_view(rf->render_view());
+
+  if (rf->GetWebFrame()->parent() &&
+      rf->GetWebFrame()->parent()->isWebRemoteFrame()) {
+    proxy->frame_ =
+        rf->GetWebFrame()->parent()->toWebRemoteFrame()->createRemoteChild(
+            "", NULL);
+  } else {
+    proxy->frame_ = blink::WebRemoteFrame::create(NULL);
+  }
+
+  std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
+      std::make_pair(proxy->frame_, proxy));
+  CHECK(result.second) << "Inserting a duplicate item.";
+
   return proxy;
 }
 
+RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(
+    int routing_id,
+    int parent_routing_id,
+    int render_view_routing_id) {
+  LOG(ERROR) << "RFP::CreateFrameProxy: "
+    << routing_id << ":" << parent_routing_id << ":" << render_view_routing_id;
+
+  RenderViewImpl* rv = NULL;
+  RenderFrameProxy* proxy = new RenderFrameProxy(routing_id, MSG_ROUTING_NONE);
+
+  if (parent_routing_id == MSG_ROUTING_NONE) {
+    rv = RenderViewImpl::FromRoutingID(render_view_routing_id);
+    proxy->frame_ = blink::WebRemoteFrame::create(NULL);
+    LOG(ERROR) << "RFP::CreateFrameProxy: top frame";
+    rv->webview()->setMainFrame(proxy->frame_);
+  } else {
+    RenderFrameProxy* proxy = RenderFrameProxy::FromRoutingID(
+        parent_routing_id);

[ncarter (slow), 2014/06/25 01:07:57]

|proxy| here is shadowing |proxy| up there. Strongly recommend putting down
crack pipe.

+    CHECK(proxy);
+    LOG(ERROR) << "RFP::CreateFrameProxy: RFP: " << proxy;
+    blink::WebRemoteFrame* remote_frame = proxy->GetWebFrame();
+    proxy->frame_ = remote_frame->createRemoteChild("", NULL);
+    rv = proxy->render_view();
+  }
+
+  std::pair<FrameMap::iterator, bool> result = g_frame_map.Get().insert(
+      std::make_pair(proxy->frame_, proxy));
+  CHECK(result.second) << "Inserting a duplicate item.";
+
+  CHECK(rv);
+  proxy->set_render_view(rv);
+
+  return proxy;
+}
+
 // static
 RenderFrameProxy* RenderFrameProxy::FromRoutingID(int32 routing_id) {
   RoutingIDProxyMap* proxies = g_routing_id_proxy_map.Pointer();
   RoutingIDProxyMap::iterator it = proxies->find(routing_id);
   return it == proxies->end() ? NULL : it->second;
 }
 
+// static
+RenderFrameProxy* RenderFrameProxy::FromWebFrame(blink::WebFrame* web_frame) {
+  FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
+  if (iter != g_frame_map.Get().end())
+    return iter->second;
+  return NULL;
+}
+
 RenderFrameProxy::RenderFrameProxy(int routing_id, int frame_routing_id)
     : routing_id_(routing_id),
       frame_routing_id_(frame_routing_id) {
   std::pair<RoutingIDProxyMap::iterator, bool> result =
     g_routing_id_proxy_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
   RenderThread::Get()->AddRoute(routing_id_, this);
 
-  render_frame_ = RenderFrameImpl::FromRoutingID(frame_routing_id);
-  CHECK(render_frame_);
-  render_frame_->render_view()->RegisterRenderFrameProxy(this);
+  LOG(ERROR) << "RFP::RFP[" << this << "]:"
+      << " routing_id:" << routing_id_ << ", for frame:" << frame_routing_id;
+
+  if (frame_routing_id_ != MSG_ROUTING_NONE) {
+    render_frame_ = RenderFrameImpl::FromRoutingID(frame_routing_id);
+    CHECK(render_frame_);
+    render_frame_->render_view()->RegisterRenderFrameProxy(this);
+  }
 }
 
 RenderFrameProxy::~RenderFrameProxy() {
-  render_frame_->render_view()->UnregisterRenderFrameProxy(this);
+  LOG(ERROR) << "RFP::~RFP[" << this << "]:"
+      << " routing_id:" << routing_id_;
+  if (render_frame_)
+    render_frame_->render_view()->UnregisterRenderFrameProxy(this);
+
+  FrameMap::iterator it = g_frame_map.Get().find(frame_);
+  CHECK(it != g_frame_map.Get().end());
+  CHECK_EQ(it->second, this);
+  g_frame_map.Get().erase(it);
+
   RenderThread::Get()->RemoveRoute(routing_id_);
   g_routing_id_proxy_map.Get().erase(routing_id_);
 }
 
-blink::WebFrame* RenderFrameProxy::GetWebFrame() {
-  return render_frame_->GetWebFrame();
-}
-
 void RenderFrameProxy::DidCommitCompositorFrame() {
   if (compositing_helper_)
     compositing_helper_->DidCommitCompositorFrame();
 }
 
 bool RenderFrameProxy::OnMessageReceived(const IPC::Message& msg) {
+  IPC::LogData data;
+  IPC::GenerateLogData("", msg, &data, true);
+
+  LOG(ERROR) << "RFP[" << this << "]::OnMessageReceived:"
+      << " msg:" << data.message_name
+      << " render_frame_:" << render_frame_;
+      //<< " parent:" << frame_->parent();
+
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderFrameProxy, msg)
     IPC_MESSAGE_HANDLER(FrameMsg_DeleteProxy, OnDeleteProxy)
     IPC_MESSAGE_HANDLER(FrameMsg_ChildFrameProcessGone, OnChildFrameProcessGone)
     IPC_MESSAGE_HANDLER(FrameMsg_BuffersSwapped, OnBuffersSwapped)
     IPC_MESSAGE_HANDLER_GENERIC(FrameMsg_CompositorFrameSwapped,
                                 OnCompositorFrameSwapped(msg))
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
-  if (!handled)
+  if (!handled && render_frame_)
     return render_frame_->OnMessageReceived(msg);
 
   return handled;
 }
 
 bool RenderFrameProxy::Send(IPC::Message* message) {
   if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
     delete message;
     return false;
   }
@@ skipping 46 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