Revert 241151 "Make RenderFrameHostManager swap RenderFrameHosts..."

r241151 seems to break content_unittests and browser_tests on Chrome OS ASAN bot:
http://build.chromium.org/p/chromium.memory/builders/Linux%20Chromium%20OS%20ASAN%20Tests%20%283%29/builds/12154

> Make RenderFrameHostManager swap RenderFrameHosts, not RenderViewHosts.
> 
> We still only have a RFHM for the main frame and not subframes, unless
> the --site-per-process flag is passed.  To external callers, RFHM is
> still effectively swapping RenderViewHosts.
> 
> RenderFrameHosts now indirectly keep their RenderViewHosts alive.
> 
> BUG=314791
> TEST=No visible behavior change.
> 
> Review URL: https://codereview.chromium.org/106963004

TBR=creis@chromium.org

Review URL: https://codereview.chromium.org/105523006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@241159 0039d316-1c4b-4281-b951-d872f2087c98

33 files changed, 689 insertions, 950 deletions

diff --git a/chrome/renderer/safe_browsing/phishing_classifier_browsertest.cc b/chrome/renderer/safe_browsing/phishing_classifier_browsertest.cc
index 3a1779a..4acb129 100644
--- a/chrome/renderer/safe_browsing/phishing_classifier_browsertest.cc
+++ b/chrome/renderer/safe_browsing/phishing_classifier_browsertest.cc
@@ -33,13 +33,6 @@ using ::testing::Contains;
 using ::testing::Not;
 using ::testing::Pair;
 
-namespace {
-
-// The first RenderFrame is routing ID 1, and the first RenderView is 2.
-const int kRenderViewRoutingId = 2;
-
-}
-
 namespace safe_browsing {
 
 class PhishingClassifierTest : public InProcessBrowserTest {
@@ -99,7 +92,7 @@ class PhishingClassifierTest : public InProcessBrowserTest {
     ASSERT_TRUE(scorer_.get());
 
     classifier_.reset(new PhishingClassifier(
-        content::RenderView::FromRoutingID(kRenderViewRoutingId),
+        content::RenderView::FromRoutingID(1),
         clock_));
   }
 
diff --git a/chrome/renderer/safe_browsing/phishing_classifier_delegate_browsertest.cc b/chrome/renderer/safe_browsing/phishing_classifier_delegate_browsertest.cc
index 9ccb8da..51a2390 100644
--- a/chrome/renderer/safe_browsing/phishing_classifier_delegate_browsertest.cc
+++ b/chrome/renderer/safe_browsing/phishing_classifier_delegate_browsertest.cc
@@ -48,10 +48,6 @@ using ::testing::StrictMock;
 namespace safe_browsing {
 
 namespace {
-
-// The RenderFrame is routing ID 1, and the RenderView is 2.
-const int kRenderViewRoutingId = 2;
-
 class MockPhishingClassifier : public PhishingClassifier {
  public:
   explicit MockPhishingClassifier(content::RenderView* render_view)
@@ -150,8 +146,7 @@ class PhishingClassifierDelegateTest : public InProcessBrowserTest {
 
   virtual void SetUpOnMainThread() OVERRIDE {
     intercepting_filter_ = new InterceptingMessageFilter();
-    content::RenderView* render_view =
-        content::RenderView::FromRoutingID(kRenderViewRoutingId);
+    content::RenderView* render_view = content::RenderView::FromRoutingID(1);
 
     GetWebContents()->GetRenderProcessHost()->AddFilter(
         intercepting_filter_.get());
@@ -238,8 +233,7 @@ class PhishingClassifierDelegateTest : public InProcessBrowserTest {
   }
 
   void NavigateMainFrameInternal(const GURL& url) {
-    content::RenderView* render_view =
-        content::RenderView::FromRoutingID(kRenderViewRoutingId);
+    content::RenderView* render_view = content::RenderView::FromRoutingID(1);
     render_view->GetWebView()->mainFrame()->firstChild()->loadRequest(
         blink::WebURLRequest(url));
   }
diff --git a/chrome/renderer/safe_browsing/phishing_dom_feature_extractor_browsertest.cc b/chrome/renderer/safe_browsing/phishing_dom_feature_extractor_browsertest.cc
index 6897972..91ec556 100644
--- a/chrome/renderer/safe_browsing/phishing_dom_feature_extractor_browsertest.cc
+++ b/chrome/renderer/safe_browsing/phishing_dom_feature_extractor_browsertest.cc
@@ -44,13 +44,6 @@ using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Return;
 
-namespace {
-
-// The first RenderFrame is routing ID 1, and the first RenderView is 2.
-const int kRenderViewRoutingId = 2;
-
-}
-
 namespace safe_browsing {
 
 class PhishingDOMFeatureExtractorTest : public InProcessBrowserTest {
@@ -83,7 +76,7 @@ class PhishingDOMFeatureExtractorTest : public InProcessBrowserTest {
 
   virtual void SetUpOnMainThread() OVERRIDE {
     extractor_.reset(new PhishingDOMFeatureExtractor(
-        content::RenderView::FromRoutingID(kRenderViewRoutingId), &clock_));
+        content::RenderView::FromRoutingID(1), &clock_));
 
     ASSERT_TRUE(StartTestServer());
     host_resolver()->AddRule("*", "127.0.0.1");
@@ -120,9 +113,8 @@ class PhishingDOMFeatureExtractorTest : public InProcessBrowserTest {
 
   // Does the actual work of removing the iframe "frame1" from the document.
   void RemoveIframe() {
-    content::RenderView* render_view =
-        content::RenderView::FromRoutingID(kRenderViewRoutingId);
-    blink::WebFrame* main_frame = render_view->GetWebView()->mainFrame();
+    blink::WebFrame* main_frame =
+        content::RenderView::FromRoutingID(1)->GetWebView()->mainFrame();
     ASSERT_TRUE(main_frame);
     main_frame->executeScript(
         blink::WebString(
diff --git a/content/browser/frame_host/frame_tree.cc b/content/browser/frame_host/frame_tree.cc
index 0dff87b..fef82ee 100644
--- a/content/browser/frame_host/frame_tree.cc
+++ b/content/browser/frame_host/frame_tree.cc
@@ -12,8 +12,6 @@
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/frame_host/render_frame_host_factory.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
-#include "content/browser/renderer_host/render_view_host_factory.h"
-#include "content/browser/renderer_host/render_view_host_impl.h"
 
 namespace content {
 
@@ -54,8 +52,7 @@ FrameTree::FrameTree(Navigator* navigator,
       render_view_delegate_(render_view_delegate),
       render_widget_delegate_(render_widget_delegate),
       manager_delegate_(manager_delegate),
-      root_(new FrameTreeNode(this,
-                              navigator,
+      root_(new FrameTreeNode(navigator,
                               render_frame_delegate,
                               render_view_delegate,
                               render_widget_delegate,
@@ -97,7 +94,7 @@ void FrameTree::OnFirstNavigationAfterSwap(int main_frame_id) {
   root_->set_frame_id(main_frame_id);
 }
 
-RenderFrameHostImpl* FrameTree::AddFrame(int frame_routing_id,
+RenderFrameHostImpl* FrameTree::AddFrame(int render_frame_host_id,
                                          int64 parent_frame_id,
                                          int64 frame_id,
                                          const std::string& frame_name) {
@@ -107,11 +104,10 @@ RenderFrameHostImpl* FrameTree::AddFrame(int frame_routing_id,
   if (!parent)
     return NULL;
 
-  scoped_ptr<FrameTreeNode> node(new FrameTreeNode(
-      this, parent->navigator(), render_frame_delegate_, render_view_delegate_,
-      render_widget_delegate_, manager_delegate_, frame_id, frame_name));
-  RenderFrameHostImpl* render_frame = node->current_frame_host();
-  parent->AddChild(node.Pass(), frame_routing_id);
+  scoped_ptr<FrameTreeNode> node(CreateNode(
+      frame_id, frame_name, render_frame_host_id, parent));
+  RenderFrameHostImpl* render_frame = node->render_frame_host();
+  parent->AddChild(node.Pass());
   return render_frame;
 }
 
@@ -151,12 +147,12 @@ void FrameTree::SetFrameUrl(int64 frame_id, const GURL& url) {
     node->set_current_url(url);
 }
 
-void FrameTree::ResetForMainFrameSwap() {
-  return root_->ResetForMainFrameSwap();
+void FrameTree::SwapMainFrame(RenderFrameHostImpl* render_frame_host) {
+  return root_->ResetForMainFrame(render_frame_host);
 }
 
 RenderFrameHostImpl* FrameTree::GetMainFrame() const {
-  return root_->current_frame_host();
+  return root_->render_frame_host();
 }
 
 void FrameTree::SetFrameRemoveListener(
@@ -164,78 +160,32 @@ void FrameTree::SetFrameRemoveListener(
   on_frame_removed_ = on_frame_removed;
 }
 
-void FrameTree::ClearFrameRemoveListenerForTesting() {
-  on_frame_removed_.Reset();
-}
-
-RenderViewHostImpl* FrameTree::CreateRenderViewHostForMainFrame(
-    SiteInstance* site_instance,
-    int routing_id,
-    int main_frame_routing_id,
-    bool swapped_out,
-    bool hidden) {
-  DCHECK(main_frame_routing_id != MSG_ROUTING_NONE);
-  RenderViewHostMap::iterator iter =
-      render_view_host_map_.find(site_instance->GetId());
-  CHECK(iter == render_view_host_map_.end());
-  RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
-      RenderViewHostFactory::Create(site_instance,
-                                    render_view_delegate_,
-                                    render_widget_delegate_,
-                                    routing_id,
-                                    main_frame_routing_id,
-                                    swapped_out,
-                                    hidden));
-
-  render_view_host_map_[site_instance->GetId()] =
-      RenderViewHostRefCount(rvh, 0);
-  return rvh;
-}
-
-RenderViewHostImpl* FrameTree::GetRenderViewHostForSubFrame(
-    SiteInstance* site_instance) {
-  RenderViewHostMap::iterator iter =
-      render_view_host_map_.find(site_instance->GetId());
-  CHECK(iter != render_view_host_map_.end());
-  RenderViewHostRefCount rvh_refcount = iter->second;
-  return rvh_refcount.first;
-}
-
-void FrameTree::RegisterRenderFrameHost(
-    RenderFrameHostImpl* render_frame_host) {
-  SiteInstance* site_instance =
-      render_frame_host->render_view_host()->GetSiteInstance();
-  RenderViewHostMap::iterator iter =
-      render_view_host_map_.find(site_instance->GetId());
-  CHECK(iter != render_view_host_map_.end());
-
-  // Increment the refcount.
-  CHECK_GE(iter->second.second, 0);
-  iter->second.second++;
-}
-
-void FrameTree::UnregisterRenderFrameHost(
-    RenderFrameHostImpl* render_frame_host) {
-  SiteInstance* site_instance =
-      render_frame_host->render_view_host()->GetSiteInstance();
-  RenderViewHostMap::iterator iter =
-      render_view_host_map_.find(site_instance->GetId());
-  CHECK(iter != render_view_host_map_.end());
-
-  // Decrement the refcount and shutdown the RenderViewHost if no one else is
-  // using it.
-  CHECK_GT(iter->second.second, 0);
-  iter->second.second--;
-  if (iter->second.second == 0) {
-    iter->second.first->Shutdown();
-    render_view_host_map_.erase(iter);
-  }
-}
-
 FrameTreeNode* FrameTree::FindByFrameID(int64 frame_id) {
   FrameTreeNode* node = NULL;
   ForEach(base::Bind(&FrameTreeNodeForFrameId, frame_id, &node));
   return node;
 }
 
+scoped_ptr<FrameTreeNode> FrameTree::CreateNode(
+    int64 frame_id,
+    const std::string& frame_name,
+    int render_frame_host_id,
+    FrameTreeNode* parent_node) {
+  scoped_ptr<FrameTreeNode> frame_tree_node(new FrameTreeNode(
+      parent_node->navigator(), render_frame_delegate_, render_view_delegate_,
+      render_widget_delegate_, manager_delegate_, frame_id, frame_name));
+
+  scoped_ptr<RenderFrameHostImpl> render_frame_host(
+      RenderFrameHostFactory::Create(
+          parent_node->render_frame_host()->render_view_host(),
+          parent_node->render_frame_host()->delegate(),
+          this,
+          frame_tree_node.get(),
+          render_frame_host_id,
+          false));
+
+  frame_tree_node->set_render_frame_host(render_frame_host.release(), true);
+  return frame_tree_node.Pass();
+}
+
 }  // namespace content
diff --git a/content/browser/frame_host/frame_tree.h b/content/browser/frame_host/frame_tree.h
index 2ee1cdd..3ef2d4c 100644
--- a/content/browser/frame_host/frame_tree.h
+++ b/content/browser/frame_host/frame_tree.h
@@ -53,8 +53,6 @@ class CONTENT_EXPORT FrameTree {
             RenderFrameHostManager::Delegate* manager_delegate);
   ~FrameTree();
 
-  FrameTreeNode* root() const { return root_.get(); }
-
   // Returns the FrameTreeNode with the given |frame_tree_node_id|.
   FrameTreeNode* FindByID(int64 frame_tree_node_id);
 
@@ -76,7 +74,7 @@ class CONTENT_EXPORT FrameTree {
 
   // Frame tree manipulation routines.
   // TODO(creis): These should take in RenderFrameHost routing IDs.
-  RenderFrameHostImpl* AddFrame(int frame_routing_id,
+  RenderFrameHostImpl* AddFrame(int render_frame_host_id,
                                 int64 parent_frame_tree_node_id,
                                 int64 frame_id,
                                 const std::string& frame_name);
@@ -85,12 +83,18 @@ class CONTENT_EXPORT FrameTree {
                    int64 frame_id);
   void SetFrameUrl(int64 frame_id, const GURL& url);
 
-  // Clears process specific-state after a main frame process swap.
+  // Resets the FrameTree and changes RenderFrameHost for the main frame.
   // This destroys most of the frame tree but retains the root node so that
   // navigation state may be kept on it between process swaps. Used to
   // support bookkeeping for top-level navigations.
-  // TODO(creis): Look into how we can remove the need for this method.
-  void ResetForMainFrameSwap();
+  //
+  // If |main_frame| is NULL, reset tree to initially constructed state.
+  //
+  // TODO(ajwong): This function should not be given a |main_frame|. This is
+  // required currently because the RenderViewHost owns its main frame. When
+  // that relation is fixed, the FrameTree should be responsible for
+  // created/destroying the main frame on the swap.
+  void SwapMainFrame(RenderFrameHostImpl* main_frame);
 
   // Convenience accessor for the main frame's RenderFrameHostImpl.
   RenderFrameHostImpl* GetMainFrame() const;
@@ -102,37 +106,19 @@ class CONTENT_EXPORT FrameTree {
   void SetFrameRemoveListener(
       const base::Callback<void(RenderViewHostImpl*, int64)>& on_frame_removed);
 
-  void ClearFrameRemoveListenerForTesting();
-
-  // Creates a RenderViewHost for a new main frame RenderFrameHost in the given
-  // |site_instance|.  The RenderViewHost will have its Shutdown method called
-  // when all of the RenderFrameHosts using it are deleted.
-  RenderViewHostImpl* CreateRenderViewHostForMainFrame(
-      SiteInstance* site_instance,
-      int routing_id,
-      int main_frame_routing_id,
-      bool swapped_out,
-      bool hidden);
-
-  // Returns the existing RenderViewHost for a new subframe RenderFrameHost.
-  // There should always be such a RenderViewHost, because the main frame
-  // RenderFrameHost for each SiteInstance should be created before subframes.
-  RenderViewHostImpl* GetRenderViewHostForSubFrame(SiteInstance* site_instance);
-
-  // Keeps track of which RenderFrameHosts are using each RenderViewHost.  When
-  // the number drops to zero, we call Shutdown on the RenderViewHost.
-  void RegisterRenderFrameHost(RenderFrameHostImpl* render_frame_host);
-  void UnregisterRenderFrameHost(RenderFrameHostImpl* render_frame_host);
+  FrameTreeNode* root() const { return root_.get(); }
 
  private:
-  typedef std::pair<RenderViewHostImpl*, int> RenderViewHostRefCount;
-  typedef base::hash_map<int, RenderViewHostRefCount> RenderViewHostMap;
-
   // Returns the FrameTreeNode with the given renderer-specific |frame_id|.
   // For internal use only.
   // TODO(creis): Replace this with a version that takes in a routing ID.
   FrameTreeNode* FindByFrameID(int64 frame_id);
 
+  scoped_ptr<FrameTreeNode> CreateNode(int64 frame_id,
+                                       const std::string& frame_name,
+                                       int render_frame_host_id,
+                                       FrameTreeNode* parent_node);
+
   // These delegates are installed into all the RenderViewHosts and
   // RenderFrameHosts that we create.
   RenderFrameHostDelegate* render_frame_delegate_;
@@ -140,15 +126,6 @@ class CONTENT_EXPORT FrameTree {
   RenderWidgetHostDelegate* render_widget_delegate_;
   RenderFrameHostManager::Delegate* manager_delegate_;
 
-  // Map of SiteInstance ID to a (RenderViewHost, refcount) pair.  This allows
-  // us to look up the RenderViewHost for a given SiteInstance when creating
-  // RenderFrameHosts, and it allows us to call Shutdown on the RenderViewHost
-  // and remove it from the map when no more RenderFrameHosts are using it.
-  //
-  // Must be declared before |root_| so that it is deleted afterward.  Otherwise
-  // the map will be cleared before we delete the RenderFrameHosts in the tree.
-  RenderViewHostMap render_view_host_map_;
-
   scoped_ptr<FrameTreeNode> root_;
 
   base::Callback<void(RenderViewHostImpl*, int64)> on_frame_removed_;
diff --git a/content/browser/frame_host/frame_tree_node.cc b/content/browser/frame_host/frame_tree_node.cc
index cca17fd..37b61b4 100644
--- a/content/browser/frame_host/frame_tree_node.cc
+++ b/content/browser/frame_host/frame_tree_node.cc
@@ -7,53 +7,39 @@
 #include <queue>
 
 #include "base/stl_util.h"
-#include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
-#include "content/browser/renderer_host/render_view_host_impl.h"
 
 namespace content {
 
 const int64 FrameTreeNode::kInvalidFrameId = -1;
 int64 FrameTreeNode::next_frame_tree_node_id_ = 1;
 
-FrameTreeNode::FrameTreeNode(FrameTree* frame_tree,
-                             Navigator* navigator,
+FrameTreeNode::FrameTreeNode(Navigator* navigator,
                              RenderFrameHostDelegate* render_frame_delegate,
                              RenderViewHostDelegate* render_view_delegate,
                              RenderWidgetHostDelegate* render_widget_delegate,
                              RenderFrameHostManager::Delegate* manager_delegate,
                              int64 frame_id,
                              const std::string& name)
-  : frame_tree_(frame_tree),
-    navigator_(navigator),
-    render_manager_(this,
-                    render_frame_delegate,
+  : navigator_(navigator),
+    render_manager_(render_frame_delegate,
                     render_view_delegate,
                     render_widget_delegate,
                     manager_delegate),
     frame_tree_node_id_(next_frame_tree_node_id_++),
     frame_id_(frame_id),
-    frame_name_(name) {
+    frame_name_(name),
+    owns_render_frame_host_(true),
+    render_frame_host_(NULL) {
 }
 
 FrameTreeNode::~FrameTreeNode() {
+  if (owns_render_frame_host_)
+    delete render_frame_host_;
 }
 
-bool FrameTreeNode::IsMainFrame() const {
-  return frame_tree_->root() == this;
-}
-
-void FrameTreeNode::AddChild(scoped_ptr<FrameTreeNode> child,
-                             int frame_routing_id) {
-  // Initialize the RenderFrameHost for the new node.  We always create child
-  // frames in the same SiteInstance as the current frame, and they can swap to
-  // a different one if they navigate away.
-  child->render_manager()->Init(
-      render_manager_.current_host()->GetSiteInstance()->GetBrowserContext(),
-      render_manager_.current_host()->GetSiteInstance(),
-      render_manager_.current_host()->GetRoutingID(),
-      frame_routing_id);
+void FrameTreeNode::AddChild(scoped_ptr<FrameTreeNode> child) {
   children_.push_back(child.release());
 }
 
@@ -69,7 +55,9 @@ void FrameTreeNode::RemoveChild(FrameTreeNode* child) {
     children_.erase(iter);
 }
 
-void FrameTreeNode::ResetForMainFrameSwap() {
+void FrameTreeNode::ResetForMainFrame(
+    RenderFrameHostImpl* new_render_frame_host) {
+  owns_render_frame_host_ = false;
   frame_id_ = kInvalidFrameId;
   current_url_ = GURL();
 
@@ -77,6 +65,8 @@ void FrameTreeNode::ResetForMainFrameSwap() {
   // commits before the old process cleans everything up.  Make sure the child
   // nodes get deleted.
   children_.clear();
+
+  render_frame_host_ = new_render_frame_host;
 }
 
 }  // namespace content
diff --git a/content/browser/frame_host/frame_tree_node.h b/content/browser/frame_host/frame_tree_node.h
index e7b0800..9c22b12 100644
--- a/content/browser/frame_host/frame_tree_node.h
+++ b/content/browser/frame_host/frame_tree_node.h
@@ -18,7 +18,6 @@
 
 namespace content {
 
-class FrameTree;
 class Navigator;
 class RenderFrameHostImpl;
 
@@ -30,8 +29,7 @@ class CONTENT_EXPORT FrameTreeNode {
  public:
   static const int64 kInvalidFrameId;
 
-  FrameTreeNode(FrameTree* frame_tree,
-                Navigator* navigator,
+  FrameTreeNode(Navigator* navigator,
                 RenderFrameHostDelegate* render_frame_delegate,
                 RenderViewHostDelegate* render_view_delegate,
                 RenderWidgetHostDelegate* render_widget_delegate,
@@ -41,19 +39,28 @@ class CONTENT_EXPORT FrameTreeNode {
 
   ~FrameTreeNode();
 
-  bool IsMainFrame() const;
-
-  void AddChild(scoped_ptr<FrameTreeNode> child, int frame_routing_id);
+  void AddChild(scoped_ptr<FrameTreeNode> child);
   void RemoveChild(FrameTreeNode* child);
 
-  // Clears process specific-state after a main frame process swap.
-  // TODO(creis): Look into how we can remove the need for this method.
-  void ResetForMainFrameSwap();
-
-  FrameTree* frame_tree() const {
-    return frame_tree_;
+  // TODO(nasko): This method should be removed once RenderFrameHosts are
+  // created by RenderFrameHostManager.
+  void set_render_frame_host(
+      RenderFrameHostImpl* render_frame_host,
+      bool owns_render_frame_host) {
+    render_frame_host_ = render_frame_host;
+    owns_render_frame_host_ = owns_render_frame_host;
   }
 
+  // Transitional API allowing the RenderFrameHost of a FrameTreeNode
+  // representing the main frame to be provided by someone else. After
+  // this is called, the FrameTreeNode no longer owns its RenderFrameHost.
+  //
+  // This should only be used for the main frame (aka root) in a frame tree.
+  //
+  // TODO(ajwong): Remove this method once the main frame RenderFrameHostImpl is
+  // no longer owned by the RenderViewHostImpl.
+  void ResetForMainFrame(RenderFrameHostImpl* new_render_frame_host);
+
   Navigator* navigator() {
     return navigator_.get();
   }
@@ -96,25 +103,23 @@ class CONTENT_EXPORT FrameTreeNode {
     current_url_ = url;
   }
 
-  RenderFrameHostImpl* current_frame_host() const {
-    return render_manager_.current_frame_host();
+  RenderFrameHostImpl* render_frame_host() const {
+    return render_frame_host_;
   }
 
  private:
   // The next available browser-global FrameTreeNode ID.
   static int64 next_frame_tree_node_id_;
 
-  // The FrameTree that owns us.
-  FrameTree* frame_tree_;  // not owned.
-
   // The Navigator object responsible for managing navigations at this node
   // of the frame tree.
   scoped_refptr<Navigator> navigator_;
 
-  // Manages creation and swapping of RenderFrameHosts for this frame.  This
-  // must be declared before |children_| so that it gets deleted after them.
-  //  That's currently necessary so that RenderFrameHostImpl's destructor can
-  // call GetProcess.
+  // Manages creation and swapping of RenderViewHosts for this frame.  This must
+  // be declared before |children_| so that it gets deleted after them.  That's
+  // currently necessary so that RenderFrameHostImpl's destructor can call
+  // GetProcess.
+  // TODO(creis): This will eliminate the need for |render_frame_host_| below.
   RenderFrameHostManager render_manager_;
 
   // A browser-global identifier for the frame in the page, which stays stable
@@ -134,6 +139,22 @@ class CONTENT_EXPORT FrameTreeNode {
   // The immediate children of this specific frame.
   ScopedVector<FrameTreeNode> children_;
 
+  // When ResetForMainFrame() is called, this is set to false and the
+  // |render_frame_host_| below is not deleted on destruction.
+  //
+  // For the mainframe, the FrameTree does not own the |render_frame_host_|.
+  // This is a transitional wart because RenderFrameHostManager does not yet
+  // have the bookkeeping logic to handle creating a pending RenderFrameHost
+  // along with a pending RenderViewHost. Thus, for the main frame, the
+  // RenderViewHost currently retains ownership and the FrameTreeNode should
+  // not delete it on destruction.
+  bool owns_render_frame_host_;
+
+  // The active RenderFrameHost for this frame. The FrameTreeNode does not
+  // always own this pointer.  See comments above |owns_render_frame_host_|.
+  // TODO(ajwong): Replace with RenderFrameHostManager.
+  RenderFrameHostImpl* render_frame_host_;
+
   // Track the current frame's last committed URL, so we can estimate the
   // process impact of out-of-process iframes.
   // TODO(creis): Remove this when we can store subframe URLs in the
diff --git a/content/browser/frame_host/frame_tree_unittest.cc b/content/browser/frame_host/frame_tree_unittest.cc
index ede3513..6f1bb33 100644
--- a/content/browser/frame_host/frame_tree_unittest.cc
+++ b/content/browser/frame_host/frame_tree_unittest.cc
@@ -10,7 +10,6 @@
 #include "content/browser/frame_host/render_frame_host_factory.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
-#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ -48,6 +47,35 @@ class FrameTreeTest : public RenderViewHostTestHarness {
   }
 };
 
+// The root node never changes during navigation even though its
+// RenderFrameHost does.
+//  - Swapping main frame doesn't change root node.
+//  - Swapping back to NULL doesn't crash (easier tear-down for interstitials).
+//  - Main frame does not own RenderFrameHost.
+TEST_F(FrameTreeTest, RootNode) {
+  FrameTree frame_tree(new NavigatorImpl(NULL, NULL), NULL, NULL, NULL, NULL);
+
+  // Initial state has empty node.
+  FrameTreeNode* root = frame_tree.root();
+  ASSERT_TRUE(root);
+  EXPECT_FALSE(frame_tree.GetMainFrame());
+
+  // Swap in main frame.
+  RenderFrameHostImpl* dummy = reinterpret_cast<RenderFrameHostImpl*>(0x1);
+  frame_tree.SwapMainFrame(dummy);
+  EXPECT_EQ(root, frame_tree.root());
+  EXPECT_EQ(dummy, frame_tree.GetMainFrame());
+
+  // Move back to NULL.
+  frame_tree.SwapMainFrame(NULL);
+  EXPECT_EQ(root, frame_tree.root());
+  EXPECT_FALSE(frame_tree.GetMainFrame());
+
+  // Move back to an invalid pointer, let the FrameTree go out of scope. Test
+  // should not crash because the main frame isn't owned.
+  frame_tree.SwapMainFrame(dummy);
+}
+
 // Test that swapping the main frame resets the renderer-assigned frame id.
 //  - On creation, frame id is unassigned.
 //  - After a swap, frame id is unassigned.
@@ -61,7 +89,7 @@ TEST_F(FrameTreeTest, FirstNavigationAfterSwap) {
   EXPECT_FALSE(frame_tree.IsFirstNavigationAfterSwap());
   EXPECT_EQ(1, frame_tree.root()->frame_id());
 
-  frame_tree.ResetForMainFrameSwap();
+  frame_tree.SwapMainFrame(NULL);
   EXPECT_TRUE(frame_tree.IsFirstNavigationAfterSwap());
   EXPECT_EQ(FrameTreeNode::kInvalidFrameId,
             frame_tree.root()->frame_id());
@@ -71,43 +99,49 @@ TEST_F(FrameTreeTest, FirstNavigationAfterSwap) {
 //  - Add a series of nodes and verify tree structure.
 //  - Remove a series of nodes and verify tree structure.
 TEST_F(FrameTreeTest, Shape) {
-  // Use the FrameTree of the WebContents so that it has all the delegates it
-  // needs.  We may want to consider a test version of this.
-  FrameTree* frame_tree =
-      static_cast<WebContentsImpl*>(web_contents())->GetFrameTree();
+  FrameTree frame_tree(new NavigatorImpl(NULL, NULL), NULL, NULL, NULL, NULL);
 
   std::string no_children_node("no children node");
   std::string deep_subtree("node with deep subtree");
 
-  frame_tree->OnFirstNavigationAfterSwap(5);
+  // Ensure the top-level node of the FrameTree is initialized by simulating a
+  // main frame swap here.
+  scoped_ptr<RenderFrameHostImpl> render_frame_host =
+      RenderFrameHostFactory::Create(static_cast<RenderViewHostImpl*>(rvh()),
+                                     NULL,
+                                     &frame_tree,
+                                     frame_tree.root(),
+                                     process()->GetNextRoutingID(),
+                                     false);
+  frame_tree.SwapMainFrame(render_frame_host.get());
+  frame_tree.OnFirstNavigationAfterSwap(5);
 
-  ASSERT_EQ("5: []", GetTreeState(frame_tree));
+  ASSERT_EQ("5: []", GetTreeState(&frame_tree));
 
   // Simulate attaching a series of frames to build the frame tree.
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 5, 14, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 5, 15, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 5, 16, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 5, 14, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 5, 15, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 5, 16, std::string());
 
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 14, 244, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 15, 255,
-                       no_children_node);
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 14, 245, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 14, 244, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 15, 255, no_children_node);
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 14, 245, std::string());
 
   ASSERT_EQ("5: [14: [244: [], 245: []], "
                 "15: [255 'no children node': []], "
                 "16: []]",
-            GetTreeState(frame_tree));
+            GetTreeState(&frame_tree));
 
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 16, 264, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 16, 265, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 16, 266, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 16, 267, deep_subtree);
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 16, 268, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 16, 264, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 16, 265, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 16, 266, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 16, 267, deep_subtree);
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 16, 268, std::string());
 
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 267, 365, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 365, 455, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 455, 555, std::string());
-  frame_tree->AddFrame(process()->GetNextRoutingID(), 555, 655, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 267, 365, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 365, 455, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 455, 555, std::string());
+  frame_tree.AddFrame(process()->GetNextRoutingID(), 555, 655, std::string());
 
   // Now that's it's fully built, verify the tree structure is as expected.
   ASSERT_EQ("5: [14: [244: [], 245: []], "
@@ -115,33 +149,31 @@ TEST_F(FrameTreeTest, Shape) {
                 "16: [264: [], 265: [], 266: [], "
                      "267 'node with deep subtree': "
                          "[365: [455: [555: [655: []]]]], 268: []]]",
-            GetTreeState(frame_tree));
+            GetTreeState(&frame_tree));
 
-  // Test removing of nodes.  Clear the frame removal listener so we can pass a
-  // NULL RFH here.
-  frame_tree->ClearFrameRemoveListenerForTesting();
-  frame_tree->RemoveFrame(NULL, 555, 655);
+  // Test removing of nodes.
+  frame_tree.RemoveFrame(NULL, 555, 655);
   ASSERT_EQ("5: [14: [244: [], 245: []], "
                 "15: [255 'no children node': []], "
                 "16: [264: [], 265: [], 266: [], "
                      "267 'node with deep subtree': "
                          "[365: [455: [555: []]]], 268: []]]",
-            GetTreeState(frame_tree));
+            GetTreeState(&frame_tree));
 
-  frame_tree->RemoveFrame(NULL, 16, 265);
+  frame_tree.RemoveFrame(NULL, 16, 265);
   ASSERT_EQ("5: [14: [244: [], 245: []], "
                 "15: [255 'no children node': []], "
                 "16: [264: [], 266: [], "
                      "267 'node with deep subtree': "
                          "[365: [455: [555: []]]], 268: []]]",
-            GetTreeState(frame_tree));
+            GetTreeState(&frame_tree));
 
-  frame_tree->RemoveFrame(NULL, 5, 15);
+  frame_tree.RemoveFrame(NULL, 5, 15);
   ASSERT_EQ("5: [14: [244: [], 245: []], "
                 "16: [264: [], 266: [], "
                      "267 'node with deep subtree': "
                          "[365: [455: [555: []]]], 268: []]]",
-            GetTreeState(frame_tree));
+            GetTreeState(&frame_tree));
 }
 
 }  // namespace
diff --git a/content/browser/frame_host/interstitial_page_impl.cc b/content/browser/frame_host/interstitial_page_impl.cc
index f3bfb8c2..7af8d02 100644
--- a/content/browser/frame_host/interstitial_page_impl.cc
+++ b/content/browser/frame_host/interstitial_page_impl.cc
@@ -162,7 +162,7 @@ InterstitialPageImpl::InterstitialPageImpl(
       // TODO(creis): We will also need to pass delegates for the RVHM as we
       // start to use it.
       frame_tree_(new InterstitialPageNavigatorImpl(this, controller_),
-                  this, this, this, NULL),
+                  NULL, NULL, NULL, NULL),
       original_child_id_(web_contents->GetRenderProcessHost()->GetID()),
       original_rvh_id_(web_contents->GetRenderViewHost()->GetRoutingID()),
       should_revert_web_contents_title_(false),
@@ -284,15 +284,15 @@ void InterstitialPageImpl::Hide() {
         controller_->delegate()->GetRenderViewHost()->GetView())->Focus();
   }
 
-  // Delete this and call Shutdown on the RVH asynchronously, as we may have
-  // been called from a RVH delegate method, and we can't delete the RVH out
-  // from under itself.
+  // Shutdown the RVH asynchronously, as we may have been called from a RVH
+  // delegate method, and we can't delete the RVH out from under itself.
   base::MessageLoop::current()->PostNonNestableTask(
       FROM_HERE,
       base::Bind(&InterstitialPageImpl::Shutdown,
-                 weak_ptr_factory_.GetWeakPtr()));
+                 weak_ptr_factory_.GetWeakPtr(),
+                 render_view_host_));
   render_view_host_ = NULL;
-  frame_tree_.ResetForMainFrameSwap();
+  frame_tree_.SwapMainFrame(NULL);
   controller_->delegate()->DetachInterstitialPage();
   // Let's revert to the original title if necessary.
   NavigationEntry* entry = controller_->GetVisibleEntry();
@@ -479,8 +479,7 @@ WebPreferences InterstitialPageImpl::GetWebkitPrefs() {
 
 void InterstitialPageImpl::RenderWidgetDeleted(
     RenderWidgetHostImpl* render_widget_host) {
-  // TODO(creis): Remove this method once we verify the shutdown path is sane.
-  CHECK(!web_contents_);
+  delete this;
 }
 
 bool InterstitialPageImpl::PreHandleKeyboardEvent(
@@ -525,10 +524,14 @@ RenderViewHost* InterstitialPageImpl::CreateRenderViewHost() {
   session_storage_namespace_ =
       new SessionStorageNamespaceImpl(dom_storage_context);
 
-  // Use the RenderViewHost from our FrameTree.
-  frame_tree_.root()->render_manager()->Init(
-      browser_context, site_instance.get(), MSG_ROUTING_NONE, MSG_ROUTING_NONE);
-  return frame_tree_.root()->current_frame_host()->render_view_host();
+  return RenderViewHostFactory::Create(site_instance.get(),
+                                       this,
+                                       this,
+                                       this,
+                                       MSG_ROUTING_NONE,
+                                       MSG_ROUTING_NONE,
+                                       false,
+                                       false);
 }
 
 WebContentsView* InterstitialPageImpl::CreateWebContentsView() {
@@ -746,8 +749,9 @@ void InterstitialPageImpl::Disable() {
   enabled_ = false;
 }
 
-void InterstitialPageImpl::Shutdown() {
-  delete this;
+void InterstitialPageImpl::Shutdown(RenderViewHostImpl* render_view_host) {
+  render_view_host->Shutdown();
+  // We are deleted now.
 }
 
 void InterstitialPageImpl::OnNavigatingAwayOrTabClosing() {
diff --git a/content/browser/frame_host/interstitial_page_impl.h b/content/browser/frame_host/interstitial_page_impl.h
index e4b4c40..fddeacd 100644
--- a/content/browser/frame_host/interstitial_page_impl.h
+++ b/content/browser/frame_host/interstitial_page_impl.h
@@ -180,8 +180,8 @@ class CONTENT_EXPORT InterstitialPageImpl
   // - any command sent by the RenderViewHost will be ignored.
   void Disable();
 
-  // Delete ourselves, causing Shutdown on the RVH to be called.
-  void Shutdown();
+  // Shutdown the RVH.  We will be deleted by the time this method returns.
+  void Shutdown(RenderViewHostImpl* render_view_host);
 
   void OnNavigatingAwayOrTabClosing();
 
@@ -229,8 +229,6 @@ class CONTENT_EXPORT InterstitialPageImpl
   // The RenderViewHost displaying the interstitial contents.  This is valid
   // until Hide is called, at which point it will be set to NULL, signifying
   // that shutdown has started.
-  // TODO(creis): This is now owned by the FrameTree.  We should route things
-  // through the tree's root RenderFrameHost instead.
   RenderViewHostImpl* render_view_host_;
 
   // The frame tree structure of the current page.
diff --git a/content/browser/frame_host/render_frame_host_impl.cc b/content/browser/frame_host/render_frame_host_impl.cc
index a2f8712..658e834 100644
--- a/content/browser/frame_host/render_frame_host_impl.cc
+++ b/content/browser/frame_host/render_frame_host_impl.cc
@@ -48,7 +48,6 @@ RenderFrameHostImpl::RenderFrameHostImpl(
       frame_tree_node_(frame_tree_node),
       routing_id_(routing_id),
       is_swapped_out_(is_swapped_out) {
-  frame_tree_->RegisterRenderFrameHost(this);
   GetProcess()->AddRoute(routing_id_, this);
   g_routing_id_frame_map.Get().insert(std::make_pair(
       RenderFrameHostID(GetProcess()->GetID(), routing_id_),
@@ -61,10 +60,6 @@ RenderFrameHostImpl::~RenderFrameHostImpl() {
       RenderFrameHostID(GetProcess()->GetID(), routing_id_));
   if (delegate_)
     delegate_->RenderFrameDeleted(this);
-
-  // Notify the FrameTree that this RFH is going away, allowing it to shut down
-  // the corresponding RenderViewHost if it is no longer needed.
-  frame_tree_->UnregisterRenderFrameHost(this);
 }
 
 int RenderFrameHostImpl::GetRoutingID() {
diff --git a/content/browser/frame_host/render_frame_host_impl.h b/content/browser/frame_host/render_frame_host_impl.h
index f00604a..2822724 100644
--- a/content/browser/frame_host/render_frame_host_impl.h
+++ b/content/browser/frame_host/render_frame_host_impl.h
@@ -76,13 +76,8 @@ class CONTENT_EXPORT RenderFrameHostImpl : public RenderFrameHost {
 
   bool is_swapped_out() { return is_swapped_out_; }
 
-  // For now, RenderFrameHosts indirectly keep RenderViewHosts alive via a
-  // refcount that calls Shutdown when it reaches zero.  This allows each
-  // RenderFrameHostManager to just care about RenderFrameHosts, while ensuring
-  // we have a RenderViewHost for each RenderFrameHost.
-  // TODO(creis): RenderViewHost will eventually go away and be replaced with
-  // some form of page context.
-  RenderViewHostImpl* render_view_host_;
+  // TODO(nasko): This should be removed and replaced by RenderProcessHost.
+  RenderViewHostImpl* render_view_host_;  // Not owned.
 
   RenderFrameHostDelegate* delegate_;
 
diff --git a/content/browser/frame_host/render_frame_host_manager.cc b/content/browser/frame_host/render_frame_host_manager.cc
index b5e1d48..8b7448d 100644
--- a/content/browser/frame_host/render_frame_host_manager.cc
+++ b/content/browser/frame_host/render_frame_host_manager.cc
@@ -14,8 +14,6 @@
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
-#include "content/browser/frame_host/render_frame_host_factory.h"
-#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ -59,55 +57,53 @@ RenderFrameHostManager::PendingNavigationParams::PendingNavigationParams(
 RenderFrameHostManager::PendingNavigationParams::~PendingNavigationParams() {}
 
 RenderFrameHostManager::RenderFrameHostManager(
-    FrameTreeNode* frame_tree_node,
     RenderFrameHostDelegate* render_frame_delegate,
     RenderViewHostDelegate* render_view_delegate,
     RenderWidgetHostDelegate* render_widget_delegate,
     Delegate* delegate)
-    : frame_tree_node_(frame_tree_node),
-      delegate_(delegate),
+    : delegate_(delegate),
       cross_navigation_pending_(false),
       render_frame_delegate_(render_frame_delegate),
       render_view_delegate_(render_view_delegate),
       render_widget_delegate_(render_widget_delegate),
-      render_frame_host_(NULL),
-      pending_render_frame_host_(NULL),
+      render_view_host_(NULL),
+      pending_render_view_host_(NULL),
       interstitial_page_(NULL) {
 }
 
 RenderFrameHostManager::~RenderFrameHostManager() {
-  if (pending_render_frame_host_)
+  if (pending_render_view_host_)
     CancelPending();
 
-  // We should always have a current RenderFrameHost except in some tests.
-  // TODO(creis): Now that we aren't using Shutdown, make render_frame_host_ and
-  // RenderFrameHostMap use scoped_ptrs.
-  RenderFrameHostImpl* render_frame_host = render_frame_host_;
-  render_frame_host_ = NULL;
-  if (render_frame_host)
-    delete render_frame_host;
+  // We should always have a main RenderViewHost except in some tests.
+  RenderViewHostImpl* render_view_host = render_view_host_;
+  render_view_host_ = NULL;
+  if (render_view_host)
+    render_view_host->Shutdown();
 
-  // Delete any swapped out RenderFrameHosts.
-  for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin();
+  // Shut down any swapped out RenderViewHosts.
+  for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
-    delete iter->second;
+    iter->second->Shutdown();
   }
 }
 
 void RenderFrameHostManager::Init(BrowserContext* browser_context,
                                   SiteInstance* site_instance,
-                                  int view_routing_id,
-                                  int frame_routing_id) {
-  // Create a RenderViewHost and RenderFrameHost, once we have an instance.  It
-  // is important to immediately give this SiteInstance to a RenderViewHost so
-  // that the SiteInstance is ref counted.
+                                  int routing_id,
+                                  int main_frame_routing_id) {
+  // Create a RenderViewHost, once we have an instance.  It is important to
+  // immediately give this SiteInstance to a RenderViewHost so that it is
+  // ref counted.
   if (!site_instance)
     site_instance = SiteInstance::Create(browser_context);
-
-  // TODO(creis): Make render_frame_host_ a scoped_ptr.
-  render_frame_host_ = CreateRenderFrameHost(site_instance, view_routing_id,
-                                             frame_routing_id, false, false);
+  render_view_host_ = static_cast<RenderViewHostImpl*>(
+      RenderViewHostFactory::Create(
+          site_instance, render_view_delegate_, render_frame_delegate_,
+          render_widget_delegate_, routing_id, main_frame_routing_id, false,
+          delegate_->IsHidden()));
+  render_view_host_->AttachToFrameTree();
 
   // Keep track of renderer processes as they start to shut down or are
   // crashed/killed.
@@ -118,23 +114,19 @@ void RenderFrameHostManager::Init(BrowserContext* browser_context,
 }
 
 RenderViewHostImpl* RenderFrameHostManager::current_host() const {
-  if (!render_frame_host_)
-    return NULL;
-  return render_frame_host_->render_view_host();
+  return render_view_host_;
 }
 
 RenderViewHostImpl* RenderFrameHostManager::pending_render_view_host() const {
-  if (!pending_render_frame_host_)
-    return NULL;
-  return pending_render_frame_host_->render_view_host();
+  return pending_render_view_host_;
 }
 
 RenderWidgetHostView* RenderFrameHostManager::GetRenderWidgetHostView() const {
   if (interstitial_page_)
     return interstitial_page_->GetView();
-  if (!render_frame_host_)
+  if (!render_view_host_)
     return NULL;
-  return render_frame_host_->render_view_host()->GetView();
+  return render_view_host_->GetView();
 }
 
 void RenderFrameHostManager::SetPendingWebUI(const NavigationEntryImpl& entry) {
@@ -157,111 +149,103 @@ void RenderFrameHostManager::SetPendingWebUI(const NavigationEntryImpl& entry) {
 RenderViewHostImpl* RenderFrameHostManager::Navigate(
     const NavigationEntryImpl& entry) {
   TRACE_EVENT0("browser", "RenderFrameHostManager:Navigate");
-  // Create a pending RenderFrameHost to use for the navigation.
-  RenderFrameHostImpl* dest_render_frame_host =
-      UpdateRendererStateForNavigate(entry);
-  if (!dest_render_frame_host)
-    return NULL;  // We weren't able to create a pending render frame host.
-
-  // If the current render_frame_host_ isn't live, we should create it so
-  // that we don't show a sad tab while the dest_render_frame_host fetches
+  // Create a pending RenderViewHost. It will give us the one we should use
+  RenderViewHostImpl* dest_render_view_host =
+      static_cast<RenderViewHostImpl*>(UpdateRendererStateForNavigate(entry));
+  if (!dest_render_view_host)
+    return NULL;  // We weren't able to create a pending render view host.
+
+  // If the current render_view_host_ isn't live, we should create it so
+  // that we don't show a sad tab while the dest_render_view_host fetches
   // its first page.  (Bug 1145340)
-  if (dest_render_frame_host != render_frame_host_ &&
-      !render_frame_host_->render_view_host()->IsRenderViewLive()) {
+  if (dest_render_view_host != render_view_host_ &&
+      !render_view_host_->IsRenderViewLive()) {
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
-    delegate_->CreateRenderViewForRenderManager(
-        render_frame_host_->render_view_host(), MSG_ROUTING_NONE);
+    delegate_->CreateRenderViewForRenderManager(render_view_host_,
+                                                MSG_ROUTING_NONE);
   }
 
   // If the renderer crashed, then try to create a new one to satisfy this
   // navigation request.
-  if (!dest_render_frame_host->render_view_host()->IsRenderViewLive()) {
+  if (!dest_render_view_host->IsRenderViewLive()) {
     // Recreate the opener chain.
     int opener_route_id = delegate_->CreateOpenerRenderViewsForRenderManager(
-        dest_render_frame_host->render_view_host()->GetSiteInstance());
-    if (!InitRenderView(dest_render_frame_host->render_view_host(),
-                        opener_route_id))
+        dest_render_view_host->GetSiteInstance());
+    if (!InitRenderView(dest_render_view_host, opener_route_id))
       return NULL;
 
     // Now that we've created a new renderer, be sure to hide it if it isn't
     // our primary one.  Otherwise, we might crash if we try to call Show()
     // on it later.
-    if (dest_render_frame_host != render_frame_host_ &&
-        dest_render_frame_host->render_view_host()->GetView()) {
-      dest_render_frame_host->render_view_host()->GetView()->Hide();
+    if (dest_render_view_host != render_view_host_ &&
+        dest_render_view_host->GetView()) {
+      dest_render_view_host->GetView()->Hide();
     } else {
       // This is our primary renderer, notify here as we won't be calling
       // CommitPending (which does the notify).
-      delegate_->NotifySwappedFromRenderManager(
-          NULL, render_frame_host_->render_view_host());
+      delegate_->NotifySwappedFromRenderManager(NULL, render_view_host_);
     }
   }
 
-  // TODO(creis): Return the RFH instead, once we can navigate RFHs.
-  return dest_render_frame_host->render_view_host();
+  return dest_render_view_host;
 }
 
 void RenderFrameHostManager::Stop() {
-  render_frame_host_->render_view_host()->Stop();
+  render_view_host_->Stop();
 
   // If we are cross-navigating, we should stop the pending renderers.  This
   // will lead to a DidFailProvisionalLoad, which will properly destroy them.
   if (cross_navigation_pending_) {
-    pending_render_frame_host_->render_view_host()->Send(new ViewMsg_Stop(
-        pending_render_frame_host_->render_view_host()->GetRoutingID()));
+    pending_render_view_host_->Send(
+        new ViewMsg_Stop(pending_render_view_host_->GetRoutingID()));
   }
 }
 
 void RenderFrameHostManager::SetIsLoading(bool is_loading) {
-  render_frame_host_->render_view_host()->SetIsLoading(is_loading);
-  if (pending_render_frame_host_)
-    pending_render_frame_host_->render_view_host()->SetIsLoading(is_loading);
+  render_view_host_->SetIsLoading(is_loading);
+  if (pending_render_view_host_)
+    pending_render_view_host_->SetIsLoading(is_loading);
 }
 
 bool RenderFrameHostManager::ShouldCloseTabOnUnresponsiveRenderer() {
   if (!cross_navigation_pending_)
     return true;
 
-  // We should always have a pending RFH when there's a cross-process navigation
+  // We should always have a pending RVH when there's a cross-process navigation
   // in progress.  Sanity check this for http://crbug.com/276333.
-  CHECK(pending_render_frame_host_);
+  CHECK(pending_render_view_host_);
 
   // If the tab becomes unresponsive during {before}unload while doing a
   // cross-site navigation, proceed with the navigation.  (This assumes that
-  // the pending RenderFrameHost is still responsive.)
-  if (render_frame_host_->render_view_host()->is_waiting_for_unload_ack()) {
+  // the pending RenderViewHost is still responsive.)
+  if (render_view_host_->is_waiting_for_unload_ack()) {
     // The request has been started and paused while we're waiting for the
     // unload handler to finish.  We'll pretend that it did.  The pending
     // renderer will then be swapped in as part of the usual DidNavigate logic.
     // (If the unload handler later finishes, this call will be ignored because
     // the pending_nav_params_ state will already be cleaned up.)
     current_host()->OnSwappedOut(true);
-  } else if (render_frame_host_->render_view_host()->
-                 is_waiting_for_beforeunload_ack()) {
+  } else if (render_view_host_->is_waiting_for_beforeunload_ack()) {
     // Haven't gotten around to starting the request, because we're still
     // waiting for the beforeunload handler to finish.  We'll pretend that it
     // did finish, to let the navigation proceed.  Note that there's a danger
     // that the beforeunload handler will later finish and possibly return
     // false (meaning the navigation should not proceed), but we'll ignore it
     // in this case because it took too long.
-    if (pending_render_frame_host_->render_view_host()->
-            are_navigations_suspended()) {
-      pending_render_frame_host_->render_view_host()->SetNavigationsSuspended(
+    if (pending_render_view_host_->are_navigations_suspended())
+      pending_render_view_host_->SetNavigationsSuspended(
           false, base::TimeTicks::Now());
-    }
   }
   return false;
 }
 
-// TODO(creis): This should take in a RenderFrameHost.
 void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) {
   // Make sure this is from our current RVH, and that we have a pending
   // navigation from OnCrossSiteResponse.  (There may be no pending navigation
   // for data URLs that don't make network requests, for example.)   If not,
   // just return early and ignore.
-  if (render_view_host != render_frame_host_->render_view_host() ||
-      !pending_nav_params_.get()) {
+  if (render_view_host != render_view_host_ || !pending_nav_params_.get()) {
     pending_nav_params_.reset();
     return;
   }
@@ -291,24 +275,23 @@ void RenderFrameHostManager::SwappedOut(RenderViewHost* render_view_host) {
         pending_nav_params_->global_request_id,
         pending_nav_params_->should_replace_current_entry,
         true);
-  } else if (pending_render_frame_host_) {
+  } else if (pending_render_view_host_) {
     RenderProcessHostImpl* pending_process =
         static_cast<RenderProcessHostImpl*>(
-            pending_render_frame_host_->GetProcess());
+            pending_render_view_host_->GetProcess());
     pending_process->ResumeDeferredNavigation(
         pending_nav_params_->global_request_id);
   }
   pending_nav_params_.reset();
 }
 
-// TODO(creis): This should take in a RenderFrameHost.
 void RenderFrameHostManager::DidNavigateMainFrame(
     RenderViewHost* render_view_host) {
   if (!cross_navigation_pending_) {
-    DCHECK(!pending_render_frame_host_);
+    DCHECK(!pending_render_view_host_);
 
     // We should only hear this from our current renderer.
-    DCHECK(render_view_host == render_frame_host_->render_view_host());
+    DCHECK(render_view_host == render_view_host_);
 
     // Even when there is no pending RVH, there may be a pending Web UI.
     if (pending_web_ui())
@@ -316,18 +299,17 @@ void RenderFrameHostManager::DidNavigateMainFrame(
     return;
   }
 
-  if (render_view_host == pending_render_frame_host_->render_view_host()) {
+  if (render_view_host == pending_render_view_host_) {
     // The pending cross-site navigation completed, so show the renderer.
     // If it committed without sending network requests (e.g., data URLs),
-    // then we still need to swap out the old RFH first and run its unload
+    // then we still need to swap out the old RVH first and run its unload
     // handler.  OK for that to happen in the background.
-    if (pending_render_frame_host_->render_view_host()->
-            HasPendingCrossSiteRequest())
+    if (pending_render_view_host_->HasPendingCrossSiteRequest())
       SwapOutOldPage();
 
     CommitPending();
     cross_navigation_pending_ = false;
-  } else if (render_view_host == render_frame_host_->render_view_host()) {
+  } else if (render_view_host == render_view_host_) {
     // A navigation in the original page has taken place.  Cancel the pending
     // one.
     CancelPending();
@@ -338,15 +320,14 @@ void RenderFrameHostManager::DidNavigateMainFrame(
   }
 }
 
-// TODO(creis): Take in RenderFrameHost instead, since frames can have openers.
 void RenderFrameHostManager::DidDisownOpener(RenderViewHost* render_view_host) {
   // Notify all swapped out hosts, including the pending RVH.
-  for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin();
+  for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
-    DCHECK_NE(iter->second->render_view_host()->GetSiteInstance(),
+    DCHECK_NE(iter->second->GetSiteInstance(),
               current_host()->GetSiteInstance());
-    iter->second->render_view_host()->DisownOpener();
+    iter->second->DisownOpener();
   }
 }
 
@@ -370,7 +351,7 @@ void RenderFrameHostManager::RendererProcessClosing(
   // swap them back in while the process is exiting.  Start by finding them,
   // since there could be more than one.
   std::list<int> ids_to_remove;
-  for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin();
+  for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     if (iter->second->GetProcess() == render_process_host)
@@ -379,7 +360,7 @@ void RenderFrameHostManager::RendererProcessClosing(
 
   // Now delete them.
   while (!ids_to_remove.empty()) {
-    delete swapped_out_hosts_[ids_to_remove.back()];
+    swapped_out_hosts_[ids_to_remove.back()]->Shutdown();
     swapped_out_hosts_.erase(ids_to_remove.back());
     ids_to_remove.pop_back();
   }
@@ -400,11 +381,9 @@ void RenderFrameHostManager::ShouldClosePage(
       // might be because the renderer was deemed unresponsive and this call was
       // already made by ShouldCloseTabOnUnresponsiveRenderer.  In that case, it
       // is ok to do nothing here.
-      if (pending_render_frame_host_ &&
-          pending_render_frame_host_->render_view_host()->
-              are_navigations_suspended()) {
-        pending_render_frame_host_->render_view_host()->
-            SetNavigationsSuspended(false, proceed_time);
+      if (pending_render_view_host_ &&
+          pending_render_view_host_->are_navigations_suspended()) {
+        pending_render_view_host_->SetNavigationsSuspended(false, proceed_time);
       }
     } else {
       // Current page says to cancel.
@@ -418,21 +397,20 @@ void RenderFrameHostManager::ShouldClosePage(
                                                   &proceed_to_fire_unload);
 
     if (proceed_to_fire_unload) {
-      // If we're about to close the tab and there's a pending RFH, cancel it.
-      // Otherwise, if the navigation in the pending RFH completes before the
-      // close in the current RFH, we'll lose the tab close.
-      if (pending_render_frame_host_) {
+      // If we're about to close the tab and there's a pending RVH, cancel it.
+      // Otherwise, if the navigation in the pending RVH completes before the
+      // close in the current RVH, we'll lose the tab close.
+      if (pending_render_view_host_) {
         CancelPending();
         cross_navigation_pending_ = false;
       }
 
       // This is not a cross-site navigation, the tab is being closed.
-      render_frame_host_->render_view_host()->ClosePage();
+      render_view_host_->ClosePage();
     }
   }
 }
 
-// TODO(creis): Take in a RenderFrameHost from CSRH.
 void RenderFrameHostManager::OnCrossSiteResponse(
     RenderViewHost* pending_render_view_host,
     const GlobalRequestID& global_request_id,
@@ -444,9 +422,9 @@ void RenderFrameHostManager::OnCrossSiteResponse(
     bool should_replace_current_entry) {
   // This should be called either when the pending RVH is ready to commit or
   // when we realize that the current RVH's request requires a transfer.
-  DCHECK(pending_render_view_host == render_frame_host_->render_view_host() ||
-         pending_render_view_host ==
-             pending_render_frame_host_->render_view_host());
+  DCHECK(
+      pending_render_view_host == pending_render_view_host_ ||
+      pending_render_view_host == render_view_host_);
 
   // TODO(creis): Eventually we will want to check all navigation responses
   // here, but currently we pass information for a transfer if
@@ -468,7 +446,7 @@ void RenderFrameHostManager::SwapOutOldPage() {
   // Tell the renderer to suppress any further modal dialogs so that we can swap
   // it out.  This must be done before canceling any current dialog, in case
   // there is a loop creating additional dialogs.
-  render_frame_host_->render_view_host()->SuppressDialogsUntilSwapOut();
+  render_view_host_->SuppressDialogsUntilSwapOut();
 
   // Now close any modal dialogs that would prevent us from swapping out.  This
   // must be done separately from SwapOut, so that the PageGroupLoadDeferrer is
@@ -480,18 +458,14 @@ void RenderFrameHostManager::SwapOutOldPage() {
   // unload handler finishes and the navigation completes, we will send a
   // message to the ResourceDispatcherHost, allowing the pending RVH's response
   // to resume.
-  // TODO(creis): We should do this on the RFH or else we'll swap out the
-  // top-level page when subframes navigate.
-  render_frame_host_->render_view_host()->SwapOut();
+  render_view_host_->SwapOut();
 
   // ResourceDispatcherHost has told us to run the onunload handler, which
   // means it is not a download or unsafe page, and we are going to perform the
   // navigation.  Thus, we no longer need to remember that the RenderViewHost
   // is part of a pending cross-site request.
-  if (pending_render_frame_host_) {
-    pending_render_frame_host_->render_view_host()->
-        SetHasPendingCrossSiteRequest(false);
-  }
+  if (pending_render_view_host_)
+    pending_render_view_host_->SetHasPendingCrossSiteRequest(false);
 }
 
 void RenderFrameHostManager::Observe(
@@ -510,17 +484,6 @@ void RenderFrameHostManager::Observe(
   }
 }
 
-bool RenderFrameHostManager::ClearSwappedOutRFHsInSiteInstance(
-    int32 site_instance_id,
-    FrameTreeNode* node) {
-  RenderFrameHostMap::iterator iter =
-      node->render_manager()->swapped_out_hosts_.find(site_instance_id);
-  if (iter != node->render_manager()->swapped_out_hosts_.end())
-    delete iter->second;
-
-  return true;
-}
-
 bool RenderFrameHostManager::ShouldTransitionCrossSite() {
   // False in the single-process mode, as it makes RVHs to accumulate
   // in swapped_out_hosts_.
@@ -553,7 +516,7 @@ bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation(
   const GURL& current_url = (current_entry) ?
       SiteInstanceImpl::GetEffectiveURL(browser_context,
                                         current_entry->GetURL()) :
-      render_frame_host_->render_view_host()->GetSiteInstance()->GetSiteURL();
+      render_view_host_->GetSiteInstance()->GetSiteURL();
   const GURL& new_url = SiteInstanceImpl::GetEffectiveURL(browser_context,
                                                           new_entry->GetURL());
 
@@ -578,8 +541,7 @@ bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation(
   // Check with the content client as well.  Important to pass current_url here,
   // which uses the SiteInstance's site if there is no current_entry.
   if (GetContentClient()->browser()->ShouldSwapBrowsingInstancesForNavigation(
-          render_frame_host_->render_view_host()->GetSiteInstance(),
-          current_url, new_url)) {
+          render_view_host_->GetSiteInstance(), current_url, new_url)) {
     return true;
   }
 
@@ -759,38 +721,7 @@ SiteInstance* RenderFrameHostManager::GetSiteInstanceForEntry(
   return current_instance->GetRelatedSiteInstance(dest_url);
 }
 
-RenderFrameHostImpl* RenderFrameHostManager::CreateRenderFrameHost(
-    SiteInstance* site_instance,
-    int view_routing_id,
-    int frame_routing_id,
-    bool swapped_out,
-    bool hidden) {
-  if (frame_routing_id == MSG_ROUTING_NONE)
-    frame_routing_id = site_instance->GetProcess()->GetNextRoutingID();
-
-  // Create a RVH for main frames, or find the existing one for subframes.
-  FrameTree* frame_tree = frame_tree_node_->frame_tree();
-  RenderViewHostImpl* render_view_host = NULL;
-  if (frame_tree_node_->IsMainFrame()) {
-    render_view_host = frame_tree->CreateRenderViewHostForMainFrame(
-        site_instance, view_routing_id, frame_routing_id, swapped_out, hidden);
-  } else {
-    render_view_host = frame_tree->GetRenderViewHostForSubFrame(site_instance);
-  }
-
-  // TODO(creis): Make render_frame_host a scoped_ptr.
-  // TODO(creis): Pass hidden to RFH.
-  RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostFactory::Create(render_view_host,
-                                     render_frame_delegate_,
-                                     frame_tree,
-                                     frame_tree_node_,
-                                     frame_routing_id,
-                                     swapped_out).release();
-  return render_frame_host;
-}
-
-int RenderFrameHostManager::CreateRenderFrame(
+int RenderFrameHostManager::CreateRenderView(
     SiteInstance* instance,
     int opener_route_id,
     bool swapped_out,
@@ -798,61 +729,59 @@ int RenderFrameHostManager::CreateRenderFrame(
   CHECK(instance);
   DCHECK(!swapped_out || hidden); // Swapped out views should always be hidden.
 
-  // We are creating a pending or swapped out RFH here.  We should never create
-  // it in the same SiteInstance as our current RFH.
-  CHECK_NE(render_frame_host_->render_view_host()->GetSiteInstance(), instance);
+  // We are creating a pending or swapped out RVH here.  We should never create
+  // it in the same SiteInstance as our current RVH.
+  CHECK_NE(render_view_host_->GetSiteInstance(), instance);
 
-  // Check if we've already created an RFH for this SiteInstance.  If so, try
+  // Check if we've already created an RVH for this SiteInstance.  If so, try
   // to re-use the existing one, which has already been initialized.  We'll
   // remove it from the list of swapped out hosts if it commits.
-  RenderFrameHostImpl* new_render_frame_host =
-      GetSwappedOutRenderFrameHost(instance);
-  if (new_render_frame_host) {
+  RenderViewHostImpl* new_render_view_host = static_cast<RenderViewHostImpl*>(
+      GetSwappedOutRenderViewHost(instance));
+  if (new_render_view_host) {
     // Prevent the process from exiting while we're trying to use it.
     if (!swapped_out)
-      new_render_frame_host->GetProcess()->AddPendingView();
+      new_render_view_host->GetProcess()->AddPendingView();
   } else {
-    // Create a new RenderFrameHost if we don't find an existing one.
-    // TODO(creis): Make new_render_frame_host a scoped_ptr.
-    new_render_frame_host = CreateRenderFrameHost(instance, MSG_ROUTING_NONE,
-                                                  MSG_ROUTING_NONE, swapped_out,
-                                                  hidden);
-
-    // If the new RFH is swapped out already, store it.  Otherwise prevent the
+    // Create a new RenderViewHost if we don't find an existing one.
+    new_render_view_host = static_cast<RenderViewHostImpl*>(
+        RenderViewHostFactory::Create(instance,
+                                      render_view_delegate_,
+                                      render_frame_delegate_,
+                                      render_widget_delegate_,
+                                      MSG_ROUTING_NONE,
+                                      MSG_ROUTING_NONE,
+                                      swapped_out,
+                                      hidden));
+
+    // If the new RVH is swapped out already, store it.  Otherwise prevent the
     // process from exiting while we're trying to navigate in it.
     if (swapped_out) {
-      swapped_out_hosts_[instance->GetId()] = new_render_frame_host;
+      swapped_out_hosts_[instance->GetId()] = new_render_view_host;
     } else {
-      new_render_frame_host->GetProcess()->AddPendingView();
+      new_render_view_host->GetProcess()->AddPendingView();
     }
 
-    RenderViewHostImpl* render_view_host =
-        new_render_frame_host->render_view_host();
-    bool success = InitRenderView(render_view_host, opener_route_id);
-    if (success && frame_tree_node_->IsMainFrame()) {
-      // Don't show the main frame's view until we get a DidNavigate from it.
-      render_view_host->GetView()->Hide();
+    bool success = InitRenderView(new_render_view_host, opener_route_id);
+    if (success) {
+      // Don't show the view until we get a DidNavigate from it.
+      new_render_view_host->GetView()->Hide();
     } else if (!swapped_out) {
       CancelPending();
     }
   }
 
-  // Use this as our new pending RFH if it isn't swapped out.
+  // Use this as our new pending RVH if it isn't swapped out.
   if (!swapped_out)
-    pending_render_frame_host_ = new_render_frame_host;
+    pending_render_view_host_ = new_render_view_host;
 
-  return new_render_frame_host->render_view_host()->GetRoutingID();
+  return new_render_view_host->GetRoutingID();
 }
 
 bool RenderFrameHostManager::InitRenderView(RenderViewHost* render_view_host,
                                             int opener_route_id) {
-  // We may have initialized this RenderViewHost for another RenderFrameHost.
-  if (render_view_host->IsRenderViewLive())
-    return true;
-
   // If the pending navigation is to a WebUI and the RenderView is not in a
-  // guest process, tell the RenderViewHost about any bindings it will need
-  // enabled.
+  // guest process, tell the RenderView about any bindings it will need enabled.
   if (pending_web_ui() && !render_view_host->GetProcess()->IsGuest()) {
     render_view_host->AllowBindings(pending_web_ui()->GetBindings());
   } else {
@@ -893,10 +822,10 @@ void RenderFrameHostManager::CommitPending() {
   else if (!pending_and_current_web_ui_.get())
     web_ui_.reset();
 
-  // It's possible for the pending_render_frame_host_ to be NULL when we aren't
+  // It's possible for the pending_render_view_host_ to be NULL when we aren't
   // crossing process boundaries. If so, we just needed to handle the Web UI
   // committing above and we're done.
-  if (!pending_render_frame_host_) {
+  if (!pending_render_view_host_) {
     if (will_focus_location_bar)
       delegate_->SetFocusToLocationBar(false);
     return;
@@ -905,110 +834,89 @@ void RenderFrameHostManager::CommitPending() {
   // Remember if the page was focused so we can focus the new renderer in
   // that case.
   bool focus_render_view = !will_focus_location_bar &&
-      render_frame_host_->render_view_host()->GetView() &&
-      render_frame_host_->render_view_host()->GetView()->HasFocus();
+      render_view_host_->GetView() && render_view_host_->GetView()->HasFocus();
 
-  // Swap in the pending frame and make it active. Also ensure the FrameTree
+  // Swap in the pending view and make it active. Also ensure the FrameTree
   // stays in sync.
-  RenderFrameHostImpl* old_render_frame_host = render_frame_host_;
-  render_frame_host_ = pending_render_frame_host_;
-  pending_render_frame_host_ = NULL;
-  render_frame_host_->render_view_host()->AttachToFrameTree();
+  RenderViewHostImpl* old_render_view_host = render_view_host_;
+  render_view_host_ = pending_render_view_host_;
+  pending_render_view_host_ = NULL;
+  render_view_host_->AttachToFrameTree();
 
   // The process will no longer try to exit, so we can decrement the count.
-  render_frame_host_->GetProcess()->RemovePendingView();
-
-  // TODO(creis): As long as show/hide are on RVH, we don't want to do them for
-  // subframe navigations or they'll interfere with the top-level page.
-  bool is_main_frame = frame_tree_node_->IsMainFrame();
+  render_view_host_->GetProcess()->RemovePendingView();
 
   // If the view is gone, then this RenderViewHost died while it was hidden.
   // We ignored the RenderProcessGone call at the time, so we should send it now
   // to make sure the sad tab shows up, etc.
-  if (!render_frame_host_->render_view_host()->GetView()) {
-    delegate_->RenderProcessGoneFromRenderManager(
-        render_frame_host_->render_view_host());
-  } else if (!delegate_->IsHidden() && is_main_frame) {
-    render_frame_host_->render_view_host()->GetView()->Show();
-  }
+  if (!render_view_host_->GetView())
+    delegate_->RenderProcessGoneFromRenderManager(render_view_host_);
+  else if (!delegate_->IsHidden())
+    render_view_host_->GetView()->Show();
 
   // Hide the old view now that the new one is visible.
-  if (old_render_frame_host->render_view_host()->GetView()) {
-    old_render_frame_host->render_view_host()->GetView()->Hide();
-    old_render_frame_host->render_view_host()->WasSwappedOut();
+  if (old_render_view_host->GetView()) {
+    old_render_view_host->GetView()->Hide();
+    old_render_view_host->WasSwappedOut();
   }
 
   // Make sure the size is up to date.  (Fix for bug 1079768.)
   delegate_->UpdateRenderViewSizeForRenderManager();
 
-  if (will_focus_location_bar) {
+  if (will_focus_location_bar)
     delegate_->SetFocusToLocationBar(false);
-  } else if (focus_render_view &&
-             render_frame_host_->render_view_host()->GetView()) {
-    RenderWidgetHostViewPort::FromRWHV(
-        render_frame_host_->render_view_host()->GetView())->Focus();
-  }
-
-  // Notify that we've swapped RenderFrameHosts. We do this before shutting down
-  // the RFH so that we can clean up RendererResources related to the RFH first.
-  // TODO(creis): Only do this on top-level RFHs for now, and later update it to
-  // pass the RFHs.
-  if (is_main_frame) {
-    delegate_->NotifySwappedFromRenderManager(
-        old_render_frame_host->render_view_host(),
-        render_frame_host_->render_view_host());
-  }
-
-  // If the pending frame was on the swapped out list, we can remove it.
-  swapped_out_hosts_.erase(render_frame_host_->render_view_host()->
-                               GetSiteInstance()->GetId());
-
-  if (old_render_frame_host->render_view_host()->IsRenderViewLive()) {
-    // If the old RFH is live, we are swapping it out and should keep track of
+  else if (focus_render_view && render_view_host_->GetView())
+    RenderWidgetHostViewPort::FromRWHV(render_view_host_->GetView())->Focus();
+
+  // Notify that we've swapped RenderViewHosts. We do this
+  // before shutting down the RVH so that we can clean up
+  // RendererResources related to the RVH first.
+  delegate_->NotifySwappedFromRenderManager(old_render_view_host,
+                                            render_view_host_);
+
+  // If the pending view was on the swapped out list, we can remove it.
+  swapped_out_hosts_.erase(render_view_host_->GetSiteInstance()->GetId());
+
+  // If there are no active RVHs in this SiteInstance, it means that
+  // this RVH was the last active one in the SiteInstance. Now that we
+  // know that all RVHs are swapped out, we can delete all the RVHs in
+  // this SiteInstance.
+  if (!static_cast<SiteInstanceImpl*>(old_render_view_host->GetSiteInstance())->
+          active_view_count()) {
+    ShutdownRenderViewHostsInSiteInstance(
+        old_render_view_host->GetSiteInstance()->GetId());
+    // This is deleted while cleaning up the SitaInstance's views.
+    old_render_view_host = NULL;
+  } else if (old_render_view_host->IsRenderViewLive()) {
+    // If the old RVH is live, we are swapping it out and should keep track of
     // it in case we navigate back to it.
-    DCHECK(old_render_frame_host->render_view_host()->is_swapped_out());
+    DCHECK(old_render_view_host->is_swapped_out());
     // Temp fix for http://crbug.com/90867 until we do a better cleanup to make
     // sure we don't get different rvh instances for the same site instance
     // in the same rvhmgr.
     // TODO(creis): Clean this up.
     int32 old_site_instance_id =
-        old_render_frame_host->render_view_host()->GetSiteInstance()->GetId();
-    RenderFrameHostMap::iterator iter =
+        old_render_view_host->GetSiteInstance()->GetId();
+    RenderViewHostMap::iterator iter =
         swapped_out_hosts_.find(old_site_instance_id);
     if (iter != swapped_out_hosts_.end() &&
-        iter->second != old_render_frame_host) {
-      // Delete the RFH that will be replaced in the map to avoid a leak.
-      delete iter->second;
-    }
-    swapped_out_hosts_[old_site_instance_id] = old_render_frame_host;
-
-    // If there are no active views in this SiteInstance, it means that
-    // this RFH was the last active one in the SiteInstance. Now that we
-    // know that all RFHs are swapped out, we can delete all the RFHs and RVHs
-    // in this SiteInstance.  We do this after ensuring the RFH is on the
-    // swapped out list to simplify the deletion.
-    if (!static_cast<SiteInstanceImpl*>(
-            old_render_frame_host->render_view_host()->GetSiteInstance())->
-                active_view_count()) {
-      ShutdownRenderFrameHostsInSiteInstance(old_site_instance_id);
-      // This is deleted while cleaning up the SiteInstance's views.
-      old_render_frame_host = NULL;
+        iter->second != old_render_view_host) {
+      // Shutdown the RVH that will be replaced in the map to avoid a leak.
+      iter->second->Shutdown();
     }
+    swapped_out_hosts_[old_site_instance_id] = old_render_view_host;
   } else {
-    delete old_render_frame_host;
+    old_render_view_host->Shutdown();
+    old_render_view_host = NULL;  // Shutdown() deletes it.
   }
 }
 
-void RenderFrameHostManager::ShutdownRenderFrameHostsInSiteInstance(
+void RenderFrameHostManager::ShutdownRenderViewHostsInSiteInstance(
     int32 site_instance_id) {
-  // First remove any swapped out RFH for this SiteInstance from our own list.
-  ClearSwappedOutRFHsInSiteInstance(site_instance_id, frame_tree_node_);
-
-  // Use the safe RenderWidgetHost iterator for now to find all RenderViewHosts
-  // in the SiteInstance, then tell their respective FrameTrees to remove all
-  // swapped out RenderFrameHosts corresponding to them.
-  // TODO(creis): Replace this with a RenderFrameHostIterator that protects
-  // against use-after-frees if a later element is deleted before getting to it.
+  // First remove any swapped out RVH for this SiteInstance from our
+  // list.
+  swapped_out_hosts_.erase(site_instance_id);
+
   scoped_ptr<RenderWidgetHostIterator> widgets(
       RenderWidgetHostImpl::GetAllRenderWidgetHosts());
   while (RenderWidgetHost* widget = widgets->GetNextHost()) {
@@ -1016,33 +924,25 @@ void RenderFrameHostManager::ShutdownRenderFrameHostsInSiteInstance(
       continue;
     RenderViewHostImpl* rvh =
         static_cast<RenderViewHostImpl*>(RenderViewHost::From(widget));
-    if (site_instance_id == rvh->GetSiteInstance()->GetId()) {
-      // This deletes all RenderFrameHosts using the |rvh|, which then causes
-      // |rvh| to Shutdown.
-      FrameTree* tree = rvh->GetDelegate()->GetFrameTree();
-      tree->ForEach(base::Bind(
-          &RenderFrameHostManager::ClearSwappedOutRFHsInSiteInstance,
-          site_instance_id));
-      // rvh is now deleted.
-    }
+    if (site_instance_id == rvh->GetSiteInstance()->GetId())
+      rvh->Shutdown();
   }
 }
 
-RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
+RenderViewHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     const NavigationEntryImpl& entry) {
   // If we are currently navigating cross-process, we want to get back to normal
   // and then navigate as usual.
   if (cross_navigation_pending_) {
-    if (pending_render_frame_host_)
+    if (pending_render_view_host_)
       CancelPending();
     cross_navigation_pending_ = false;
   }
 
-  // render_frame_host_'s SiteInstance and new_instance will not be deleted
+  // render_view_host_'s SiteInstance and new_instance will not be deleted
   // before the end of this method, so we don't have to worry about their ref
   // counts dropping to zero.
-  SiteInstance* current_instance =
-      render_frame_host_->render_view_host()->GetSiteInstance();
+  SiteInstance* current_instance = render_view_host_->GetSiteInstance();
   SiteInstance* new_instance = current_instance;
 
   // We do not currently swap processes for navigations in webview tag guests.
@@ -1050,7 +950,7 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
 
   // Determine if we need a new BrowsingInstance for this entry.  If true, this
   // implies that it will get a new SiteInstance (and likely process), and that
-  // other tabs in the current BrowsingInstance will be unable to script it.
+  // other tabs in the current BrosingInstance will be unalbe to script it.
   // This is used for cases that require a process swap even in the
   // process-per-tab model, such as WebUI pages.
   const NavigationEntry* current_entry =
@@ -1061,13 +961,13 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     new_instance = GetSiteInstanceForEntry(entry, current_instance, force_swap);
 
   // If force_swap is true, we must use a different SiteInstance.  If we didn't,
-  // we would have two RenderFrameHosts in the same SiteInstance and the same
-  // frame, resulting in page_id conflicts for their NavigationEntries.
+  // we would have two RenderViewHosts in the same SiteInstance and the same
+  // tab, resulting in page_id conflicts for their NavigationEntries.
   if (force_swap)
     CHECK_NE(new_instance, current_instance);
 
   if (new_instance != current_instance) {
-    // New SiteInstance: create a pending RFH to navigate.
+    // New SiteInstance: create a pending RVH to navigate.
     DCHECK(!cross_navigation_pending_);
 
     // This will possibly create (set to NULL) a Web UI object for the pending
@@ -1078,8 +978,8 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     // not have its bindings set appropriately.
     SetPendingWebUI(entry);
 
-    // Ensure that we have created RFHs for the new RFH's opener chain if
-    // we are staying in the same BrowsingInstance. This allows the pending RFH
+    // Ensure that we have created RVHs for the new RVH's opener chain if
+    // we are staying in the same BrowsingInstance. This allows the pending RVH
     // to send cross-process script calls to its opener(s).
     int opener_route_id = MSG_ROUTING_NONE;
     if (new_instance->IsRelatedSiteInstance(current_instance)) {
@@ -1087,26 +987,26 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
           delegate_->CreateOpenerRenderViewsForRenderManager(new_instance);
     }
 
-    // Create a non-swapped-out pending RFH with the given opener and navigate
+    // Create a non-swapped-out pending RVH with the given opener and navigate
     // it.
-    int route_id = CreateRenderFrame(new_instance, opener_route_id, false,
-                                     delegate_->IsHidden());
+    int route_id = CreateRenderView(new_instance, opener_route_id, false,
+                                    delegate_->IsHidden());
     if (route_id == MSG_ROUTING_NONE)
       return NULL;
 
-    // Check if our current RFH is live before we set up a transition.
-    if (!render_frame_host_->render_view_host()->IsRenderViewLive()) {
+    // Check if our current RVH is live before we set up a transition.
+    if (!render_view_host_->IsRenderViewLive()) {
       if (!cross_navigation_pending_) {
-        // The current RFH is not live.  There's no reason to sit around with a
-        // sad tab or a newly created RFH while we wait for the pending RFH to
-        // navigate.  Just switch to the pending RFH now and go back to non
+        // The current RVH is not live.  There's no reason to sit around with a
+        // sad tab or a newly created RVH while we wait for the pending RVH to
+        // navigate.  Just switch to the pending RVH now and go back to non
         // cross-navigating (Note that we don't care about on{before}unload
-        // handlers if the current RFH isn't live.)
+        // handlers if the current RVH isn't live.)
         CommitPending();
-        return render_frame_host_;
+        return render_view_host_;
       } else {
         NOTREACHED();
-        return render_frame_host_;
+        return render_view_host_;
       }
     }
     // Otherwise, it's safe to treat this as a pending cross-site transition.
@@ -1117,8 +1017,7 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     // Navigate message) until we hear back from the old renderer's
     // beforeunload handler.  If the handler returns false, we'll have to
     // cancel the request.
-    DCHECK(!pending_render_frame_host_->render_view_host()->
-               are_navigations_suspended());
+    DCHECK(!pending_render_view_host_->are_navigations_suspended());
     bool is_transfer =
         entry.transferred_global_request_id() != GlobalRequestID();
     if (is_transfer) {
@@ -1130,21 +1029,19 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
       // Also make sure the old render view stops, in case a load is in
       // progress.  (We don't want to do this for transfers, since it will
       // interrupt the transfer with an unexpected DidStopLoading.)
-      render_frame_host_->render_view_host()->Send(new ViewMsg_Stop(
-          render_frame_host_->render_view_host()->GetRoutingID()));
+      render_view_host_->Send(
+          new ViewMsg_Stop(render_view_host_->GetRoutingID()));
 
-      pending_render_frame_host_->render_view_host()->SetNavigationsSuspended(
-          true, base::TimeTicks());
+      pending_render_view_host_->SetNavigationsSuspended(true,
+                                                         base::TimeTicks());
 
       // Tell the CrossSiteRequestManager that this RVH has a pending cross-site
       // request, so that ResourceDispatcherHost will know to tell us to run the
       // old page's unload handler before it sends the response.
-      // TODO(creis): This needs to be on the RFH.
-      pending_render_frame_host_->render_view_host()->
-          SetHasPendingCrossSiteRequest(true);
+      pending_render_view_host_->SetHasPendingCrossSiteRequest(true);
     }
 
-    // We now have a pending RFH.
+    // We now have a pending RVH.
     DCHECK(!cross_navigation_pending_);
     cross_navigation_pending_ = true;
 
@@ -1153,12 +1050,12 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     // doesn't otherwise know that the cross-site request is happening.  This
     // will trigger a call to ShouldClosePage with the reply.
     if (!is_transfer)
-      render_frame_host_->render_view_host()->FirePageBeforeUnload(true);
+      render_view_host_->FirePageBeforeUnload(true);
 
-    return pending_render_frame_host_;
+    return pending_render_view_host_;
   }
 
-  // Otherwise the same SiteInstance can be used.  Navigate render_frame_host_.
+  // Otherwise the same SiteInstance can be used.  Navigate render_view_host_.
   DCHECK(!cross_navigation_pending_);
   if (ShouldReuseWebUI(current_entry, &entry)) {
     pending_web_ui_.reset();
@@ -1167,53 +1064,46 @@ RenderFrameHostImpl* RenderFrameHostManager::UpdateRendererStateForNavigate(
     SetPendingWebUI(entry);
 
     // Make sure the new RenderViewHost has the right bindings.
-    if (pending_web_ui() && !render_frame_host_->GetProcess()->IsGuest()) {
-      render_frame_host_->render_view_host()->AllowBindings(
-          pending_web_ui()->GetBindings());
-    }
+    if (pending_web_ui() && !render_view_host_->GetProcess()->IsGuest())
+      render_view_host_->AllowBindings(pending_web_ui()->GetBindings());
   }
 
-  if (pending_web_ui() &&
-      render_frame_host_->render_view_host()->IsRenderViewLive()) {
-    pending_web_ui()->GetController()->RenderViewReused(
-        render_frame_host_->render_view_host());
-  }
+  if (pending_web_ui() && render_view_host_->IsRenderViewLive())
+    pending_web_ui()->GetController()->RenderViewReused(render_view_host_);
 
   // The renderer can exit view source mode when any error or cancellation
   // happen. We must overwrite to recover the mode.
   if (entry.IsViewSourceMode()) {
-    render_frame_host_->render_view_host()->Send(
-        new ViewMsg_EnableViewSourceMode(
-            render_frame_host_->render_view_host()->GetRoutingID()));
+    render_view_host_->Send(
+        new ViewMsg_EnableViewSourceMode(render_view_host_->GetRoutingID()));
   }
 
-  return render_frame_host_;
+  return render_view_host_;
 }
 
 void RenderFrameHostManager::CancelPending() {
-  RenderFrameHostImpl* pending_render_frame_host = pending_render_frame_host_;
-  pending_render_frame_host_ = NULL;
+  RenderViewHostImpl* pending_render_view_host = pending_render_view_host_;
+  pending_render_view_host_ = NULL;
 
   RenderViewDevToolsAgentHost::OnCancelPendingNavigation(
-      pending_render_frame_host->render_view_host(),
-      render_frame_host_->render_view_host());
+      pending_render_view_host,
+      render_view_host_);
 
   // We no longer need to prevent the process from exiting.
-  pending_render_frame_host->GetProcess()->RemovePendingView();
+  pending_render_view_host->GetProcess()->RemovePendingView();
 
-  // The pending RFH may already be on the swapped out list if we started to
+  // The pending RVH may already be on the swapped out list if we started to
   // swap it back in and then canceled.  If so, make sure it gets swapped out
   // again.  If it's not on the swapped out list (e.g., aborting a pending
   // load), then it's safe to shut down.
-  if (IsOnSwappedOutList(pending_render_frame_host)) {
+  if (IsOnSwappedOutList(pending_render_view_host)) {
     // Any currently suspended navigations are no longer needed.
-    pending_render_frame_host->render_view_host()->CancelSuspendedNavigations();
+    pending_render_view_host->CancelSuspendedNavigations();
 
-    // TODO(creis): We need to swap out the RFH.
-    pending_render_frame_host->render_view_host()->SwapOut();
+    pending_render_view_host->SwapOut();
   } else {
     // We won't be coming back, so shut this one down.
-    delete pending_render_frame_host;
+    pending_render_view_host->Shutdown();
   }
 
   pending_web_ui_.reset();
@@ -1222,69 +1112,47 @@ void RenderFrameHostManager::CancelPending() {
 
 void RenderFrameHostManager::RenderViewDeleted(RenderViewHost* rvh) {
   // We are doing this in order to work around and to track a crasher
-  // (http://crbug.com/23411) where it seems that pending_render_frame_host_ is
+  // (http://crbug.com/23411) where it seems that pending_render_view_host_ is
   // deleted (not sure from where) but not NULLed.
-  if (pending_render_frame_host_ &&
-      rvh == pending_render_frame_host_->render_view_host()) {
+  if (rvh == pending_render_view_host_) {
     // If you hit this NOTREACHED, please report it in the following bug
     // http://crbug.com/23411 Make sure to include what you were doing when it
     // happened  (navigating to a new page, closing a tab...) and if you can
     // reproduce.
     NOTREACHED();
-    pending_render_frame_host_ = NULL;
+    pending_render_view_host_ = NULL;
   }
 
   // Make sure deleted RVHs are not kept in the swapped out list while we are
-  // still alive.  (If render_frame_host_ is null, we're already being deleted.)
-  if (!render_frame_host_)
+  // still alive.  (If render_view_host_ is null, we're already being deleted.)
+  if (!render_view_host_)
     return;
-
   // We can't look it up by SiteInstance ID, which may no longer be valid.
-  for (RenderFrameHostMap::iterator iter = swapped_out_hosts_.begin();
+  for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
-    if (iter->second->render_view_host() == rvh) {
+    if (iter->second == rvh) {
       swapped_out_hosts_.erase(iter);
       break;
     }
   }
 }
 
-bool RenderFrameHostManager::IsRVHOnSwappedOutList(
-    RenderViewHostImpl* rvh) const {
-  RenderFrameHostImpl* render_frame_host = GetSwappedOutRenderFrameHost(
-      rvh->GetSiteInstance());
-  if (!render_frame_host)
+bool RenderFrameHostManager::IsOnSwappedOutList(RenderViewHost* rvh) const {
+  if (!rvh->GetSiteInstance())
     return false;
-  return IsOnSwappedOutList(render_frame_host);
-}
 
-bool RenderFrameHostManager::IsOnSwappedOutList(
-    RenderFrameHostImpl* rfh) const {
-  if (!rfh->render_view_host()->GetSiteInstance())
-    return false;
-
-  RenderFrameHostMap::const_iterator iter = swapped_out_hosts_.find(
-      rfh->render_view_host()->GetSiteInstance()->GetId());
+  RenderViewHostMap::const_iterator iter = swapped_out_hosts_.find(
+      rvh->GetSiteInstance()->GetId());
   if (iter == swapped_out_hosts_.end())
     return false;
 
-  return iter->second == rfh;
+  return iter->second == rvh;
 }
 
 RenderViewHostImpl* RenderFrameHostManager::GetSwappedOutRenderViewHost(
-   SiteInstance* instance) const {
-  RenderFrameHostImpl* render_frame_host =
-      GetSwappedOutRenderFrameHost(instance);
-  if (render_frame_host)
-    return render_frame_host->render_view_host();
-  return NULL;
-}
-
-RenderFrameHostImpl* RenderFrameHostManager::GetSwappedOutRenderFrameHost(
-    SiteInstance* instance) const {
-  RenderFrameHostMap::const_iterator iter =
-      swapped_out_hosts_.find(instance->GetId());
+    SiteInstance* instance) {
+  RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end())
     return iter->second;
 
diff --git a/content/browser/frame_host/render_frame_host_manager.h b/content/browser/frame_host/render_frame_host_manager.h
index 0360bd0..94a4998 100644
--- a/content/browser/frame_host/render_frame_host_manager.h
+++ b/content/browser/frame_host/render_frame_host_manager.h
@@ -20,12 +20,10 @@
 namespace content {
 class BrowserContext;
 class InterstitialPageImpl;
-class FrameTreeNode;
 class NavigationControllerImpl;
 class NavigationEntry;
 class NavigationEntryImpl;
 class RenderFrameHostDelegate;
-class RenderFrameHostImpl;
 class RenderFrameHostManagerTest;
 class RenderViewHost;
 class RenderViewHostImpl;
@@ -116,7 +114,6 @@ class CONTENT_EXPORT RenderFrameHostManager
   //
   // You must call Init() before using this class.
   RenderFrameHostManager(
-      FrameTreeNode* frame_tree_node,
       RenderFrameHostDelegate* render_frame_delegate,
       RenderViewHostDelegate* render_view_delegate,
       RenderWidgetHostDelegate* render_widget_delegate,
@@ -126,31 +123,21 @@ class CONTENT_EXPORT RenderFrameHostManager
   // For arguments, see WebContentsImpl constructor.
   void Init(BrowserContext* browser_context,
             SiteInstance* site_instance,
-            int view_routing_id,
-            int frame_routing_id);
+            int routing_id,
+            int main_frame_routing_id);
 
-  // Returns the currently active RenderFrameHost.
+  // Returns the currently active RenderViewHost.
   //
   // This will be non-NULL between Init() and Shutdown(). You may want to NULL
   // check it in many cases, however. Windows can send us messages during the
   // destruction process after it has been shut down.
-  RenderFrameHostImpl* current_frame_host() const {
-    return render_frame_host_;
-  }
-
-  // TODO(creis): Remove this when we no longer use RVH for navigation.
   RenderViewHostImpl* current_host() const;
 
   // Returns the view associated with the current RenderViewHost, or NULL if
   // there is no current one.
   RenderWidgetHostView* GetRenderWidgetHostView() const;
 
-  // Returns the pending RenderFrameHost, or NULL if there is no pending one.
-  RenderFrameHostImpl* pending_frame_host() const {
-    return pending_render_frame_host_;
-  }
-
-  // TODO(creis): Remove this when we no longer use RVH for navigation.
+  // Returns the pending render view host, or NULL if there is no pending one.
   RenderViewHostImpl* pending_render_view_host() const;
 
   // Returns the current committed Web UI or NULL if none applies.
@@ -196,13 +183,13 @@ class CONTENT_EXPORT RenderFrameHostManager
   // Called when a renderer sets its opener to null.
   void DidDisownOpener(RenderViewHost* render_view_host);
 
-  // Helper method to create and initialize a RenderFrameHost.  If |swapped_out|
-  // is true, it will be initially placed on the swapped out hosts list.
-  // Otherwise, it will be used for a pending cross-site navigation.
-  int CreateRenderFrame(SiteInstance* instance,
-                        int opener_route_id,
-                        bool swapped_out,
-                        bool hidden);
+  // Helper method to create a RenderViewHost.  If |swapped_out| is true, it
+  // will be initially placed on the swapped out hosts list.  Otherwise, it
+  // will be used for a pending cross-site navigation.
+  int CreateRenderView(SiteInstance* instance,
+                       int opener_route_id,
+                       bool swapped_out,
+                       bool hidden);
 
   // Called when a provisional load on the given renderer is aborted.
   void RendererAbortedProvisionalLoad(RenderViewHost* render_view_host);
@@ -249,16 +236,12 @@ class CONTENT_EXPORT RenderFrameHostManager
   // Called when a RenderViewHost is about to be deleted.
   void RenderViewDeleted(RenderViewHost* rvh);
 
-  // Returns whether the given RenderFrameHost (or its associated
-  // RenderViewHost) is on the list of swapped out RenderFrameHosts.
-  bool IsRVHOnSwappedOutList(RenderViewHostImpl* rvh) const;
-  bool IsOnSwappedOutList(RenderFrameHostImpl* rfh) const;
+  // Returns whether the given RenderViewHost is on the list of swapped out
+  // RenderViewHosts.
+  bool IsOnSwappedOutList(RenderViewHost* rvh) const;
 
-  // Returns the swapped out RenderViewHost or RenderFrameHost for the given
-  // SiteInstance, if any.
-  RenderViewHostImpl* GetSwappedOutRenderViewHost(SiteInstance* instance) const;
-  RenderFrameHostImpl* GetSwappedOutRenderFrameHost(
-      SiteInstance* instance) const;
+  // Returns the swapped out RenderViewHost for the given SiteInstance, if any.
+  RenderViewHostImpl* GetSwappedOutRenderViewHost(SiteInstance* instance);
 
   // Runs the unload handler in the current page, when we know that a pending
   // cross-process navigation is going to commit.  We may initiate a transfer
@@ -270,7 +253,7 @@ class CONTENT_EXPORT RenderFrameHostManager
   friend class TestWebContents;
 
   // Tracks information about a navigation while a cross-process transition is
-  // in progress, in case we need to transfer it to a new RenderFrameHost.
+  // in progress, in case we need to transfer it to a new RenderViewHost.
   struct PendingNavigationParams {
     PendingNavigationParams();
     PendingNavigationParams(const GlobalRequestID& global_request_id,
@@ -312,11 +295,6 @@ class CONTENT_EXPORT RenderFrameHostManager
     bool should_replace_current_entry;
   };
 
-  // Used with FrameTree::ForEach to erase inactive RenderFrameHosts from a
-  // FrameTreeNode's RenderFrameHostManager.
-  static bool ClearSwappedOutRFHsInSiteInstance(int32 site_instance_id,
-                                                FrameTreeNode* node);
-
   // Returns whether this tab should transition to a new renderer for
   // cross-site URLs.  Enabled unless we see the --process-per-tab command line
   // switch.  Can be overridden in unit tests.
@@ -347,76 +325,60 @@ class CONTENT_EXPORT RenderFrameHostManager
       SiteInstance* current_instance,
       bool force_browsing_instance_swap);
 
-  // Creates a RenderFrameHost and corresponding RenderViewHost if necessary.
-  RenderFrameHostImpl* CreateRenderFrameHost(SiteInstance* instance,
-                                             int view_routing_id,
-                                             int frame_routing_id,
-                                             bool swapped_out,
-                                             bool hidden);
-
-  // Sets up the necessary state for a new RenderViewHost with the given opener,
-  // if necessary.  Returns early if the RenderViewHost has already been
-  // initialized for another RenderFrameHost.
-  // TODO(creis): opener_route_id is currently for the RenderViewHost but should
-  // be for the RenderFrame, since frames can have openers.
+  // Sets up the necessary state for a new RenderViewHost with the given opener.
   bool InitRenderView(RenderViewHost* render_view_host, int opener_route_id);
 
-  // Sets the pending RenderFrameHost/WebUI to be the active one. Note that this
-  // doesn't require the pending render_frame_host_ pointer to be non-NULL,
-  // since there could be Web UI switching as well. Call this for every commit.
+  // Sets the pending RenderViewHost/WebUI to be the active one. Note that this
+  // doesn't require the pending render_view_host_ pointer to be non-NULL, since
+  // there could be Web UI switching as well. Call this for every commit.
   void CommitPending();
 
-  // Shutdown all RenderFrameHosts in a SiteInstance. This is called to shutdown
-  // frames when all the frames in a SiteInstance are confirmed to be swapped
-  // out.
-  void ShutdownRenderFrameHostsInSiteInstance(int32 site_instance_id);
+  // Shutdown all RenderViewHosts in a SiteInstance. This is called
+  // to shutdown views when all the views in a SiteInstance are
+  // confirmed to be swapped out.
+  void ShutdownRenderViewHostsInSiteInstance(int32 site_instance_id);
 
   // Helper method to terminate the pending RenderViewHost.
   void CancelPending();
 
-  RenderFrameHostImpl* UpdateRendererStateForNavigate(
+  RenderViewHostImpl* UpdateRendererStateForNavigate(
       const NavigationEntryImpl& entry);
 
   // Called when a renderer process is starting to close.  We should not
-  // schedule new navigations in its swapped out RenderFrameHosts after this.
+  // schedule new navigations in its swapped out RenderViewHosts after this.
   void RendererProcessClosing(RenderProcessHost* render_process_host);
 
-  // For use in creating RenderFrameHosts.
-  FrameTreeNode* frame_tree_node_;
-
   // Our delegate, not owned by us. Guaranteed non-NULL.
   Delegate* delegate_;
 
-  // Whether a navigation requiring different RenderFrameHosts is pending. This
-  // is either for cross-site requests or when required for the process type
-  // (like WebUI).
+  // Whether a navigation requiring different RenderView's is pending. This is
+  // either cross-site request is (in the new process model), or when required
+  // for the view type (like view source versus not).
   bool cross_navigation_pending_;
 
-  // Implemented by the owner of this class.  These delegates are installed into
-  // all the RenderFrameHosts that we create.
+  // Implemented by the owner of this class, these delegates are installed into
+  // all the RenderViewHosts that we create.
   RenderFrameHostDelegate* render_frame_delegate_;
   RenderViewHostDelegate* render_view_delegate_;
   RenderWidgetHostDelegate* render_widget_delegate_;
 
-  // Our RenderFrameHost and its associated Web UI (if any, will be NULL for
-  // non-WebUI pages). This object is responsible for all communication with
-  // a child RenderFrame instance.
-  // For now, RenderFrameHost keeps a RenderViewHost in its SiteInstance alive.
-  // Eventually, RenderViewHost will be replaced with a page context.
-  RenderFrameHostImpl* render_frame_host_;
+  // Our RenderView host and its associated Web UI (if any, will be NULL for
+  // non-DOM-UI pages). This object is responsible for all communication with
+  // a child RenderView instance.
+  RenderViewHostImpl* render_view_host_;
   scoped_ptr<WebUIImpl> web_ui_;
 
-  // A RenderFrameHost used to load a cross-site page. This remains hidden
+  // A RenderViewHost used to load a cross-site page. This remains hidden
   // while a cross-site request is pending until it calls DidNavigate. It may
   // have an associated Web UI, in which case the Web UI pointer will be non-
   // NULL.
   //
   // The |pending_web_ui_| may be non-NULL even when the
-  // |pending_render_frame_host_| is NULL. This will happen when we're
-  // transitioning between two Web UI pages: the RFH won't be swapped, so the
+  // |pending_render_view_host_| is NULL. This will happen when we're
+  // transitioning between two Web UI pages: the RVH won't be swapped, so the
   // pending pointer will be unused, but there will be a pending Web UI
   // associated with the navigation.
-  RenderFrameHostImpl* pending_render_frame_host_;
+  RenderViewHostImpl* pending_render_view_host_;
 
   // Tracks information about any current pending cross-process navigation.
   scoped_ptr<PendingNavigationParams> pending_nav_params_;
@@ -428,10 +390,10 @@ class CONTENT_EXPORT RenderFrameHostManager
   scoped_ptr<WebUIImpl> pending_web_ui_;
   base::WeakPtr<WebUIImpl> pending_and_current_web_ui_;
 
-  // A map of site instance ID to swapped out RenderFrameHosts.  This may
-  // include pending_render_frame_host_ for navigations to existing entries.
-  typedef base::hash_map<int32, RenderFrameHostImpl*> RenderFrameHostMap;
-  RenderFrameHostMap swapped_out_hosts_;
+  // A map of site instance ID to swapped out RenderViewHosts.  This may include
+  // pending_render_view_host_ for navigations to existing entries.
+  typedef base::hash_map<int32, RenderViewHostImpl*> RenderViewHostMap;
+  RenderViewHostMap swapped_out_hosts_;
 
   // The intersitial page currently shown if any, not own by this class
   // (the InterstitialPage is self-owned, it deletes itself when hidden).
diff --git a/content/browser/frame_host/render_frame_host_manager_unittest.cc b/content/browser/frame_host/render_frame_host_manager_unittest.cc
index 630262c..2ba5fb8 100644
--- a/content/browser/frame_host/render_frame_host_manager_unittest.cc
+++ b/content/browser/frame_host/render_frame_host_manager_unittest.cc
@@ -567,24 +567,17 @@ TEST_F(RenderFrameHostManagerTest, Init) {
 
   scoped_ptr<TestWebContents> web_contents(
       TestWebContents::Create(browser_context(), instance));
-  FrameTree tree(web_contents->GetFrameTree()->root()->navigator(),
-                 web_contents.get(), web_contents.get(),
-                 web_contents.get(), web_contents.get());
-  RenderFrameHostManager* manager = tree.root()->render_manager();
-
-  manager->Init(browser_context(), instance, MSG_ROUTING_NONE,
-                MSG_ROUTING_NONE);
-
-  RenderViewHostImpl* rvh = manager->current_host();
-  RenderFrameHostImpl* rfh = manager->current_frame_host();
-  ASSERT_TRUE(rvh);
-  ASSERT_TRUE(rfh);
-  EXPECT_EQ(rvh, rfh->render_view_host());
-  EXPECT_EQ(instance, rvh->GetSiteInstance());
-  EXPECT_EQ(web_contents.get(), rvh->GetDelegate());
-  EXPECT_EQ(web_contents.get(), rfh->delegate());
-  EXPECT_TRUE(manager->GetRenderWidgetHostView());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  RenderFrameHostManager manager(web_contents.get(), web_contents.get(),
+                                 web_contents.get(), web_contents.get());
+
+  manager.Init(browser_context(), instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
+
+  RenderViewHost* host = manager.current_host();
+  ASSERT_TRUE(host);
+  EXPECT_EQ(instance, host->GetSiteInstance());
+  EXPECT_EQ(web_contents.get(), host->GetDelegate());
+  EXPECT_TRUE(manager.GetRenderWidgetHostView());
+  EXPECT_FALSE(manager.pending_render_view_host());
 }
 
 // Tests the Navigate function. We navigate three sites consecutively and check
@@ -600,13 +593,10 @@ TEST_F(RenderFrameHostManagerTest, Navigate) {
                           Source<WebContents>(web_contents.get()));
 
   // Create.
-  FrameTree tree(web_contents->GetFrameTree()->root()->navigator(),
-                 web_contents.get(), web_contents.get(),
-                 web_contents.get(), web_contents.get());
-  RenderFrameHostManager* manager = tree.root()->render_manager();
+  RenderFrameHostManager manager(web_contents.get(), web_contents.get(),
+                                 web_contents.get(), web_contents.get());
 
-  manager->Init(browser_context(), instance, MSG_ROUTING_NONE,
-                MSG_ROUTING_NONE);
+  manager.Init(browser_context(), instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
 
   RenderViewHost* host;
 
@@ -616,16 +606,16 @@ TEST_F(RenderFrameHostManagerTest, Navigate) {
       NULL /* instance */, -1 /* page_id */, kUrl1, Referrer(),
       base::string16() /* title */, PAGE_TRANSITION_TYPED,
       false /* is_renderer_init */);
-  host = manager->Navigate(entry1);
+  host = manager.Navigate(entry1);
 
   // The RenderViewHost created in Init will be reused.
-  EXPECT_TRUE(host == manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_TRUE(host == manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
+  manager.DidNavigateMainFrame(host);
   // Commit to SiteInstance should be delayed until RenderView commit.
-  EXPECT_TRUE(host == manager->current_host());
+  EXPECT_TRUE(host == manager.current_host());
   ASSERT_TRUE(host);
   EXPECT_FALSE(static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->
       HasSite());
@@ -638,15 +628,15 @@ TEST_F(RenderFrameHostManagerTest, Navigate) {
       Referrer(kUrl1, blink::WebReferrerPolicyDefault),
       base::string16() /* title */, PAGE_TRANSITION_LINK,
       true /* is_renderer_init */);
-  host = manager->Navigate(entry2);
+  host = manager.Navigate(entry2);
 
   // The RenderViewHost created in Init will be reused.
-  EXPECT_TRUE(host == manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_TRUE(host == manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
-  EXPECT_TRUE(host == manager->current_host());
+  manager.DidNavigateMainFrame(host);
+  EXPECT_TRUE(host == manager.current_host());
   ASSERT_TRUE(host);
   EXPECT_TRUE(static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->
       HasSite());
@@ -658,22 +648,22 @@ TEST_F(RenderFrameHostManagerTest, Navigate) {
       Referrer(kUrl2, blink::WebReferrerPolicyDefault),
       base::string16() /* title */, PAGE_TRANSITION_LINK,
       false /* is_renderer_init */);
-  host = manager->Navigate(entry3);
+  host = manager.Navigate(entry3);
 
   // A new RenderViewHost should be created.
-  EXPECT_TRUE(manager->pending_render_view_host());
-  ASSERT_EQ(host, manager->pending_render_view_host());
+  EXPECT_TRUE(manager.pending_render_view_host());
+  ASSERT_EQ(host, manager.pending_render_view_host());
 
   notifications.Reset();
 
   // Commit.
-  manager->DidNavigateMainFrame(manager->pending_render_view_host());
-  EXPECT_TRUE(host == manager->current_host());
+  manager.DidNavigateMainFrame(manager.pending_render_view_host());
+  EXPECT_TRUE(host == manager.current_host());
   ASSERT_TRUE(host);
   EXPECT_TRUE(static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->
       HasSite());
   // Check the pending RenderViewHost has been committed.
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // We should observe a notification.
   EXPECT_TRUE(
@@ -695,13 +685,10 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
                           Source<WebContents>(web_contents.get()));
 
   // Create.
-  FrameTree tree(web_contents->GetFrameTree()->root()->navigator(),
-                 web_contents.get(), web_contents.get(),
-                 web_contents.get(), web_contents.get());
-  RenderFrameHostManager* manager = tree.root()->render_manager();
+  RenderFrameHostManager manager(web_contents.get(), web_contents.get(),
+                                 web_contents.get(), web_contents.get());
 
-  manager->Init(browser_context(), instance, MSG_ROUTING_NONE,
-                MSG_ROUTING_NONE);
+  manager.Init(browser_context(), instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
 
   // 1) The first navigation. --------------------------
   const GURL kUrl1("http://www.google.com/");
@@ -709,11 +696,11 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
                              Referrer(), base::string16() /* title */,
                              PAGE_TRANSITION_TYPED,
                              false /* is_renderer_init */);
-  RenderViewHost* host = manager->Navigate(entry1);
+  RenderViewHost* host = manager.Navigate(entry1);
 
   // The RenderViewHost created in Init will be reused.
-  EXPECT_TRUE(host == manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_TRUE(host == manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // We should observe a notification.
   EXPECT_TRUE(
@@ -721,10 +708,10 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
   notifications.Reset();
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
+  manager.DidNavigateMainFrame(host);
 
   // Commit to SiteInstance should be delayed until RenderView commit.
-  EXPECT_TRUE(host == manager->current_host());
+  EXPECT_TRUE(host == manager.current_host());
   ASSERT_TRUE(host);
   EXPECT_FALSE(static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->
       HasSite());
@@ -737,12 +724,12 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
       base::string16() /* title */, PAGE_TRANSITION_TYPED,
       false /* is_renderer_init */);
   RenderViewHostImpl* host2 = static_cast<RenderViewHostImpl*>(
-      manager->Navigate(entry2));
+      manager.Navigate(entry2));
   int host2_process_id = host2->GetProcess()->GetID();
 
   // A new RenderViewHost should be created.
-  EXPECT_TRUE(manager->pending_render_view_host());
-  ASSERT_EQ(host2, manager->pending_render_view_host());
+  EXPECT_TRUE(manager.pending_render_view_host());
+  ASSERT_EQ(host2, manager.pending_render_view_host());
   EXPECT_NE(host2, host);
 
   // Check that the navigation is still suspended because the old RVH
@@ -769,15 +756,15 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
   // call of RenderFrameHostManager::SwapOutOldPage before
   // RenderFrameHostManager::DidNavigateMainFrame is called.
   // The RVH is not swapped out until the commit.
-  manager->SwapOutOldPage();
+  manager.SwapOutOldPage();
   EXPECT_TRUE(test_process_host->sink().GetUniqueMessageMatching(
       ViewMsg_SwapOut::ID));
   test_host->OnSwappedOut(false);
 
-  EXPECT_EQ(host, manager->current_host());
+  EXPECT_EQ(host, manager.current_host());
   EXPECT_FALSE(static_cast<RenderViewHostImpl*>(
-      manager->current_host())->is_swapped_out());
-  EXPECT_EQ(host2, manager->pending_render_view_host());
+      manager.current_host())->is_swapped_out());
+  EXPECT_EQ(host2, manager.pending_render_view_host());
   // There should be still no navigation messages being sent.
   EXPECT_FALSE(test_process_host2->sink().GetUniqueMessageMatching(
       ViewMsg_Navigate::ID));
@@ -789,11 +776,11 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
                              PAGE_TRANSITION_TYPED,
                              false /* is_renderer_init */);
   test_process_host->sink().ClearMessages();
-  RenderViewHost* host3 = manager->Navigate(entry3);
+  RenderViewHost* host3 = manager.Navigate(entry3);
 
   // A new RenderViewHost should be created. host2 is now deleted.
-  EXPECT_TRUE(manager->pending_render_view_host());
-  ASSERT_EQ(host3, manager->pending_render_view_host());
+  EXPECT_TRUE(manager.pending_render_view_host());
+  ASSERT_EQ(host3, manager.pending_render_view_host());
   EXPECT_NE(host3, host);
   EXPECT_NE(host3->GetProcess()->GetID(), host2_process_id);
 
@@ -802,9 +789,9 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
   // request.
   EXPECT_TRUE(static_cast<RenderViewHostImpl*>(
       host3)->are_navigations_suspended());
-  EXPECT_EQ(host, manager->current_host());
+  EXPECT_EQ(host, manager.current_host());
   EXPECT_FALSE(static_cast<RenderViewHostImpl*>(
-      manager->current_host())->is_swapped_out());
+      manager.current_host())->is_swapped_out());
 
   // Simulate a response to the second beforeunload request.
   EXPECT_TRUE(test_process_host->sink().GetUniqueMessageMatching(
@@ -815,19 +802,19 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyReNavigation) {
   // call of RenderFrameHostManager::SwapOutOldPage before
   // RenderFrameHostManager::DidNavigateMainFrame is called.
   // The RVH is not swapped out until the commit.
-  manager->SwapOutOldPage();
+  manager.SwapOutOldPage();
   EXPECT_TRUE(test_process_host->sink().GetUniqueMessageMatching(
       ViewMsg_SwapOut::ID));
   test_host->OnSwappedOut(false);
 
   // Commit.
-  manager->DidNavigateMainFrame(host3);
-  EXPECT_TRUE(host3 == manager->current_host());
+  manager.DidNavigateMainFrame(host3);
+  EXPECT_TRUE(host3 == manager.current_host());
   ASSERT_TRUE(host3);
   EXPECT_TRUE(static_cast<SiteInstanceImpl*>(host3->GetSiteInstance())->
       HasSite());
   // Check the pending RenderViewHost has been committed.
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // We should observe a notification.
   EXPECT_TRUE(
@@ -841,28 +828,25 @@ TEST_F(RenderFrameHostManagerTest, WebUI) {
 
   scoped_ptr<TestWebContents> web_contents(
       TestWebContents::Create(browser_context(), instance));
-  FrameTree tree(web_contents->GetFrameTree()->root()->navigator(),
-                 web_contents.get(), web_contents.get(),
-                 web_contents.get(), web_contents.get());
-  RenderFrameHostManager* manager = tree.root()->render_manager();
+  RenderFrameHostManager manager(web_contents.get(), web_contents.get(),
+                                 web_contents.get(), web_contents.get());
 
-  manager->Init(browser_context(), instance, MSG_ROUTING_NONE,
-                MSG_ROUTING_NONE);
-  EXPECT_FALSE(manager->current_host()->IsRenderViewLive());
+  manager.Init(browser_context(), instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
+  EXPECT_FALSE(manager.current_host()->IsRenderViewLive());
 
   const GURL kUrl("chrome://foo");
   NavigationEntryImpl entry(NULL /* instance */, -1 /* page_id */, kUrl,
                             Referrer(), base::string16() /* title */,
                             PAGE_TRANSITION_TYPED,
                             false /* is_renderer_init */);
-  RenderViewHost* host = manager->Navigate(entry);
+  RenderViewHost* host = manager.Navigate(entry);
 
   // We commit the pending RenderViewHost immediately because the previous
   // RenderViewHost was not live.  We test a case where it is live in
   // WebUIInNewTab.
   EXPECT_TRUE(host);
-  EXPECT_EQ(host, manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_EQ(host, manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // It's important that the site instance get set on the Web UI page as soon
   // as the navigation starts, rather than lazily after it commits, so we don't
@@ -874,11 +858,11 @@ TEST_F(RenderFrameHostManagerTest, WebUI) {
 
   // The Web UI is committed immediately because the RenderViewHost has not been
   // used yet. UpdateRendererStateForNavigate() took the short cut path.
-  EXPECT_FALSE(manager->pending_web_ui());
-  EXPECT_TRUE(manager->web_ui());
+  EXPECT_FALSE(manager.pending_web_ui());
+  EXPECT_TRUE(manager.web_ui());
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
+  manager.DidNavigateMainFrame(host);
   EXPECT_TRUE(host->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 }
 
@@ -891,14 +875,12 @@ TEST_F(RenderFrameHostManagerTest, WebUIInNewTab) {
   // Create a blank tab.
   scoped_ptr<TestWebContents> web_contents1(
       TestWebContents::Create(browser_context(), blank_instance));
-  FrameTree tree1(web_contents1->GetFrameTree()->root()->navigator(),
-                 web_contents1.get(), web_contents1.get(),
-                 web_contents1.get(), web_contents1.get());
-  RenderFrameHostManager* manager1 = tree1.root()->render_manager();
-  manager1->Init(
+  RenderFrameHostManager manager1(web_contents1.get(), web_contents1.get(),
+                                  web_contents1.get(), web_contents1.get());
+  manager1.Init(
       browser_context(), blank_instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
   // Test the case that new RVH is considered live.
-  manager1->current_host()->CreateRenderView(base::string16(), -1, -1);
+  manager1.current_host()->CreateRenderView(base::string16(), -1, -1);
 
   // Navigate to a WebUI page.
   const GURL kUrl1("chrome://foo");
@@ -906,46 +888,44 @@ TEST_F(RenderFrameHostManagerTest, WebUIInNewTab) {
                              Referrer(), base::string16() /* title */,
                              PAGE_TRANSITION_TYPED,
                              false /* is_renderer_init */);
-  RenderViewHost* host1 = manager1->Navigate(entry1);
+  RenderViewHost* host1 = manager1.Navigate(entry1);
 
   // We should have a pending navigation to the WebUI RenderViewHost.
   // It should already have bindings.
-  EXPECT_EQ(host1, manager1->pending_render_view_host());
-  EXPECT_NE(host1, manager1->current_host());
+  EXPECT_EQ(host1, manager1.pending_render_view_host());
+  EXPECT_NE(host1, manager1.current_host());
   EXPECT_TRUE(host1->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 
   // Commit and ensure we still have bindings.
-  manager1->DidNavigateMainFrame(host1);
+  manager1.DidNavigateMainFrame(host1);
   SiteInstance* webui_instance = host1->GetSiteInstance();
-  EXPECT_EQ(host1, manager1->current_host());
+  EXPECT_EQ(host1, manager1.current_host());
   EXPECT_TRUE(host1->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 
   // Now simulate clicking a link that opens in a new tab.
   scoped_ptr<TestWebContents> web_contents2(
       TestWebContents::Create(browser_context(), webui_instance));
-  FrameTree tree2(web_contents2->GetFrameTree()->root()->navigator(),
-                  web_contents2.get(), web_contents2.get(),
-                  web_contents2.get(), web_contents2.get());
-  RenderFrameHostManager* manager2 = tree2.root()->render_manager();
-  manager2->Init(
+  RenderFrameHostManager manager2(web_contents2.get(), web_contents2.get(),
+                                  web_contents2.get(), web_contents2.get());
+  manager2.Init(
       browser_context(), webui_instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
   // Make sure the new RVH is considered live.  This is usually done in
   // RenderWidgetHost::Init when opening a new tab from a link.
-  manager2->current_host()->CreateRenderView(base::string16(), -1, -1);
+  manager2.current_host()->CreateRenderView(base::string16(), -1, -1);
 
   const GURL kUrl2("chrome://foo/bar");
   NavigationEntryImpl entry2(NULL /* instance */, -1 /* page_id */, kUrl2,
                              Referrer(), base::string16() /* title */,
                              PAGE_TRANSITION_LINK,
                              true /* is_renderer_init */);
-  RenderViewHost* host2 = manager2->Navigate(entry2);
+  RenderViewHost* host2 = manager2.Navigate(entry2);
 
   // No cross-process transition happens because we are already in the right
   // SiteInstance.  We should grant bindings immediately.
-  EXPECT_EQ(host2, manager2->current_host());
+  EXPECT_EQ(host2, manager2.current_host());
   EXPECT_TRUE(host2->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 
-  manager2->DidNavigateMainFrame(host2);
+  manager2.DidNavigateMainFrame(host2);
 }
 
 // Tests that we don't end up in an inconsistent state if a page does a back and
@@ -1078,20 +1058,20 @@ TEST_F(RenderFrameHostManagerTest, CreateSwappedOutOpenerRVHs) {
                   rvh2->GetSiteInstance()));
 
   // Ensure rvh1 is placed on swapped out list of the current tab.
-  EXPECT_TRUE(manager->IsRVHOnSwappedOutList(rvh1));
+  EXPECT_TRUE(manager->IsOnSwappedOutList(rvh1));
   EXPECT_EQ(rvh1,
             manager->GetSwappedOutRenderViewHost(rvh1->GetSiteInstance()));
 
   // Ensure a swapped out RVH is created in the first opener tab.
   TestRenderViewHost* opener1_rvh = static_cast<TestRenderViewHost*>(
       opener1_manager->GetSwappedOutRenderViewHost(rvh2->GetSiteInstance()));
-  EXPECT_TRUE(opener1_manager->IsRVHOnSwappedOutList(opener1_rvh));
+  EXPECT_TRUE(opener1_manager->IsOnSwappedOutList(opener1_rvh));
   EXPECT_TRUE(opener1_rvh->is_swapped_out());
 
   // Ensure a swapped out RVH is created in the second opener tab.
   TestRenderViewHost* opener2_rvh = static_cast<TestRenderViewHost*>(
       opener2_manager->GetSwappedOutRenderViewHost(rvh2->GetSiteInstance()));
-  EXPECT_TRUE(opener2_manager->IsRVHOnSwappedOutList(opener2_rvh));
+  EXPECT_TRUE(opener2_manager->IsOnSwappedOutList(opener2_rvh));
   EXPECT_TRUE(opener2_rvh->is_swapped_out());
 
   // Navigate to a cross-BrowsingInstance URL.
@@ -1193,7 +1173,7 @@ TEST_F(RenderFrameHostManagerTest, EnableWebUIWithSwappedOutOpener) {
   // Ensure a swapped out RVH is created in the first opener tab.
   TestRenderViewHost* opener1_rvh = static_cast<TestRenderViewHost*>(
       opener1_manager->GetSwappedOutRenderViewHost(rvh2->GetSiteInstance()));
-  EXPECT_TRUE(opener1_manager->IsRVHOnSwappedOutList(opener1_rvh));
+  EXPECT_TRUE(opener1_manager->IsOnSwappedOutList(opener1_rvh));
   EXPECT_TRUE(opener1_rvh->is_swapped_out());
 
   // Ensure the new RVH has WebUI bindings.
@@ -1211,13 +1191,10 @@ TEST_F(RenderFrameHostManagerTest, NoSwapOnGuestNavigations) {
       TestWebContents::Create(browser_context(), instance));
 
   // Create.
-  FrameTree tree(web_contents->GetFrameTree()->root()->navigator(),
-                 web_contents.get(), web_contents.get(),
-                 web_contents.get(), web_contents.get());
-  RenderFrameHostManager* manager = tree.root()->render_manager();
+  RenderFrameHostManager manager(web_contents.get(), web_contents.get(),
+                                 web_contents.get(), web_contents.get());
 
-  manager->Init(browser_context(), instance, MSG_ROUTING_NONE,
-                MSG_ROUTING_NONE);
+  manager.Init(browser_context(), instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
 
   RenderViewHost* host;
 
@@ -1227,17 +1204,17 @@ TEST_F(RenderFrameHostManagerTest, NoSwapOnGuestNavigations) {
       NULL /* instance */, -1 /* page_id */, kUrl1, Referrer(),
       base::string16() /* title */, PAGE_TRANSITION_TYPED,
       false /* is_renderer_init */);
-  host = manager->Navigate(entry1);
+  host = manager.Navigate(entry1);
 
   // The RenderViewHost created in Init will be reused.
-  EXPECT_TRUE(host == manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
-  EXPECT_EQ(manager->current_host()->GetSiteInstance(), instance);
+  EXPECT_TRUE(host == manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
+  EXPECT_EQ(manager.current_host()->GetSiteInstance(), instance);
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
+  manager.DidNavigateMainFrame(host);
   // Commit to SiteInstance should be delayed until RenderView commit.
-  EXPECT_EQ(host, manager->current_host());
+  EXPECT_EQ(host, manager.current_host());
   ASSERT_TRUE(host);
   EXPECT_TRUE(static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->
       HasSite());
@@ -1250,15 +1227,15 @@ TEST_F(RenderFrameHostManagerTest, NoSwapOnGuestNavigations) {
       Referrer(kUrl1, blink::WebReferrerPolicyDefault),
       base::string16() /* title */, PAGE_TRANSITION_LINK,
       true /* is_renderer_init */);
-  host = manager->Navigate(entry2);
+  host = manager.Navigate(entry2);
 
   // The RenderViewHost created in Init will be reused.
-  EXPECT_EQ(host, manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_EQ(host, manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
-  EXPECT_EQ(host, manager->current_host());
+  manager.DidNavigateMainFrame(host);
+  EXPECT_EQ(host, manager.current_host());
   ASSERT_TRUE(host);
   EXPECT_EQ(static_cast<SiteInstanceImpl*>(host->GetSiteInstance()),
       instance);
@@ -1279,13 +1256,10 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyClose) {
                           Source<WebContents>(web_contents.get()));
 
   // Create.
-  FrameTree tree(web_contents->GetFrameTree()->root()->navigator(),
-                 web_contents.get(), web_contents.get(),
-                 web_contents.get(), web_contents.get());
-  RenderFrameHostManager* manager = tree.root()->render_manager();
+  RenderFrameHostManager manager(web_contents.get(), web_contents.get(),
+                                 web_contents.get(), web_contents.get());
 
-  manager->Init(browser_context(), instance, MSG_ROUTING_NONE,
-                MSG_ROUTING_NONE);
+  manager.Init(browser_context(), instance, MSG_ROUTING_NONE, MSG_ROUTING_NONE);
 
   // 1) The first navigation. --------------------------
   const GURL kUrl1("http://www.google.com/");
@@ -1293,11 +1267,11 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyClose) {
                              Referrer(), base::string16() /* title */,
                              PAGE_TRANSITION_TYPED,
                              false /* is_renderer_init */);
-  RenderViewHost* host = manager->Navigate(entry1);
+  RenderViewHost* host = manager.Navigate(entry1);
 
   // The RenderViewHost created in Init will be reused.
-  EXPECT_EQ(host, manager->current_host());
-  EXPECT_FALSE(manager->pending_render_view_host());
+  EXPECT_EQ(host, manager.current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
 
   // We should observe a notification.
   EXPECT_TRUE(
@@ -1305,10 +1279,10 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyClose) {
   notifications.Reset();
 
   // Commit.
-  manager->DidNavigateMainFrame(host);
+  manager.DidNavigateMainFrame(host);
 
   // Commit to SiteInstance should be delayed until RenderView commit.
-  EXPECT_EQ(host, manager->current_host());
+  EXPECT_EQ(host, manager.current_host());
   EXPECT_FALSE(static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->
       HasSite());
   static_cast<SiteInstanceImpl*>(host->GetSiteInstance())->SetSite(kUrl1);
@@ -1320,26 +1294,26 @@ TEST_F(RenderFrameHostManagerTest, NavigateWithEarlyClose) {
       base::string16() /* title */, PAGE_TRANSITION_TYPED,
       false /* is_renderer_init */);
   RenderViewHostImpl* host2 = static_cast<RenderViewHostImpl*>(
-      manager->Navigate(entry2));
+      manager.Navigate(entry2));
 
   // A new RenderViewHost should be created.
-  ASSERT_EQ(host2, manager->pending_render_view_host());
+  ASSERT_EQ(host2, manager.pending_render_view_host());
   EXPECT_NE(host2, host);
 
-  EXPECT_EQ(host, manager->current_host());
+  EXPECT_EQ(host, manager.current_host());
   EXPECT_FALSE(static_cast<RenderViewHostImpl*>(
-      manager->current_host())->is_swapped_out());
-  EXPECT_EQ(host2, manager->pending_render_view_host());
+      manager.current_host())->is_swapped_out());
+  EXPECT_EQ(host2, manager.pending_render_view_host());
 
   // 3) Close the tab. -------------------------
   notifications.ListenFor(NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
                           Source<RenderWidgetHost>(host2));
-  manager->ShouldClosePage(false, true, base::TimeTicks());
+  manager.ShouldClosePage(false, true, base::TimeTicks());
 
   EXPECT_TRUE(
       notifications.Check1AndReset(NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED));
-  EXPECT_FALSE(manager->pending_render_view_host());
-  EXPECT_EQ(host, manager->current_host());
+  EXPECT_FALSE(manager.pending_render_view_host());
+  EXPECT_EQ(host, manager.current_host());
 }
 
 }  // namespace content
diff --git a/content/browser/renderer_host/DEPS b/content/browser/renderer_host/DEPS
index 2696801..1d612c4 100644
--- a/content/browser/renderer_host/DEPS
+++ b/content/browser/renderer_host/DEPS
@@ -33,5 +33,7 @@ specific_include_rules = {
   # of RenderViewHost on the FrameTree.
   "render_view_host_impl\.(cc|h)": [
     "+content/browser/frame_host/frame_tree.h",
+    "+content/browser/frame_host/render_frame_host_factory.h",
+    "+content/browser/frame_host/render_frame_host_impl.h",
   ],
 }
diff --git a/content/browser/renderer_host/media/web_contents_video_capture_device_unittest.cc b/content/browser/renderer_host/media/web_contents_video_capture_device_unittest.cc
index 6abb183..db766cd 100644
--- a/content/browser/renderer_host/media/web_contents_video_capture_device_unittest.cc
+++ b/content/browser/renderer_host/media/web_contents_video_capture_device_unittest.cc
@@ -228,13 +228,14 @@ class CaptureTestRenderViewHost : public TestRenderViewHost {
  public:
   CaptureTestRenderViewHost(SiteInstance* instance,
                             RenderViewHostDelegate* delegate,
+                            RenderFrameHostDelegate* frame_delegate,
                             RenderWidgetHostDelegate* widget_delegate,
                             int routing_id,
                             int main_frame_routing_id,
                             bool swapped_out,
                             CaptureTestSourceController* controller)
-      : TestRenderViewHost(instance, delegate, widget_delegate, routing_id,
-                           main_frame_routing_id, swapped_out),
+      : TestRenderViewHost(instance, delegate, frame_delegate, widget_delegate,
+                           routing_id, main_frame_routing_id, swapped_out),
         controller_(controller) {
     // Override the default view installed by TestRenderViewHost; we need
     // our special subclass which has mocked-out tab capture support.
@@ -289,13 +290,15 @@ class CaptureTestRenderViewHostFactory : public RenderViewHostFactory {
   virtual RenderViewHost* CreateRenderViewHost(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
+      RenderFrameHostDelegate* frame_delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
       bool swapped_out) OVERRIDE {
-    return new CaptureTestRenderViewHost(instance, delegate, widget_delegate,
-                                         routing_id, main_frame_routing_id,
-                                         swapped_out, controller_);
+    return new CaptureTestRenderViewHost(instance, delegate, frame_delegate,
+                                         widget_delegate, routing_id,
+                                         main_frame_routing_id, swapped_out,
+                                         controller_);
   }
  private:
   CaptureTestSourceController* controller_;
diff --git a/content/browser/renderer_host/render_view_host_browsertest.cc b/content/browser/renderer_host/render_view_host_browsertest.cc
index 555852c..386ff52 100644
--- a/content/browser/renderer_host/render_view_host_browsertest.cc
+++ b/content/browser/renderer_host/render_view_host_browsertest.cc
@@ -6,7 +6,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
-#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
@@ -101,19 +100,19 @@ IN_PROC_BROWSER_TEST_F(RenderViewHostTest, BasicRenderFrameHost) {
   GURL test_url = embedded_test_server()->GetURL("/simple_page.html");
   NavigateToURL(shell(), test_url);
 
-  FrameTreeNode* old_root = static_cast<WebContentsImpl*>(
-      shell()->web_contents())->GetFrameTree()->root();
-  EXPECT_TRUE(old_root->current_frame_host());
+  RenderViewHostImpl* rvh = static_cast<RenderViewHostImpl*>(
+      shell()->web_contents()->GetRenderViewHost());
+  EXPECT_TRUE(rvh->main_render_frame_host());
 
   ShellAddedObserver new_shell_observer;
   EXPECT_TRUE(ExecuteScript(shell()->web_contents(), "window.open();"));
   Shell* new_shell = new_shell_observer.GetShell();
-  FrameTreeNode* new_root = static_cast<WebContentsImpl*>(
-      new_shell->web_contents())->GetFrameTree()->root();
+  RenderViewHostImpl* new_rvh = static_cast<RenderViewHostImpl*>(
+      new_shell->web_contents()->GetRenderViewHost());
 
-  EXPECT_TRUE(new_root->current_frame_host());
-  EXPECT_NE(old_root->current_frame_host()->routing_id(),
-            new_root->current_frame_host()->routing_id());
+  EXPECT_TRUE(new_rvh->main_render_frame_host());
+  EXPECT_NE(rvh->main_render_frame_host()->routing_id(),
+            new_rvh->main_render_frame_host()->routing_id());
 }
 
 }  // namespace content
diff --git a/content/browser/renderer_host/render_view_host_factory.cc b/content/browser/renderer_host/render_view_host_factory.cc
index 5cffd13..fe51c7e 100644
--- a/content/browser/renderer_host/render_view_host_factory.cc
+++ b/content/browser/renderer_host/render_view_host_factory.cc
@@ -16,17 +16,19 @@ RenderViewHostFactory* RenderViewHostFactory::factory_ = NULL;
 RenderViewHost* RenderViewHostFactory::Create(
     SiteInstance* instance,
     RenderViewHostDelegate* delegate,
+    RenderFrameHostDelegate* frame_delegate,
     RenderWidgetHostDelegate* widget_delegate,
     int routing_id,
     int main_frame_routing_id,
     bool swapped_out,
     bool hidden) {
   if (factory_) {
-    return factory_->CreateRenderViewHost(instance, delegate, widget_delegate,
-                                          routing_id, main_frame_routing_id,
-                                          swapped_out);
+    return factory_->CreateRenderViewHost(instance, delegate, frame_delegate,
+                                          widget_delegate, routing_id,
+                                          main_frame_routing_id, swapped_out);
   }
-  return new RenderViewHostImpl(instance, delegate, widget_delegate, routing_id,
+  return new RenderViewHostImpl(instance, delegate, frame_delegate,
+                                widget_delegate, routing_id,
                                 main_frame_routing_id, swapped_out, hidden);
 }
 
diff --git a/content/browser/renderer_host/render_view_host_factory.h b/content/browser/renderer_host/render_view_host_factory.h
index 734f61f..cf6a0f1 100644
--- a/content/browser/renderer_host/render_view_host_factory.h
+++ b/content/browser/renderer_host/render_view_host_factory.h
@@ -27,6 +27,7 @@ class RenderViewHostFactory {
   static RenderViewHost* Create(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
+      RenderFrameHostDelegate* frame_delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
@@ -47,6 +48,7 @@ class RenderViewHostFactory {
   virtual RenderViewHost* CreateRenderViewHost(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
+      RenderFrameHostDelegate* frame_delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
diff --git a/content/browser/renderer_host/render_view_host_impl.cc b/content/browser/renderer_host/render_view_host_impl.cc
index 6008f9d..491944e 100644
--- a/content/browser/renderer_host/render_view_host_impl.cc
+++ b/content/browser/renderer_host/render_view_host_impl.cc
@@ -27,6 +27,7 @@
 #include "content/browser/cross_site_request_manager.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/frame_host/frame_tree.h"
+#include "content/browser/frame_host/render_frame_host_factory.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host.h"
@@ -158,6 +159,7 @@ RenderViewHostImpl* RenderViewHostImpl::FromID(int render_process_id,
 RenderViewHostImpl::RenderViewHostImpl(
     SiteInstance* instance,
     RenderViewHostDelegate* delegate,
+    RenderFrameHostDelegate* frame_delegate,
     RenderWidgetHostDelegate* widget_delegate,
     int routing_id,
     int main_frame_routing_id,
@@ -176,7 +178,6 @@ RenderViewHostImpl::RenderViewHostImpl(
       is_swapped_out_(swapped_out),
       is_subframe_(false),
       main_frame_id_(-1),
-      main_frame_routing_id_(main_frame_routing_id),
       run_modal_reply_msg_(NULL),
       run_modal_opener_id_(MSG_ROUTING_NONE),
       is_waiting_for_beforeunload_ack_(false),
@@ -189,6 +190,16 @@ RenderViewHostImpl::RenderViewHostImpl(
   DCHECK(instance_.get());
   CHECK(delegate_);  // http://crbug.com/82827
 
+  if (main_frame_routing_id == MSG_ROUTING_NONE)
+    main_frame_routing_id = GetProcess()->GetNextRoutingID();
+
+  main_render_frame_host_ = RenderFrameHostFactory::Create(
+      this, frame_delegate, delegate_->GetFrameTree(),
+      delegate_->GetFrameTree()->root(),
+      main_frame_routing_id, is_swapped_out_);
+  delegate_->GetFrameTree()->root()->set_render_frame_host(
+      main_render_frame_host_.get(), false);
+
   GetProcess()->EnableSendQueue();
 
   if (!swapped_out)
@@ -268,7 +279,7 @@ bool RenderViewHostImpl::CreateRenderView(
       delegate_->GetRendererPrefs(GetProcess()->GetBrowserContext());
   params.web_preferences = delegate_->GetWebkitPrefs();
   params.view_id = GetRoutingID();
-  params.main_frame_routing_id = main_frame_routing_id_;
+  params.main_frame_routing_id = main_render_frame_host()->routing_id();
   params.surface_id = surface_id();
   params.session_storage_namespace_id =
       delegate_->GetSessionStorageNamespace(instance_)->id();
@@ -1279,6 +1290,7 @@ bool RenderViewHostImpl::OnMessageReceived(const IPC::Message& msg) {
 
 void RenderViewHostImpl::Init() {
   RenderWidgetHostImpl::Init();
+  main_render_frame_host()->Init();
 }
 
 void RenderViewHostImpl::Shutdown() {
@@ -1392,7 +1404,7 @@ void RenderViewHostImpl::OnRenderProcessGone(int status, int exit_code) {
   // TODO(creis): Once subframes can be in different processes, we'll need to
   // clear just the FrameTreeNodes affected by the crash (and their subtrees).
   main_frame_id_ = -1;
-  delegate_->GetFrameTree()->ResetForMainFrameSwap();
+  delegate_->GetFrameTree()->SwapMainFrame(main_render_frame_host_.get());
 
   // Our base class RenderWidgetHost needs to reset some stuff.
   RendererExited(render_view_termination_status_, exit_code);
@@ -2287,7 +2299,7 @@ bool RenderViewHostImpl::CanAccessFilesOfPageState(
 void RenderViewHostImpl::AttachToFrameTree() {
   FrameTree* frame_tree = delegate_->GetFrameTree();
 
-  frame_tree->ResetForMainFrameSwap();
+  frame_tree->SwapMainFrame(main_render_frame_host_.get());
   if (main_frame_id() != FrameTreeNode::kInvalidFrameId) {
     frame_tree->OnFirstNavigationAfterSwap(main_frame_id());
   }
diff --git a/content/browser/renderer_host/render_view_host_impl.h b/content/browser/renderer_host/render_view_host_impl.h
index d073763d..44851ee 100644
--- a/content/browser/renderer_host/render_view_host_impl.h
+++ b/content/browser/renderer_host/render_view_host_impl.h
@@ -13,6 +13,7 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/process/kill.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/common/accessibility_node_data.h"
@@ -60,6 +61,8 @@ namespace content {
 class BrowserMediaPlayerManager;
 class ChildProcessSecurityPolicyImpl;
 class PageState;
+class RenderFrameHostDelegate;
+class RenderFrameHostImpl;
 class RenderWidgetHostDelegate;
 class SessionStorageNamespace;
 class SessionStorageNamespaceImpl;
@@ -116,6 +119,7 @@ class CONTENT_EXPORT RenderViewHostImpl
   RenderViewHostImpl(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
+      RenderFrameHostDelegate* frame_delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
@@ -613,6 +617,12 @@ class CONTENT_EXPORT RenderViewHostImpl
   void OnShowPopup(const ViewHostMsg_ShowPopup_Params& params);
 #endif
 
+  // TODO(nasko): Remove this accessor once RenderFrameHost moves into the frame
+  // tree.
+  RenderFrameHostImpl* main_render_frame_host() const {
+    return main_render_frame_host_.get();
+  }
+
  private:
   friend class TestRenderViewHost;
   FRIEND_TEST_ALL_PREFIXES(RenderViewHostTest, BasicRenderFrameHost);
@@ -624,6 +634,16 @@ class CONTENT_EXPORT RenderViewHostImpl
 
   bool CanAccessFilesOfPageState(const PageState& state) const;
 
+  // All RenderViewHosts must have a RenderFrameHost for its main frame.
+  // Currently the RenderFrameHost is created in lock step on construction
+  // and a pointer to the main frame is given to the FrameTreeNode
+  // when the RenderViewHost commits (see AttachToFrameTree()).
+  //
+  // TODO(ajwong): Make this reference non-owning. The root FrameTreeNode of
+  // the FrameTree should be responsible for owning the main frame's
+  // RenderFrameHost.
+  scoped_ptr<RenderFrameHostImpl> main_render_frame_host_;
+
   // Our delegate, which wants to know about changes in the RenderView.
   RenderViewHostDelegate* delegate_;
 
@@ -669,12 +689,8 @@ class CONTENT_EXPORT RenderViewHostImpl
   // The frame id of the main (top level) frame. This value is set on the
   // initial navigation of a RenderView and reset when the RenderView's
   // process is terminated (in RenderProcessGone).
-  // TODO(creis): Remove this when we switch to routing IDs for frames.
   int64 main_frame_id_;
 
-  // Routing ID for the main frame's RenderFrameHost.
-  int main_frame_routing_id_;
-
   // If we were asked to RunModal, then this will hold the reply_msg that we
   // must return to the renderer to unblock it.
   IPC::Message* run_modal_reply_msg_;
diff --git a/content/browser/renderer_host/render_view_host_unittest.cc b/content/browser/renderer_host/render_view_host_unittest.cc
index 0b56d16..e81e67f 100644
--- a/content/browser/renderer_host/render_view_host_unittest.cc
+++ b/content/browser/renderer_host/render_view_host_unittest.cc
@@ -5,7 +5,6 @@
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/child_process_security_policy_impl.h"
-#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_view_host_delegate_view.h"
@@ -289,10 +288,10 @@ TEST_F(RenderViewHostTest, NavigationWithBadHistoryItemFiles) {
 }
 
 TEST_F(RenderViewHostTest, RoutingIdSane) {
-  RenderFrameHostImpl* root_rfh =
-      contents()->GetFrameTree()->root()->current_frame_host();
-  EXPECT_EQ(test_rvh()->GetProcess(), root_rfh->GetProcess());
-  EXPECT_NE(test_rvh()->GetRoutingID(), root_rfh->routing_id());
+  EXPECT_EQ(test_rvh()->GetProcess(),
+            test_rvh()->main_render_frame_host()->GetProcess());
+  EXPECT_NE(test_rvh()->GetRoutingID(),
+            test_rvh()->main_render_frame_host()->routing_id());
 }
 
 }  // namespace content
diff --git a/content/browser/web_contents/web_contents_impl.cc b/content/browser/web_contents/web_contents_impl.cc
index c9831cf..554c220 100644
--- a/content/browser/web_contents/web_contents_impl.cc
+++ b/content/browser/web_contents/web_contents_impl.cc
@@ -631,7 +631,7 @@ RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
 }
 
 RenderFrameHost* WebContentsImpl::GetMainFrame() {
-  return frame_tree_.root()->current_frame_host();
+  return frame_tree_.root()->render_frame_host();
 }
 
 RenderViewHost* WebContentsImpl::GetRenderViewHost() const {
@@ -3032,13 +3032,8 @@ void WebContentsImpl::UpdateState(RenderViewHost* rvh,
                                   const PageState& page_state) {
   // Ensure that this state update comes from either the active RVH or one of
   // the swapped out RVHs.  We don't expect to hear from any other RVHs.
-  // TODO(nasko): This should go through RenderFrameHost.
-  // TODO(creis): We can't update state for cross-process subframes until we
-  // have FrameNavigationEntries.  Once we do, this should be a DCHECK.
-  if (rvh != GetRenderViewHost() &&
-      !GetRenderManager()->IsRVHOnSwappedOutList(
-          static_cast<RenderViewHostImpl*>(rvh)))
-    return;
+  DCHECK(rvh == GetRenderViewHost() ||
+         GetRenderManager()->IsOnSwappedOutList(rvh));
 
   // We must be prepared to handle state updates for any page, these occur
   // when the user is scrolling and entering form data, as well as when we're
@@ -3465,8 +3460,8 @@ WebPreferences WebContentsImpl::GetWebkitPrefs() {
 
 int WebContentsImpl::CreateSwappedOutRenderView(
     SiteInstance* instance) {
-  return GetRenderManager()->CreateRenderFrame(instance, MSG_ROUTING_NONE,
-                                               true, true);
+  return GetRenderManager()->CreateRenderView(instance, MSG_ROUTING_NONE,
+                                              true, true);
 }
 
 void WebContentsImpl::OnUserGesture() {
@@ -3635,8 +3630,8 @@ int WebContentsImpl::CreateOpenerRenderViews(SiteInstance* instance) {
 
   // Create a swapped out RenderView in the given SiteInstance if none exists,
   // setting its opener to the given route_id.  Return the new view's route_id.
-  return GetRenderManager()->CreateRenderFrame(instance, opener_route_id,
-                                               true, true);
+  return GetRenderManager()->CreateRenderView(instance, opener_route_id,
+                                              true, true);
 }
 
 NavigationControllerImpl& WebContentsImpl::GetControllerForRenderManager() {
diff --git a/content/browser/web_contents/web_contents_impl_unittest.cc b/content/browser/web_contents/web_contents_impl_unittest.cc
index 421771b..1be4a3c 100644
--- a/content/browser/web_contents/web_contents_impl_unittest.cc
+++ b/content/browser/web_contents/web_contents_impl_unittest.cc
@@ -184,7 +184,7 @@ class TestInterstitialPage : public InterstitialPageImpl {
   virtual RenderViewHost* CreateRenderViewHost() OVERRIDE {
     return new TestRenderViewHost(
         SiteInstance::Create(web_contents()->GetBrowserContext()),
-        this, this, MSG_ROUTING_NONE, MSG_ROUTING_NONE, false);
+        this, this, this, MSG_ROUTING_NONE, MSG_ROUTING_NONE, false);
   }
 
   virtual WebContentsView* CreateWebContentsView() OVERRIDE {
@@ -429,8 +429,6 @@ TEST_F(WebContentsImplTest, NavigateToExcessivelyLongURL) {
 TEST_F(WebContentsImplTest, CrossSiteBoundaries) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
-  RenderFrameHostImpl* orig_rfh =
-      contents()->GetFrameTree()->root()->current_frame_host();
   int orig_rvh_delete_count = 0;
   orig_rvh->set_delete_counter(&orig_rvh_delete_count);
   SiteInstance* instance1 = contents()->GetSiteInstance();
@@ -463,8 +461,6 @@ TEST_F(WebContentsImplTest, CrossSiteBoundaries) {
       static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   int pending_rvh_delete_count = 0;
   pending_rvh->set_delete_counter(&pending_rvh_delete_count);
-  RenderFrameHostImpl* pending_rfh = contents()->GetFrameTree()->root()->
-      render_manager()->pending_frame_host();
 
   // Navigations should be suspended in pending_rvh until ShouldCloseACK.
   EXPECT_TRUE(pending_rvh->are_navigations_suspended());
@@ -488,9 +484,9 @@ TEST_F(WebContentsImplTest, CrossSiteBoundaries) {
   EXPECT_EQ(url2, contents()->GetVisibleURL());
   EXPECT_NE(instance1, instance2);
   EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
-  // We keep the original RFH around, swapped out.
+  // We keep the original RVH around, swapped out.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->IsOnSwappedOutList(
-      orig_rfh));
+      orig_rvh));
   EXPECT_EQ(orig_rvh_delete_count, 0);
 
   // Going back should switch SiteInstances again.  The first SiteInstance is
@@ -513,9 +509,9 @@ TEST_F(WebContentsImplTest, CrossSiteBoundaries) {
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(goback_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(instance1, contents()->GetSiteInstance());
-  // The pending RFH should now be swapped out, not deleted.
+  // The pending RVH should now be swapped out, not deleted.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->
-      IsOnSwappedOutList(pending_rfh));
+      IsOnSwappedOutList(pending_rvh));
   EXPECT_EQ(pending_rvh_delete_count, 0);
 
   // Close contents and ensure RVHs are deleted.
@@ -638,8 +634,6 @@ TEST_F(WebContentsImplTest, NavigateDoesNotUseUpSiteInstance) {
 
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
-  RenderFrameHostImpl* orig_rfh =
-      contents()->GetFrameTree()->root()->current_frame_host();
   int orig_rvh_delete_count = 0;
   orig_rvh->set_delete_counter(&orig_rvh_delete_count);
   SiteInstanceImpl* orig_instance =
@@ -710,9 +704,9 @@ TEST_F(WebContentsImplTest, NavigateDoesNotUseUpSiteInstance) {
   EXPECT_EQ(url2, contents()->GetVisibleURL());
   EXPECT_NE(new_instance, orig_instance);
   EXPECT_FALSE(contents()->GetPendingRenderViewHost());
-  // We keep the original RFH around, swapped out.
+  // We keep the original RVH around, swapped out.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->IsOnSwappedOutList(
-      orig_rfh));
+      orig_rvh));
   EXPECT_EQ(orig_rvh_delete_count, 0);
 
   // Close contents and ensure RVHs are deleted.
diff --git a/content/renderer/dom_serializer_browsertest.cc b/content/renderer/dom_serializer_browsertest.cc
index 738bcd9..16bd30f 100644
--- a/content/renderer/dom_serializer_browsertest.cc
+++ b/content/renderer/dom_serializer_browsertest.cc
@@ -51,13 +51,6 @@ using blink::WebURL;
 using blink::WebView;
 using blink::WebVector;
 
-namespace {
-
-// The first RenderFrame is routing ID 1, and the first RenderView is 2.
-const int kRenderViewRoutingId = 2;
-
-}
-
 namespace content {
 
 // Iterate recursively over sub-frames to find one with with a given url.
@@ -230,7 +223,7 @@ class DomSerializerTests : public ContentBrowserTest,
   RenderView* GetRenderView() {
     // We could have the test on the UI thread get the WebContent's routing ID,
     // but we know this will be the first RV so skip that and just hardcode it.
-    return RenderView::FromRoutingID(kRenderViewRoutingId);
+    return RenderView::FromRoutingID(1);
   }
 
   WebView* GetWebView() {
diff --git a/content/renderer/resource_fetcher_browsertest.cc b/content/renderer/resource_fetcher_browsertest.cc
index a1f1593..a9498cb 100644
--- a/content/renderer/resource_fetcher_browsertest.cc
+++ b/content/renderer/resource_fetcher_browsertest.cc
@@ -25,13 +25,6 @@ using blink::WebFrame;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 
-namespace {
-
-// The first RenderFrame is routing ID 1, and the first RenderView is 2.
-const int kRenderViewRoutingId = 2;
-
-}
-
 namespace content {
 
 static const int kMaxWaitTimeMs = 5000;
@@ -142,7 +135,7 @@ class ResourceFetcherTests : public ContentBrowserTest {
   RenderView* GetRenderView() {
     // We could have the test on the UI thread get the WebContent's routing ID,
     // but we know this will be the first RV so skip that and just hardcode it.
-    return RenderView::FromRoutingID(kRenderViewRoutingId);
+    return RenderView::FromRoutingID(1);
   }
 
   void ResourceFetcherDownloadOnRenderer(const GURL& url) {
diff --git a/content/test/test_render_frame_host.cc b/content/test/test_render_frame_host.cc
index e9a3bc8..57f8c0f 100644
--- a/content/test/test_render_frame_host.cc
+++ b/content/test/test_render_frame_host.cc
@@ -4,9 +4,6 @@
 
 #include "content/test/test_render_frame_host.h"
 
-#include "content/browser/frame_host/frame_tree.h"
-#include "content/test/test_render_view_host.h"
-
 namespace content {
 
 TestRenderFrameHost::TestRenderFrameHost(RenderViewHostImpl* render_view_host,
@@ -20,13 +17,7 @@ TestRenderFrameHost::TestRenderFrameHost(RenderViewHostImpl* render_view_host,
                           frame_tree,
                           frame_tree_node,
                           routing_id,
-                          is_swapped_out) {
-  // Allow TestRenderViewHosts to easily access their main frame RFH.
-  if (frame_tree_node == frame_tree->root()) {
-    static_cast<TestRenderViewHost*>(render_view_host)->
-        set_main_render_frame_host(this);
-  }
-}
+                          is_swapped_out) {}
 
 TestRenderFrameHost::~TestRenderFrameHost() {}
 
diff --git a/content/test/test_render_view_host.cc b/content/test/test_render_view_host.cc
index b71af68..f33b012 100644
--- a/content/test/test_render_view_host.cc
+++ b/content/test/test_render_view_host.cc
@@ -238,12 +238,14 @@ gfx::NativeViewId TestRenderWidgetHostView::GetParentForWindowlessPlugin()
 TestRenderViewHost::TestRenderViewHost(
     SiteInstance* instance,
     RenderViewHostDelegate* delegate,
+    RenderFrameHostDelegate* frame_delegate,
     RenderWidgetHostDelegate* widget_delegate,
     int routing_id,
     int main_frame_routing_id,
     bool swapped_out)
     : RenderViewHostImpl(instance,
                          delegate,
+                         frame_delegate,
                          widget_delegate,
                          routing_id,
                          main_frame_routing_id,
@@ -254,8 +256,7 @@ TestRenderViewHost::TestRenderViewHost(
       simulate_fetch_via_proxy_(false),
       simulate_history_list_was_cleared_(false),
       contents_mime_type_("text/html"),
-      opener_route_id_(MSG_ROUTING_NONE),
-      main_render_frame_host_(NULL) {
+      opener_route_id_(MSG_ROUTING_NONE) {
   // TestRenderWidgetHostView installs itself into this->view_ in its
   // constructor, and deletes itself when TestRenderWidgetHostView::Destroy() is
   // called.
diff --git a/content/test/test_render_view_host.h b/content/test/test_render_view_host.h
index 5014fca..2e9fbd5 100644
--- a/content/test/test_render_view_host.h
+++ b/content/test/test_render_view_host.h
@@ -35,7 +35,6 @@ class Rect;
 namespace content {
 
 class SiteInstance;
-class TestRenderFrameHost;
 class TestWebContents;
 
 // Utility function to initialize ViewHostMsg_NavigateParams_Params
@@ -235,6 +234,7 @@ class TestRenderViewHost
  public:
   TestRenderViewHost(SiteInstance* instance,
                      RenderViewHostDelegate* delegate,
+                     RenderFrameHostDelegate* frame_delegate,
                      RenderWidgetHostDelegate* widget_delegate,
                      int routing_id,
                      int main_frame_routing_id,
@@ -314,14 +314,6 @@ class TestRenderViewHost
   // The opener route id passed to CreateRenderView().
   int opener_route_id() const { return opener_route_id_; }
 
-  // TODO(creis): Remove the need for these methods.
-  TestRenderFrameHost* main_render_frame_host() const {
-    return main_render_frame_host_;
-  }
-  void set_main_render_frame_host(TestRenderFrameHost* rfh) {
-    main_render_frame_host_ = rfh;
-  }
-
   // RenderViewHost overrides --------------------------------------------------
 
   virtual bool CreateRenderView(const base::string16& frame_name,
@@ -367,8 +359,6 @@ class TestRenderViewHost
   // See opener_route_id() above.
   int opener_route_id_;
 
-  TestRenderFrameHost* main_render_frame_host_;
-
   DISALLOW_COPY_AND_ASSIGN(TestRenderViewHost);
 };
 
diff --git a/content/test/test_render_view_host_factory.cc b/content/test/test_render_view_host_factory.cc
index 8bfc697..6cd4e8a 100644
--- a/content/test/test_render_view_host_factory.cc
+++ b/content/test/test_render_view_host_factory.cc
@@ -29,13 +29,14 @@ void TestRenderViewHostFactory::set_render_process_host_factory(
 RenderViewHost* TestRenderViewHostFactory::CreateRenderViewHost(
     SiteInstance* instance,
     RenderViewHostDelegate* delegate,
+    RenderFrameHostDelegate* frame_delegate,
     RenderWidgetHostDelegate* widget_delegate,
     int routing_id,
     int main_frame_routing_id,
     bool swapped_out) {
   return new TestRenderViewHost(
-      instance, delegate, widget_delegate, routing_id, main_frame_routing_id,
-      swapped_out);
+      instance, delegate, frame_delegate, widget_delegate, routing_id,
+      main_frame_routing_id, swapped_out);
 }
 
 }  // namespace content
diff --git a/content/test/test_render_view_host_factory.h b/content/test/test_render_view_host_factory.h
index e93762f..df6a2d0 100644
--- a/content/test/test_render_view_host_factory.h
+++ b/content/test/test_render_view_host_factory.h
@@ -30,6 +30,7 @@ class TestRenderViewHostFactory : public RenderViewHostFactory {
   virtual RenderViewHost* CreateRenderViewHost(
       SiteInstance* instance,
       RenderViewHostDelegate* delegate,
+      RenderFrameHostDelegate* frame_delegate,
       RenderWidgetHostDelegate* widget_delegate,
       int routing_id,
       int main_frame_routing_id,
diff --git a/content/test/test_web_contents.cc b/content/test/test_web_contents.cc
index a94a2bc..a2a42e6 100644
--- a/content/test/test_web_contents.cc
+++ b/content/test/test_web_contents.cc
@@ -43,7 +43,7 @@ TestWebContents::~TestWebContents() {
 }
 
 RenderViewHost* TestWebContents::GetPendingRenderViewHost() const {
-  return GetRenderManager()->pending_render_view_host();
+  return GetRenderManager()->pending_render_view_host_;
 }
 
 TestRenderViewHost* TestWebContents::pending_test_rvh() const {