Remove swapped-out usage in --site-per-process.

content/browser/frame_host/render_frame_host_manager_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
@@ skipping 312 matching lines @@
     // state is being checked.
     RenderFrameHostDeletedObserver rfh_observer(old_rfh);
     RenderViewHostDeletedObserver rvh_observer(old_rfh->GetRenderViewHost());
     active_rfh->SendNavigate(max_page_id + 1, entry_id, true, url);
 
     // Make sure that we start to run the unload handler at the time of commit.
     bool expecting_rfh_shutdown = false;
     if (old_rfh != active_rfh && !rfh_observer.deleted()) {
       EXPECT_EQ(RenderFrameHostImpl::STATE_PENDING_SWAP_OUT,
                 old_rfh->rfh_state());
-      if (!old_rfh->GetSiteInstance()->active_frame_count()) {
+      if (!old_rfh->GetSiteInstance()->active_frame_count() ||
+          base::CommandLine::ForCurrentProcess()->HasSwitch(
+               switches::kSitePerProcess)) {
         expecting_rfh_shutdown = true;
         EXPECT_TRUE(
             old_rfh->frame_tree_node()->render_manager()->IsPendingDeletion(
                 old_rfh));
       }
     }
 
     // Simulate the swap out ACK coming from the pending renderer.  This should
     // either shut down the old RFH or leave it in a swapped out state.
     if (old_rfh != active_rfh) {
       old_rfh->OnSwappedOut();
       if (expecting_rfh_shutdown) {
         EXPECT_TRUE(rfh_observer.deleted());
-        EXPECT_TRUE(rvh_observer.deleted());
+        if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+              switches::kSitePerProcess)) {
+          EXPECT_TRUE(rvh_observer.deleted());
+        }
       } else {
         EXPECT_EQ(RenderFrameHostImpl::STATE_SWAPPED_OUT,
                   old_rfh->rfh_state());
       }
     }
     EXPECT_EQ(active_rfh, contents()->GetMainFrame());
     EXPECT_EQ(NULL, contents()->GetPendingMainFrame());
   }
 
   bool ShouldSwapProcesses(RenderFrameHostManager* manager,
@@ skipping 162 matching lines @@
 // for synchronous messages, which cannot be ignored without leaving the
 // renderer in a stuck state.  See http://crbug.com/93427.
 TEST_F(RenderFrameHostManagerTest, FilterMessagesWhileSwappedOut) {
   const GURL kChromeURL("chrome://foo");
   const GURL kDestUrl("http://www.google.com/");
   std::vector<FaviconURL> icons;
 
   // Navigate our first tab to a chrome url and then to the destination.
   NavigateActiveAndCommit(kChromeURL);
   TestRenderFrameHost* ntp_rfh = contents()->GetMainFrame();
+  TestRenderViewHost* ntp_rvh = ntp_rfh->GetRenderViewHost();
 
   // Send an update favicon message and make sure it works.
   {
     PluginFaviconMessageObserver observer(contents());
     EXPECT_TRUE(ntp_rfh->GetRenderViewHost()->OnMessageReceived(
                     ViewHostMsg_UpdateFaviconURL(
                         ntp_rfh->GetRenderViewHost()->GetRoutingID(), icons)));
     EXPECT_TRUE(observer.favicon_received());
   }
   // Create one more frame in the same SiteInstance where ntp_rfh
@@ skipping 12 matching lines @@
     PluginFaviconMessageObserver observer(contents());
     EXPECT_TRUE(
         dest_rfh->GetRenderViewHost()->OnMessageReceived(
             ViewHostMsg_UpdateFaviconURL(
                 dest_rfh->GetRenderViewHost()->GetRoutingID(), icons)));
     EXPECT_TRUE(observer.favicon_received());
   }
 
   // The old renderer, being slow, now updates the favicon. It should be
   // filtered out and not take effect.
-  EXPECT_TRUE(ntp_rfh->is_swapped_out());
   {
     PluginFaviconMessageObserver observer(contents());
     EXPECT_TRUE(
-        ntp_rfh->GetRenderViewHost()->OnMessageReceived(
+        ntp_rvh->OnMessageReceived(
             ViewHostMsg_UpdateFaviconURL(
                 dest_rfh->GetRenderViewHost()->GetRoutingID(), icons)));
     EXPECT_FALSE(observer.favicon_received());
   }
 
+  // In --site-per-process, the RenderFrameHost is deleted on cross-process
+  // navigation, so the rest of the test case doesn't apply.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    return;
+  }
+
 #if defined(ENABLE_PLUGINS)
   // The same logic should apply to RenderFrameHosts as well and routing through
   // swapped out RFH shouldn't be allowed. Use a PluginCrashObserver to check
   // if the IPC message is allowed through or not.
   {
     PluginFaviconMessageObserver observer(contents());
     EXPECT_TRUE(ntp_rfh->OnMessageReceived(
                     FrameHostMsg_PluginCrashed(
                         ntp_rfh->GetRoutingID(), base::FilePath(), 0)));
     EXPECT_FALSE(observer.plugin_crashed());
@@ skipping 84 matching lines @@
 }
 
 // Ensure that frames aren't added to the frame tree, if the message is coming
 // from a process different than the parent frame's current RenderFrameHost
 // process. Otherwise it is possible to have collisions of routing ids, as they
 // are scoped per process. See https://crbug.com/415059.
 TEST_F(RenderFrameHostManagerTest, DropCreateChildFrameWhileSwappedOut) {
   const GURL kUrl1("http://foo.com");
   const GURL kUrl2("http://www.google.com/");
 
+  // This test is invalid in --site-per-process mode, as swapped-out is no
+  // longer used.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    return;
+  }
+
   // Navigate to the first site.
   NavigateActiveAndCommit(kUrl1);
   TestRenderFrameHost* initial_rfh = contents()->GetMainFrame();
   {
     RenderFrameHostCreatedObserver observer(contents());
     initial_rfh->OnCreateChildFrame(
         initial_rfh->GetProcess()->GetNextRoutingID(),
         blink::WebTreeScopeType::Document, std::string(),
         blink::WebSandboxFlags::None);
     EXPECT_TRUE(observer.created());
@@ skipping 18 matching lines @@
     RenderFrameHostCreatedObserver observer(contents());
     initial_rfh->OnCreateChildFrame(
         initial_rfh->GetProcess()->GetNextRoutingID(),
         blink::WebTreeScopeType::Document, std::string(),
         blink::WebSandboxFlags::None);
     EXPECT_FALSE(observer.created());
   }
 }
 
 TEST_F(RenderFrameHostManagerTest, WhiteListSwapCompositorFrame) {
+  // TODO(nasko): Check with kenrb whether this test can be rewritten and
+  // whether it makes sense when swapped out is replaced with proxies.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    return;
+  }
   TestRenderFrameHost* swapped_out_rfh = CreateSwappedOutRenderFrameHost();
   TestRenderWidgetHostView* swapped_out_rwhv =
       static_cast<TestRenderWidgetHostView*>(
           swapped_out_rfh->GetRenderViewHost()->GetView());
   EXPECT_FALSE(swapped_out_rwhv->did_swap_compositor_frame());
 
   MockRenderProcessHost* process_host = swapped_out_rfh->GetProcess();
   process_host->sink().ClearMessages();
 
   cc::CompositorFrame frame;
   ViewHostMsg_SwapCompositorFrame msg(
       rvh()->GetRoutingID(), 0, frame, std::vector<IPC::Message>());
 
   EXPECT_TRUE(swapped_out_rfh->render_view_host()->OnMessageReceived(msg));
   EXPECT_TRUE(swapped_out_rwhv->did_swap_compositor_frame());
 }
 
 // Test if RenderViewHost::GetRenderWidgetHosts() only returns active
 // widgets.
 TEST_F(RenderFrameHostManagerTest, GetRenderWidgetHostsReturnsActiveViews) {
+  // This test is invalid in --site-per-process mode, as swapped-out is no
+  // longer used.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    return;
+  }
+
   TestRenderFrameHost* swapped_out_rfh = CreateSwappedOutRenderFrameHost();
   EXPECT_TRUE(swapped_out_rfh->is_swapped_out());
 
   scoped_ptr<RenderWidgetHostIterator> widgets(
       RenderWidgetHost::GetRenderWidgetHosts());
   // We know that there is the only one active widget. Another view is
   // now swapped out, so the swapped out view is not included in the
   // list.
   RenderWidgetHost* widget = widgets->GetNextHost();
   EXPECT_FALSE(widgets->GetNextHost());
   RenderViewHost* rvh = RenderViewHost::From(widget);
   EXPECT_TRUE(static_cast<RenderViewHostImpl*>(rvh)->is_active());
 }
 
 // Test if RenderViewHost::GetRenderWidgetHosts() returns a subset of
 // RenderViewHostImpl::GetAllRenderWidgetHosts().
 // RenderViewHost::GetRenderWidgetHosts() returns only active widgets, but
 // RenderViewHostImpl::GetAllRenderWidgetHosts() returns everything
 // including swapped out ones.
 TEST_F(RenderFrameHostManagerTest,
        GetRenderWidgetHostsWithinGetAllRenderWidgetHosts) {
+  // This test is invalid in --site-per-process mode, as swapped-out is no
+  // longer used.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    return;
+  }
+
   TestRenderFrameHost* swapped_out_rfh = CreateSwappedOutRenderFrameHost();
   EXPECT_TRUE(swapped_out_rfh->is_swapped_out());
 
   scoped_ptr<RenderWidgetHostIterator> widgets(
       RenderWidgetHost::GetRenderWidgetHosts());
 
   while (RenderWidgetHost* w = widgets->GetNextHost()) {
     bool found = false;
     scoped_ptr<RenderWidgetHostIterator> all_widgets(
         RenderWidgetHostImpl::GetAllRenderWidgetHosts());
@@ skipping 337 matching lines @@
   SiteInstance* blank_instance = SiteInstance::Create(browser_context());
   blank_instance->GetProcess()->Init();
 
   // Create a blank tab.
   scoped_ptr<TestWebContents> web_contents1(
       TestWebContents::Create(browser_context(), blank_instance));
   RenderFrameHostManager* manager1 =
       web_contents1->GetRenderManagerForTesting();
   // Test the case that new RVH is considered live.
   manager1->current_host()->CreateRenderView(
-      base::string16(), -1, MSG_ROUTING_NONE, -1, false);
+      base::string16(), -1, MSG_ROUTING_NONE, -1,
+      FrameReplicationState(), false);
   EXPECT_TRUE(manager1->current_host()->IsRenderViewLive());
   EXPECT_TRUE(manager1->current_frame_host()->IsRenderFrameLive());
 
   // Navigate to a WebUI page.
   const GURL kUrl1("chrome://foo");
   NavigationEntryImpl entry1(NULL /* instance */, -1 /* page_id */, kUrl1,
                              Referrer(), base::string16() /* title */,
                              ui::PAGE_TRANSITION_TYPED,
                              false /* is_renderer_init */);
   RenderFrameHostImpl* host1 = NavigateToEntry(manager1, entry1);
@@ skipping 13 matching lines @@
       host1->render_view_host()->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));
   RenderFrameHostManager* manager2 =
       web_contents2->GetRenderManagerForTesting();
   // 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, MSG_ROUTING_NONE, -1, false);
+      base::string16(), -1, MSG_ROUTING_NONE, -1,
+      FrameReplicationState(), false);
   EXPECT_TRUE(manager2->current_host()->IsRenderViewLive());
 
   const GURL kUrl2("chrome://foo/bar");
   NavigationEntryImpl entry2(NULL /* instance */, -1 /* page_id */, kUrl2,
                              Referrer(), base::string16() /* title */,
                              ui::PAGE_TRANSITION_LINK,
                              true /* is_renderer_init */);
   RenderFrameHostImpl* host2 = NavigateToEntry(manager2, entry2);
 
   // No cross-process transition happens because we are already in the right
@@ skipping 149 matching lines @@
   // Now go back, but suppose the SwapOut_ACK isn't received.  This shouldn't
   // happen, but we have seen it when going back quickly across many entries
   // (http://crbug.com/93427).
   contents()->GetController().GoBack();
   EXPECT_TRUE(rfh2->IsWaitingForBeforeUnloadACK());
   contents()->GetMainFrame()->PrepareForCommit();
   EXPECT_FALSE(rfh2->IsWaitingForBeforeUnloadACK());
 
   // The back navigation commits.
   const NavigationEntry* entry1 = contents()->GetController().GetPendingEntry();
-  rfh1->SendNavigate(entry1->GetPageID(), entry1->GetUniqueID(), false,
-                     entry1->GetURL());
+  contents()->GetPendingMainFrame()->SendNavigate(
+      entry1->GetPageID(), entry1->GetUniqueID(), false, entry1->GetURL());
   EXPECT_TRUE(rfh2->IsWaitingForUnloadACK());
   EXPECT_EQ(RenderFrameHostImpl::STATE_PENDING_SWAP_OUT, rfh2->rfh_state());
 
   // We should be able to navigate forward.
   contents()->GetController().GoForward();
   contents()->GetMainFrame()->PrepareForCommit();
   const NavigationEntry* entry2 = contents()->GetController().GetPendingEntry();
-  rfh2->SendNavigate(entry2->GetPageID(), entry2->GetUniqueID(), false,
-                     entry2->GetURL());
-  EXPECT_EQ(rfh2, main_test_rfh());
-  EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh2->rfh_state());
-  EXPECT_EQ(RenderFrameHostImpl::STATE_PENDING_SWAP_OUT, rfh1->rfh_state());
-  rfh1->OnSwappedOut();
-  EXPECT_TRUE(rfh1->is_swapped_out());
-  EXPECT_EQ(RenderFrameHostImpl::STATE_SWAPPED_OUT, rfh1->rfh_state());
+  contents()->GetPendingMainFrame()->SendNavigate(
+      entry2->GetPageID(), entry2->GetUniqueID(), false, entry2->GetURL());
+  EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, main_test_rfh()->rfh_state());
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    EXPECT_EQ(rfh2, main_test_rfh());
+    EXPECT_EQ(RenderFrameHostImpl::STATE_PENDING_SWAP_OUT, rfh1->rfh_state());
+    rfh1->OnSwappedOut();
+    EXPECT_TRUE(rfh1->is_swapped_out());
+    EXPECT_EQ(RenderFrameHostImpl::STATE_SWAPPED_OUT, rfh1->rfh_state());
+  }
 }
 
 // Test that we create swapped out RFHs for the opener chain when navigating an
 // opened tab cross-process.  This allows us to support certain cross-process
 // JavaScript calls (http://crbug.com/99202).
 TEST_F(RenderFrameHostManagerTest, CreateSwappedOutOpenerRFHs) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
   const GURL kChromeUrl("chrome://foo");
+  bool is_site_per_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSitePerProcess);
 
   // Navigate to an initial URL.
   contents()->NavigateAndCommit(kUrl1);
   RenderFrameHostManager* manager = contents()->GetRenderManagerForTesting();
   TestRenderFrameHost* rfh1 = main_test_rfh();
+  scoped_refptr<SiteInstanceImpl> site_instance1 = rfh1->GetSiteInstance();
+  RenderFrameHostDeletedObserver rfh1_deleted_observer(rfh1);
   TestRenderViewHost* rvh1 = test_rvh();
 
   // Create 2 new tabs and simulate them being the opener chain for the main
   // tab.  They should be in the same SiteInstance.
   scoped_ptr<TestWebContents> opener1(
-      TestWebContents::Create(browser_context(), rfh1->GetSiteInstance()));
+      TestWebContents::Create(browser_context(), site_instance1.get()));
   RenderFrameHostManager* opener1_manager =
       opener1->GetRenderManagerForTesting();
   contents()->SetOpener(opener1.get());
 
   scoped_ptr<TestWebContents> opener2(
-      TestWebContents::Create(browser_context(), rfh1->GetSiteInstance()));
+      TestWebContents::Create(browser_context(), site_instance1.get()));
   RenderFrameHostManager* opener2_manager =
       opener2->GetRenderManagerForTesting();
   opener1->SetOpener(opener2.get());
 
   // Navigate to a cross-site URL (different SiteInstance but same
   // BrowsingInstance).
   contents()->NavigateAndCommit(kUrl2);
   TestRenderFrameHost* rfh2 = main_test_rfh();
   TestRenderViewHost* rvh2 = test_rvh();
-  EXPECT_NE(rfh1->GetSiteInstance(), rfh2->GetSiteInstance());
-  EXPECT_TRUE(rfh1->GetSiteInstance()->IsRelatedSiteInstance(
-                  rfh2->GetSiteInstance()));
+  EXPECT_NE(site_instance1, rfh2->GetSiteInstance());
+  EXPECT_TRUE(site_instance1->IsRelatedSiteInstance(rfh2->GetSiteInstance()));
 
   // Ensure rvh1 is placed on swapped out list of the current tab.
-  EXPECT_TRUE(manager->IsOnSwappedOutList(rfh1));
-  EXPECT_TRUE(manager->IsRVHOnSwappedOutList(rvh1));
-  EXPECT_EQ(rfh1,
-            manager->GetRenderFrameProxyHost(rfh1->GetSiteInstance())
-                ->render_frame_host());
+  if (!is_site_per_process) {
+    EXPECT_TRUE(manager->IsRVHOnSwappedOutList(rvh1));
+    EXPECT_FALSE(rfh1_deleted_observer.deleted());
+    EXPECT_TRUE(manager->IsOnSwappedOutList(rfh1));
+    EXPECT_EQ(rfh1,
+              manager->GetRenderFrameProxyHost(site_instance1.get())
+                  ->render_frame_host());
+  } else {
+    EXPECT_TRUE(rfh1_deleted_observer.deleted());
+    EXPECT_TRUE(manager->GetRenderFrameProxyHost(site_instance1.get()));
+  }
   EXPECT_EQ(rvh1,
             manager->GetSwappedOutRenderViewHost(rvh1->GetSiteInstance()));
 
   // Ensure a swapped out RFH and RFH is created in the first opener tab.
   RenderFrameProxyHost* opener1_proxy =
       opener1_manager->GetRenderFrameProxyHost(rfh2->GetSiteInstance());
   RenderFrameHostImpl* opener1_rfh = opener1_proxy->render_frame_host();
   TestRenderViewHost* opener1_rvh = static_cast<TestRenderViewHost*>(
       opener1_manager->GetSwappedOutRenderViewHost(rvh2->GetSiteInstance()));
-  EXPECT_TRUE(opener1_manager->IsOnSwappedOutList(opener1_rfh));
-  EXPECT_TRUE(opener1_manager->IsRVHOnSwappedOutList(opener1_rvh));
-  EXPECT_TRUE(opener1_rfh->is_swapped_out());
+  if (!is_site_per_process) {
+    EXPECT_TRUE(opener1_manager->IsOnSwappedOutList(opener1_rfh));
+    EXPECT_TRUE(opener1_manager->IsRVHOnSwappedOutList(opener1_rvh));
+    EXPECT_TRUE(opener1_rfh->is_swapped_out());
+  } else {
+    EXPECT_FALSE(opener1_rfh);
+  }
   EXPECT_FALSE(opener1_rvh->is_active());
 
   // Ensure a swapped out RFH and RVH is created in the second opener tab.
   RenderFrameProxyHost* opener2_proxy =
       opener2_manager->GetRenderFrameProxyHost(rfh2->GetSiteInstance());
   RenderFrameHostImpl* opener2_rfh = opener2_proxy->render_frame_host();
   TestRenderViewHost* opener2_rvh = static_cast<TestRenderViewHost*>(
       opener2_manager->GetSwappedOutRenderViewHost(rvh2->GetSiteInstance()));
-  EXPECT_TRUE(opener2_manager->IsOnSwappedOutList(opener2_rfh));
-  EXPECT_TRUE(opener2_manager->IsRVHOnSwappedOutList(opener2_rvh));
-  EXPECT_TRUE(opener2_rfh->is_swapped_out());
+  if (!is_site_per_process) {
+    EXPECT_TRUE(opener2_manager->IsOnSwappedOutList(opener2_rfh));
+    EXPECT_TRUE(opener2_manager->IsRVHOnSwappedOutList(opener2_rvh));
+    EXPECT_TRUE(opener2_rfh->is_swapped_out());
+  } else {
+    EXPECT_FALSE(opener2_rfh);
+  }
   EXPECT_FALSE(opener2_rvh->is_active());
 
   // Navigate to a cross-BrowsingInstance URL.
   contents()->NavigateAndCommit(kChromeUrl);
   TestRenderFrameHost* rfh3 = main_test_rfh();
-  EXPECT_NE(rfh1->GetSiteInstance(), rfh3->GetSiteInstance());
-  EXPECT_FALSE(rfh1->GetSiteInstance()->IsRelatedSiteInstance(
-                   rfh3->GetSiteInstance()));
+  EXPECT_NE(site_instance1, rfh3->GetSiteInstance());
+  EXPECT_FALSE(site_instance1->IsRelatedSiteInstance(rfh3->GetSiteInstance()));
 
   // No scripting is allowed across BrowsingInstances, so we should not create
   // swapped out RVHs for the opener chain in this case.
   EXPECT_FALSE(opener1_manager->GetRenderFrameProxyHost(
                    rfh3->GetSiteInstance()));
   EXPECT_FALSE(opener1_manager->GetSwappedOutRenderViewHost(
                    rfh3->GetSiteInstance()));
   EXPECT_FALSE(opener2_manager->GetRenderFrameProxyHost(
                    rfh3->GetSiteInstance()));
   EXPECT_FALSE(opener2_manager->GetSwappedOutRenderViewHost(
                    rfh3->GetSiteInstance()));
 }
 
 // Test that a page can disown the opener of the WebContents.
 TEST_F(RenderFrameHostManagerTest, DisownOpener) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   // Navigate to an initial URL.
   contents()->NavigateAndCommit(kUrl1);
   TestRenderFrameHost* rfh1 = main_test_rfh();
+  scoped_refptr<SiteInstanceImpl> site_instance1 = rfh1->GetSiteInstance();
 
   // Create a new tab and simulate having it be the opener for the main tab.
   scoped_ptr<TestWebContents> opener1(
       TestWebContents::Create(browser_context(), rfh1->GetSiteInstance()));
   contents()->SetOpener(opener1.get());
   EXPECT_TRUE(contents()->HasOpener());
 
   // Navigate to a cross-site URL (different SiteInstance but same
   // BrowsingInstance).
   contents()->NavigateAndCommit(kUrl2);
   TestRenderFrameHost* rfh2 = main_test_rfh();
-  EXPECT_NE(rfh1->GetSiteInstance(), rfh2->GetSiteInstance());
+  EXPECT_NE(site_instance1, rfh2->GetSiteInstance());
 
   // Disown the opener from rfh2.
   rfh2->DidDisownOpener();
 
   // Ensure the opener is cleared.
   EXPECT_FALSE(contents()->HasOpener());
 }
 
 // Test that a page can disown a same-site opener of the WebContents.
 TEST_F(RenderFrameHostManagerTest, DisownSameSiteOpener) {
@@ skipping 17 matching lines @@
 }
 
 // Test that a page can disown the opener just as a cross-process navigation is
 // in progress.
 TEST_F(RenderFrameHostManagerTest, DisownOpenerDuringNavigation) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   // Navigate to an initial URL.
   contents()->NavigateAndCommit(kUrl1);
-  TestRenderFrameHost* rfh1 = main_test_rfh();
+  scoped_refptr<SiteInstanceImpl> site_instance1 =
+      main_test_rfh()->GetSiteInstance();
 
   // Create a new tab and simulate having it be the opener for the main tab.
   scoped_ptr<TestWebContents> opener1(
-      TestWebContents::Create(browser_context(), rfh1->GetSiteInstance()));
+      TestWebContents::Create(browser_context(), site_instance1.get()));
   contents()->SetOpener(opener1.get());
   EXPECT_TRUE(contents()->HasOpener());
 
   // Navigate to a cross-site URL (different SiteInstance but same
   // BrowsingInstance).
   contents()->NavigateAndCommit(kUrl2);
   TestRenderFrameHost* rfh2 = main_test_rfh();
-  EXPECT_NE(rfh1->GetSiteInstance(), rfh2->GetSiteInstance());
+  EXPECT_NE(site_instance1, rfh2->GetSiteInstance());
 
-  // Start a back navigation so that rfh1 becomes the pending RFH.
+  // Start a back navigation.
   contents()->GetController().GoBack();
   contents()->GetMainFrame()->PrepareForCommit();
 
   // Disown the opener from rfh2.
   rfh2->DidDisownOpener();
 
   // Ensure the opener is cleared.
   EXPECT_FALSE(contents()->HasOpener());
 
   // The back navigation commits.
   const NavigationEntry* entry1 = contents()->GetController().GetPendingEntry();
-  rfh1->SendNavigate(entry1->GetPageID(), entry1->GetUniqueID(), false,
-                     entry1->GetURL());
+  contents()->GetPendingMainFrame()->SendNavigate(
+      entry1->GetPageID(), entry1->GetUniqueID(), false, entry1->GetURL());
 
   // Ensure the opener is still cleared.
   EXPECT_FALSE(contents()->HasOpener());
 }
 
 // Test that a page can disown the opener just after a cross-process navigation
 // commits.
 TEST_F(RenderFrameHostManagerTest, DisownOpenerAfterNavigation) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   // Navigate to an initial URL.
   contents()->NavigateAndCommit(kUrl1);
-  TestRenderFrameHost* rfh1 = main_test_rfh();
+  scoped_refptr<SiteInstanceImpl> site_instance1 =
+      main_test_rfh()->GetSiteInstance();
 
   // Create a new tab and simulate having it be the opener for the main tab.
   scoped_ptr<TestWebContents> opener1(
-      TestWebContents::Create(browser_context(), rfh1->GetSiteInstance()));
+      TestWebContents::Create(browser_context(), site_instance1.get()));
   contents()->SetOpener(opener1.get());
   EXPECT_TRUE(contents()->HasOpener());
 
   // Navigate to a cross-site URL (different SiteInstance but same
   // BrowsingInstance).
   contents()->NavigateAndCommit(kUrl2);
   TestRenderFrameHost* rfh2 = main_test_rfh();
-  EXPECT_NE(rfh1->GetSiteInstance(), rfh2->GetSiteInstance());
+  EXPECT_NE(site_instance1, rfh2->GetSiteInstance());
 
   // Commit a back navigation before the DidDisownOpener message arrives.
-  // rfh1 will be kept alive because of the opener tab.
   contents()->GetController().GoBack();
   contents()->GetMainFrame()->PrepareForCommit();
   const NavigationEntry* entry1 = contents()->GetController().GetPendingEntry();
-  rfh1->SendNavigate(entry1->GetPageID(), entry1->GetUniqueID(), false,
-                     entry1->GetURL());
+  contents()->GetPendingMainFrame()->SendNavigate(
+      entry1->GetPageID(), entry1->GetUniqueID(), false, entry1->GetURL());
 
   // Disown the opener from rfh2.
   rfh2->DidDisownOpener();
   EXPECT_FALSE(contents()->HasOpener());
 }
 
 // Test that we clean up swapped out RenderViewHosts when a process hosting
 // those associated RenderViews crashes. http://crbug.com/258993
 TEST_F(RenderFrameHostManagerTest, CleanUpSwappedOutRVHOnProcessCrash) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   // Navigate to an initial URL.
   contents()->NavigateAndCommit(kUrl1);
   TestRenderFrameHost* rfh1 = contents()->GetMainFrame();
 
   // Create a new tab as an opener for the main tab.
   scoped_ptr<TestWebContents> opener1(
       TestWebContents::Create(browser_context(), rfh1->GetSiteInstance()));
   RenderFrameHostManager* opener1_manager =
       opener1->GetRenderManagerForTesting();
   contents()->SetOpener(opener1.get());
 
   // Make sure the new opener RVH is considered live.
   opener1_manager->current_host()->CreateRenderView(
-      base::string16(), -1, MSG_ROUTING_NONE, -1, false);
+      base::string16(), -1, MSG_ROUTING_NONE, -1,
+      FrameReplicationState(), false);
   EXPECT_TRUE(opener1_manager->current_host()->IsRenderViewLive());
   EXPECT_TRUE(opener1_manager->current_frame_host()->IsRenderFrameLive());
 
   // Use a cross-process navigation in the opener to swap out the old RVH.
   EXPECT_FALSE(
       opener1_manager->GetSwappedOutRenderViewHost(rfh1->GetSiteInstance()));
   opener1->NavigateAndCommit(kUrl2);
   EXPECT_TRUE(
       opener1_manager->GetSwappedOutRenderViewHost(rfh1->GetSiteInstance()));
 
@@ skipping 50 matching lines @@
   EXPECT_NE(rvh1->GetSiteInstance(), rvh2->GetSiteInstance());
   EXPECT_TRUE(rvh1->GetSiteInstance()->IsRelatedSiteInstance(
                   rvh2->GetSiteInstance()));
 
   // Ensure a swapped out RFH and RVH is created in the first opener tab.
   RenderFrameProxyHost* opener1_proxy =
       opener1_manager->GetRenderFrameProxyHost(rvh2->GetSiteInstance());
   RenderFrameHostImpl* opener1_rfh = opener1_proxy->render_frame_host();
   TestRenderViewHost* opener1_rvh = static_cast<TestRenderViewHost*>(
       opener1_manager->GetSwappedOutRenderViewHost(rvh2->GetSiteInstance()));
-  EXPECT_TRUE(opener1_manager->IsOnSwappedOutList(opener1_rfh));
-  EXPECT_TRUE(opener1_manager->IsRVHOnSwappedOutList(opener1_rvh));
-  EXPECT_TRUE(opener1_rfh->is_swapped_out());
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    EXPECT_TRUE(opener1_manager->IsOnSwappedOutList(opener1_rfh));
+    EXPECT_TRUE(opener1_manager->IsRVHOnSwappedOutList(opener1_rvh));
+    EXPECT_TRUE(opener1_rfh->is_swapped_out());
+  } else {
+    EXPECT_FALSE(opener1_rfh);
+  }
   EXPECT_FALSE(opener1_rvh->is_active());
 
   // Ensure the new RVH has WebUI bindings.
   EXPECT_TRUE(rvh2->GetEnabledBindings() & BINDINGS_POLICY_WEB_UI);
 }
 
 // Test that we reuse the same guest SiteInstance if we navigate across sites.
 TEST_F(RenderFrameHostManagerTest, NoSwapOnGuestNavigations) {
   GURL guest_url(std::string(kGuestScheme).append("://abc123"));
   SiteInstance* instance =
@@ skipping 217 matching lines @@
                               ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->CrossProcessNavigationPending());
   EXPECT_EQ(rfh2, contents()->GetMainFrame());
   EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh2->rfh_state());
   EXPECT_EQ(RenderFrameHostImpl::STATE_PENDING_SWAP_OUT, rfh1->rfh_state());
 
   // Simulate the swap out ack.
   rfh1->OnSwappedOut();
 
-  // rfh1 should be swapped out.
-  EXPECT_FALSE(rfh_deleted_observer.deleted());
-  EXPECT_TRUE(rfh1->is_swapped_out());
+  // rfh1 should be swapped out or deleted in --site-per-process.
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    EXPECT_FALSE(rfh_deleted_observer.deleted());
+    EXPECT_TRUE(rfh1->is_swapped_out());
+  } else {
+    EXPECT_TRUE(rfh_deleted_observer.deleted());
+  }
 }
 
 // Test that the RenderViewHost is properly swapped out if a navigation in the
 // new renderer commits before sending the SwapOut message to the old renderer.
 // This simulates a cross-site navigation to a synchronously committing URL
 // (e.g., a data URL) and ensures it works properly.
 TEST_F(RenderFrameHostManagerTest,
        CommitNewNavigationBeforeSendingSwapOut) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
 
   // Navigate to the first page.
   contents()->NavigateAndCommit(kUrl1);
   TestRenderFrameHost* rfh1 = contents()->GetMainFrame();
   RenderFrameHostDeletedObserver rfh_deleted_observer(rfh1);
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh1->rfh_state());
 
   // Increment the number of active frames in SiteInstanceImpl so that rfh1 is
   // not deleted on swap out.
-  rfh1->GetSiteInstance()->increment_active_frame_count();
+  scoped_refptr<SiteInstanceImpl> site_instance = rfh1->GetSiteInstance();
+  site_instance->increment_active_frame_count();
 
   // Navigate to new site, simulating onbeforeunload approval.
   controller().LoadURL(
       kUrl2, Referrer(), ui::PAGE_TRANSITION_LINK, std::string());
   int entry_id = controller().GetPendingEntry()->GetUniqueID();
   rfh1->PrepareForCommit();
   EXPECT_TRUE(contents()->CrossProcessNavigationPending());
   TestRenderFrameHost* rfh2 = contents()->GetPendingMainFrame();
 
   // The new page commits.
   contents()->TestDidNavigate(rfh2, 1, entry_id, true, kUrl2,
                               ui::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->CrossProcessNavigationPending());
   EXPECT_EQ(rfh2, contents()->GetMainFrame());
   EXPECT_TRUE(contents()->GetPendingMainFrame() == NULL);
   EXPECT_EQ(RenderFrameHostImpl::STATE_DEFAULT, rfh2->rfh_state());
   EXPECT_EQ(RenderFrameHostImpl::STATE_PENDING_SWAP_OUT, rfh1->rfh_state());
 
   // Simulate the swap out ack.
   rfh1->OnSwappedOut();
 
   // rfh1 should be swapped out.
-  EXPECT_FALSE(rfh_deleted_observer.deleted());
-  EXPECT_TRUE(rfh1->is_swapped_out());
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+    EXPECT_TRUE(rfh_deleted_observer.deleted());
+    EXPECT_TRUE(contents()->GetFrameTree()->root()->render_manager()
+                ->GetRenderFrameProxyHost(site_instance.get()));
+  } else {
+    EXPECT_FALSE(rfh_deleted_observer.deleted());
+    EXPECT_TRUE(rfh1->is_swapped_out());
+  }
 }
 
-// Test that a RenderFrameHost is properly deleted or swapped out when a
-// cross-site navigation is cancelled.
+// Test that a RenderFrameHost is properly deleted when a cross-site navigation
+// is cancelled.
 TEST_F(RenderFrameHostManagerTest,
        CancelPendingProperlyDeletesOrSwaps) {
   const GURL kUrl1("http://www.google.com/");
   const GURL kUrl2("http://www.chromium.org/");
   RenderFrameHostImpl* pending_rfh = NULL;
   base::TimeTicks now = base::TimeTicks::Now();
 
   // Navigate to the first page.
   contents()->NavigateAndCommit(kUrl1);
   TestRenderFrameHost* rfh1 = main_test_rfh();
@@ skipping 19 matching lines @@
 
   // Start another cross-site navigation.
   controller().LoadURL(
       kUrl2, Referrer(), ui::PAGE_TRANSITION_LINK, std::string());
   {
     pending_rfh = contents()->GetFrameTree()->root()->render_manager()
         ->pending_frame_host();
     RenderFrameHostDeletedObserver rfh_deleted_observer(pending_rfh);
 
     // Increment the number of active frames in the new SiteInstance, which will
-    // cause the pending RFH to be swapped out instead of deleted.
-    pending_rfh->GetSiteInstance()->increment_active_frame_count();
+    // cause the pending RFH to be deleted and a RenderFrameProxyHost to be
+    // created.
+    scoped_refptr<SiteInstanceImpl> site_instance =
+        pending_rfh->GetSiteInstance();
+    site_instance->increment_active_frame_count();
 
     contents()->GetMainFrame()->OnMessageReceived(
         FrameHostMsg_BeforeUnload_ACK(0, false, now, now));
     EXPECT_FALSE(contents()->CrossProcessNavigationPending());
-    EXPECT_FALSE(rfh_deleted_observer.deleted());
+
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kSitePerProcess)) {
+      EXPECT_TRUE(rfh_deleted_observer.deleted());
+      EXPECT_TRUE(contents()->GetFrameTree()->root()->render_manager()
+                  ->GetRenderFrameProxyHost(site_instance.get()));
+    } else {
+      EXPECT_FALSE(rfh_deleted_observer.deleted());
+    }
   }
 }
 
 // Test that a pending RenderFrameHost in a non-root frame tree node is properly
 // deleted when the node is detached. Motivated by http://crbug.com/441357 and
 // http://crbug.com/444955.
 TEST_F(RenderFrameHostManagerTest, DetachPendingChild) {
   base::CommandLine::ForCurrentProcess()->AppendSwitch(
       switches::kSitePerProcess);
 
@@ skipping 173 matching lines @@
   EXPECT_FALSE(contents2->GetMainFrame()->IsRenderFrameLive());
   contents2->NavigateAndCommit(kUrl3);
   EXPECT_TRUE(contents2->GetMainFrame()->IsRenderFrameLive());
   EXPECT_NE(nullptr,
             iframe->GetRenderFrameProxyHost(contents1->GetSiteInstance()));
   EXPECT_EQ(nullptr,
             iframe->GetRenderFrameProxyHost(contents2->GetSiteInstance()));
 }
 
 }  // namespace content