Create RenderFrameProxyHost at time of swap-out instead of commit.

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/render_frame_impl.h"
+#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/render_view_impl.h"
+
+namespace content {
+
+namespace {
+
+typedef std::map<int, RenderFrameProxy*> RoutingIDProxyMap;
+static base::LazyInstance<RoutingIDProxyMap> g_routing_id_proxy_map =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+// static
+RenderFrameProxy* RenderFrameProxy::CreateFrameProxy(int routing_id,
+                                                     int frame_routing_id) {
+  RenderFrameImpl* rf = RenderFrameImpl::FromRoutingID(frame_routing_id);
+  RenderFrameProxy* proxy = new RenderFrameProxy(routing_id, frame_routing_id);
+
+  CHECK(rf);

[Charlie Reis, 2014/05/15 00:32:50]

Not sure I understand why we need this function.  The RenderFrameProxy
constructor already does most of this, including looking up the RenderFrameImpl
and CHECKing that it exists.  Are there cases that we need to avoid the
set_render_frame call by calling the RenderFrameProxy constructor directly?

[nasko, 2014/05/15 18:47:13]

The code when through a bunch of iterations, so I didn't realize they do mostly
the same work :).

Overall, I think we need this method, as it will handle creating WebRemoteFrame,
connecting it to the RenderFrameProxy and inserting into the frame tree. It
isn't in this CL, since we can't do it all yet.

+  proxy->set_render_frame(rf);
+  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;
+}
+
+RenderFrameProxy::RenderFrameProxy(int routing_id, int frame_routing_id)

[Charlie Reis, 2014/05/15 00:32:50]

Maybe we should check that routing_id is valid?

[nasko, 2014/05/15 18:47:13]

If it is invalid, what do we do? We can't fail construction or throw an
exception? Another justification for having CreateFrameProxy, but see my comment
in render_view_browsertest.

[Charlie Reis, 2014/05/15 22:55:00]

A DCHECK would work fine, right?  It just seems like we shouldn't be creating
these (and calling AddRoute) with MSG_ROUTING_NONE, and now the test doesn't
attempt to.

[nasko, 2014/05/15 23:36:49]

Done.

+    : 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_);
+}
+
+RenderFrameProxy::~RenderFrameProxy() {
+  RenderThread::Get()->RemoveRoute(routing_id_);
+  g_routing_id_proxy_map.Get().erase(routing_id_);
+}
+
+bool RenderFrameProxy::OnMessageReceived(const IPC::Message& msg) {
+  bool handled = true;
+  bool msg_is_ok = true;
+  IPC_BEGIN_MESSAGE_MAP_EX(RenderFrameProxy, msg, msg_is_ok)
+    IPC_MESSAGE_HANDLER(FrameMsg_DeleteProxy, OnDeleteProxy)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+
+  if (!handled)
+    return render_frame_->OnMessageReceived(msg);
+
+  if (!msg_is_ok) {
+    // The message had a handler, but its deserialization failed.
+    // Kill the renderer to avoid potential spoofing attacks.
+    int id = msg.type();
+    CHECK(false) << "Unable to deserialize " << id << " in RenderFrameProxy.";
+  }
+
+  return handled;
+}
+
+bool RenderFrameProxy::Send(IPC::Message* message) {
+  if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
+    delete message;
+    return false;
+  }
+  message->set_routing_id(routing_id_);
+  return RenderThread::Get()->Send(message);
+}
+
+void RenderFrameProxy::OnDeleteProxy() {
+  RenderFrameImpl* render_frame =
+      RenderFrameImpl::FromRoutingID(frame_routing_id_);
+  CHECK(render_frame);
+  render_frame->set_render_frame_proxy(NULL);
+
+  delete this;
+}
+
+}  // namespace