Create a new RenderFrameHost per child frame when --site-per-process is enabled.

content/browser/renderer_host/frame_tree.cc

Index: content/browser/renderer_host/frame_tree.cc
diff --git a/content/browser/renderer_host/frame_tree.cc b/content/browser/renderer_host/frame_tree.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ebf857e3d6efcd234724d110667e1ffbc5278467
--- /dev/null
+++ b/content/browser/renderer_host/frame_tree.cc
@@ -0,0 +1,128 @@
+// 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/renderer_host/frame_tree.h"
+
+#include <queue>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "content/browser/renderer_host/frame_tree_node.h"
+#include "content/browser/renderer_host/render_frame_host_impl.h"
+
+namespace content {
+
+namespace {
+// Used with FrameTree::ForEach() to search for the FrameTreeNode
+// corresponding to |frame_id|.
+bool FrameTreeNodeForId(int64 frame_id, FrameTreeNode** out_node,
+                        FrameTreeNode* node) {
+  if (node->frame_id() == frame_id) {
+    *out_node = node;
+    // Terminate iteration once the node has been found.
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+FrameTree::FrameTree()
+    : root_(new FrameTreeNode(FrameTreeNode::kInvalidFrameId, std::string(),
+                              scoped_ptr<RenderFrameHostImpl>())) {
+}
+
+FrameTree::~FrameTree() {
+}
+
+FrameTreeNode* FrameTree::FindByID(int64 frame_id) {
+  FrameTreeNode* node = NULL;
+  ForEach(base::Bind(&FrameTreeNodeForId, frame_id, &node));
+  return node;
+}
+
+void FrameTree::ForEach(
+    const base::Callback<bool(FrameTreeNode*)>& on_node) const {
+  std::queue<FrameTreeNode*> queue;
+  queue.push(root_.get());
+
+  while (!queue.empty()) {
+    FrameTreeNode* node = queue.front();
+    queue.pop();
+    if (!on_node.Run(node))
+      break;
+
+    for (size_t i = 0; i < node->child_count(); ++i)
+      queue.push(node->child_at(i));
+  }
+}
+
+bool FrameTree::IsFirstNavigationAfterSwap() const {
+  return root_->frame_id() == FrameTreeNode::kInvalidFrameId;
+}
+
+void FrameTree::OnFirstNavigationAfterSwap(int main_frame_id) {
+  root_->set_frame_id(main_frame_id);
+}
+
+void FrameTree::AddFrame(int render_frame_host_id, int64 parent_frame_id,
+                         int64 frame_id, const std::string& frame_name) {
+  FrameTreeNode* parent = FindByID(parent_frame_id);
+  // TODO(ajwong): Should the renderer be killed here? Would there be a race on
+  // shutdown that might make this case possible?

[Charlie Reis, 2013/09/27 19:19:21]

I'm inclined to think we should kill the renderer, but it's ok to do that in a
followup CL.

(We're getting to where we depend on having correct frame tree information in
the browser process, so letting them get out of sync is a problem.  Killing it
will mean we're able to hear about cases where this isn't true.)

[awong, 2013/09/27 20:50:09]

Let's do it in a followup CL. I'd rather not risk a need to revert due to an
extra check when there's already a large refactor + object lifetime change in
this one.

+  if (!parent)
+    return;
+
+  parent->AddChild(CreateNode(frame_id, frame_name, render_frame_host_id,
+                              parent->render_frame_host()->GetProcess()));
+}
+
+void FrameTree::RemoveFrame(int64 parent_frame_id, int64 frame_id) {
+  FrameTreeNode* parent = FindByID(parent_frame_id);
+  // TODO(ajwong): Should the renderer be killed here? Would there be a race on
+  // shutdown that might make this case possible?
+  if (!parent)
+    return;
+
+  parent->RemoveChild(frame_id);
+  if (!on_frame_removed_.is_null())
+    on_frame_removed_.Run(frame_id);
+}
+
+void FrameTree::SetFrameUrl(int64 frame_id, const GURL& url) {
+  FrameTreeNode* node = FindByID(frame_id);
+  // TODO(ajwong): Should the renderer be killed here? Would there be a race on
+  // shutdown that might make this case possible?
+  if (!node)
+    return;
+
+  if (node)
+    node->set_current_url(url);
+}
+
+void FrameTree::SwapMainFrame(RenderFrameHostImpl* render_frame_host) {
+  return root_->ResetForMainFrame(render_frame_host);
+}
+
+RenderFrameHostImpl* FrameTree::GetMainFrame() const {
+  return root_->render_frame_host();
+}
+
+void FrameTree::SetFrameRemoveListener(
+    const base::Callback<void(int64)>& on_frame_removed) {
+  on_frame_removed_ = on_frame_removed;
+}
+
+scoped_ptr<FrameTreeNode> FrameTree::CreateNode(
+    int64 frame_id, const std::string& frame_name, int render_frame_host_id,
+    RenderProcessHost* render_process_host) {
+  scoped_ptr<RenderFrameHostImpl> render_frame_host(
+      new RenderFrameHostImpl(render_process_host, this, render_frame_host_id,
+                              false));
+
+  return make_scoped_ptr(new FrameTreeNode(frame_id, frame_name,
+                                           render_frame_host.Pass()));
+}
+
+}  // namespace content