Clean up a few TODO items.

content/browser/tab_contents/tab_contents_unittest.cc

 // Copyright (c) 2012 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/logging.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/mock_content_browser_client.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/site_instance_impl.h"
@@ skipping 351 matching lines @@
   contents()->UpdateMaxPageIDForSiteInstance(instance2, 7);
   EXPECT_EQ(3, contents()->GetMaxPageID());
   EXPECT_EQ(3, contents()->GetMaxPageIDForSiteInstance(instance1));
   EXPECT_EQ(7, contents()->GetMaxPageIDForSiteInstance(instance2));
 }
 
 // Test simple same-SiteInstance navigation.
 TEST_F(TabContentsTest, SimpleNavigation) {
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 
   // Navigate to URL
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(instance1, orig_rvh->GetSiteInstance());
   // Controller's pending entry will have a NULL site instance until we assign
   // it in DidNavigate.
   EXPECT_TRUE(
@@ skipping 42 matching lines @@
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* pending_rvh =
-      static_cast<TestRenderViewHost*>(contents()->pending_rvh());
+      static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   int pending_rvh_delete_count = 0;
   pending_rvh->set_delete_counter(&pending_rvh_delete_count);
 
   // Navigations should be suspended in pending_rvh until ShouldCloseACK.
   EXPECT_TRUE(pending_rvh->are_navigations_suspended());
   orig_rvh->SendShouldCloseACK(true);
   EXPECT_FALSE(pending_rvh->are_navigations_suspended());
 
   // DidNavigate from the pending page
   contents()->TestDidNavigate(
       pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, contents()->GetRenderViewHost());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
   // We keep the original RVH around, swapped out.
   EXPECT_TRUE(contents()->GetRenderManagerForTesting()->IsSwappedOut(orig_rvh));
   EXPECT_EQ(orig_rvh_delete_count, 0);
 
   // Going back should switch SiteInstances again.  The first SiteInstance is
   // stored in the NavigationEntry, so it should be the same as at the start.
   // We should use the same RVH as before, swapping it back in.
   controller().GoBack();
   TestRenderViewHost* goback_rvh =
-      static_cast<TestRenderViewHost*>(contents()->pending_rvh());
+      static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(orig_rvh, goback_rvh);
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Navigations should be suspended in goback_rvh until ShouldCloseACK.
   EXPECT_TRUE(goback_rvh->are_navigations_suspended());
   pending_rvh->SendShouldCloseACK(true);
   EXPECT_FALSE(goback_rvh->are_navigations_suspended());
 
   // DidNavigate from the back action
   contents()->TestDidNavigate(
@@ skipping 32 matching lines @@
 
   // Crash the renderer.
   orig_rvh->set_render_view_created(false);
 
   // Navigate to new site.  We should not go into PENDING.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   RenderViewHost* new_rvh = rvh();
   EXPECT_FALSE(contents()->cross_navigation_pending());
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
   EXPECT_NE(orig_rvh, new_rvh);
   EXPECT_EQ(orig_rvh_delete_count, 1);
 
   // DidNavigate from the new page
   contents()->TestDidNavigate(new_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(new_rvh, rvh());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 
   // Close tab and ensure RVHs are deleted.
   DeleteContents();
   EXPECT_EQ(orig_rvh_delete_count, 1);
 }
 
 // Test that opening a new tab in the same SiteInstance and then navigating
 // both tabs to a new site will place both tabs in a single SiteInstance.
 TEST_F(TabContentsTest, NavigateTwoTabsCrossSite) {
   contents()->transition_cross_site = true;
@@ skipping 17 matching lines @@
   contents2.TestDidNavigate(
       contents2.GetRenderViewHost(), 2, url, content::PAGE_TRANSITION_TYPED);
 
   // Navigate first tab to a new site
   const GURL url2a("http://www.yahoo.com");
   controller().LoadURL(
       url2a, content::Referrer(), content::PAGE_TRANSITION_TYPED,
       std::string());
   orig_rvh->SendShouldCloseACK(true);
   TestRenderViewHost* pending_rvh_a =
-      static_cast<TestRenderViewHost*>(contents()->pending_rvh());
+      static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   contents()->TestDidNavigate(
       pending_rvh_a, 1, url2a, content::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2a = contents()->GetSiteInstance();
   EXPECT_NE(instance1, instance2a);
 
   // Navigate second tab to the same site as the first tab
   const GURL url2b("http://mail.yahoo.com");
   contents2.GetController().LoadURL(url2b, content::Referrer(),
                                     content::PAGE_TRANSITION_TYPED,
                                     std::string());
   TestRenderViewHost* rvh2 =
       static_cast<TestRenderViewHost*>(contents2.GetRenderViewHost());
   rvh2->SendShouldCloseACK(true);
   TestRenderViewHost* pending_rvh_b =
-      static_cast<TestRenderViewHost*>(contents2.pending_rvh());
+      static_cast<TestRenderViewHost*>(contents2.GetPendingRenderViewHost());
   EXPECT_TRUE(pending_rvh_b != NULL);
   EXPECT_TRUE(contents2.cross_navigation_pending());
 
   // NOTE(creis): We used to be in danger of showing a sad tab page here if the
   // second tab hadn't navigated somewhere first (bug 1145430).  That case is
   // now covered by the CrossSiteBoundariesAfterCrash test.
   contents2.TestDidNavigate(
       pending_rvh_b, 2, url2b, content::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2b = contents2.GetSiteInstance();
   EXPECT_NE(instance1, instance2b);
@@ skipping 66 matching lines @@
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, but simulate an onbeforeunload denial.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
-  orig_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, false, base::TimeTicks(), base::TimeTicks()));
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate again, but simulate an onbeforeunload approval.
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
-  orig_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* pending_rvh = static_cast<TestRenderViewHost*>(
-      contents()->pending_rvh());
+      contents()->GetPendingRenderViewHost());
 
   // We won't hear DidNavigate until the onunload handler has finished running.
   // (No way to simulate that here, but it involves a call from RDH to
   // TabContents::OnCrossSiteResponse.)
 
   // DidNavigate from the pending page
   contents()->TestDidNavigate(
       pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, rvh());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 // Test that during a slow cross-site navigation, the original renderer can
 // navigate to a different URL and have it displayed, canceling the slow
 // navigation.
 TEST_F(TabContentsTest, CrossSiteNavigationPreempted) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
-  orig_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Suppose the original renderer navigates before the new one is ready.
   orig_rvh->SendNavigate(2, GURL("http://www.google.com/foo"));
 
   // Verify that the pending navigation is cancelled.
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, rvh());
   EXPECT_EQ(instance1, instance2);
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 TEST_F(TabContentsTest, CrossSiteNavigationBackPreempted) {
   contents()->transition_cross_site = true;
 
   // Start with a web ui page, which gets a new RVH with WebUI bindings.
   const GURL url1("tabcontentstest://blah");
   controller().LoadURL(
       url1, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* ntp_rvh = test_rvh();
   contents()->TestDidNavigate(ntp_rvh, 1, url1, content::PAGE_TRANSITION_TYPED);
   NavigationEntry* entry1 = controller().GetLastCommittedEntry();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(ntp_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(url1, entry1->GetURL());
   EXPECT_EQ(instance1,
             NavigationEntryImpl::FromNavigationEntry(entry1)->site_instance());
   EXPECT_TRUE(ntp_rvh->GetEnabledBindings() & content::BINDINGS_POLICY_WEB_UI);
 
   // Navigate to new site.
   const GURL url2("http://www.google.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* google_rvh =
-      static_cast<TestRenderViewHost*>(contents()->pending_rvh());
+      static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
 
   // Simulate beforeunload approval.
   EXPECT_TRUE(ntp_rvh->is_waiting_for_beforeunload_ack());
-  ntp_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  ntp_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
 
   // DidNavigate from the pending page.
   contents()->TestDidNavigate(
       google_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
   NavigationEntry* entry2 = controller().GetLastCommittedEntry();
   SiteInstance* instance2 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(google_rvh, contents()->GetRenderViewHost());
   EXPECT_NE(instance1, instance2);
-  EXPECT_FALSE(contents()->pending_rvh());
+  EXPECT_FALSE(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(url2, entry2->GetURL());
   EXPECT_EQ(instance2,
             NavigationEntryImpl::FromNavigationEntry(entry2)->site_instance());
   EXPECT_FALSE(google_rvh->GetEnabledBindings() &
       content::BINDINGS_POLICY_WEB_UI);
 
   // Navigate to third page on same site.
   const GURL url3("http://news.google.com");
   controller().LoadURL(
       url3, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_FALSE(contents()->cross_navigation_pending());
   contents()->TestDidNavigate(
       google_rvh, 2, url3, content::PAGE_TRANSITION_TYPED);
   NavigationEntry* entry3 = controller().GetLastCommittedEntry();
   SiteInstance* instance3 = contents()->GetSiteInstance();
 
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(google_rvh, contents()->GetRenderViewHost());
   EXPECT_EQ(instance2, instance3);
-  EXPECT_FALSE(contents()->pending_rvh());
+  EXPECT_FALSE(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(url3, entry3->GetURL());
   EXPECT_EQ(instance3,
             NavigationEntryImpl::FromNavigationEntry(entry3)->site_instance());
 
   // Go back within the site.
   controller().GoBack();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(entry2, controller().GetPendingEntry());
 
   // Before that commits, go back again.
   controller().GoBack();
   EXPECT_TRUE(contents()->cross_navigation_pending());
-  EXPECT_TRUE(contents()->pending_rvh());
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost());
   EXPECT_EQ(entry1, controller().GetPendingEntry());
 
   // Simulate beforeunload approval.
   EXPECT_TRUE(google_rvh->is_waiting_for_beforeunload_ack());
-  google_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  google_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
 
   // DidNavigate from the first back. This aborts the second back's pending RVH.
   contents()->TestDidNavigate(
       google_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
 
   // We should commit this page and forget about the second back.
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_FALSE(controller().GetPendingEntry());
   EXPECT_EQ(google_rvh, contents()->GetRenderViewHost());
@@ skipping 29 matching lines @@
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
 
   // Simulate a sub-frame navigation arriving and ensure the RVH is still
   // waiting for a before unload response.
   orig_rvh->SendNavigateWithTransition(1, GURL("http://google.com/frame"),
                                        content::PAGE_TRANSITION_AUTO_SUBFRAME);
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // Now simulate the onbeforeunload approval and verify the navigation is
   // not canceled.
-  orig_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   EXPECT_TRUE(contents()->cross_navigation_pending());
 }
 
 // Test that a cross-site navigation is not preempted if the previous
 // renderer sends a FrameNavigate message just before being told to stop.
 // We should only preempt the cross-site navigation if the previous renderer
 // has started a new navigation.  See http://crbug.com/79176.
 TEST_F(TabContentsTest, CrossSiteNotPreemptedDuringBeforeUnload) {
   contents()->transition_cross_site = true;
 
   // Navigate to NTP URL.
   const GURL url("tabcontentstest://blah");
   controller().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* orig_rvh = test_rvh();
   EXPECT_FALSE(contents()->cross_navigation_pending());
 
   // Navigate to new site, with the beforeunload request in flight.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   TestRenderViewHost* pending_rvh =
-      static_cast<TestRenderViewHost*>(contents()->pending_rvh());
+      static_cast<TestRenderViewHost*>(contents()->GetPendingRenderViewHost());
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
 
   // Suppose the first navigation tries to commit now, with a
   // ViewMsg_Stop in flight.  This should not cancel the pending navigation,
   // but it should act as if the beforeunload ack arrived.
   orig_rvh->SendNavigate(1, GURL("tabcontentstest://blah"));
   EXPECT_TRUE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
@@ skipping 19 matching lines @@
   controller().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  orig_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_TRUE(contents()->cross_navigation_pending());
   TestRenderViewHost* pending_rvh = static_cast<TestRenderViewHost*>(
-      contents()->pending_rvh());
+      contents()->GetPendingRenderViewHost());
 
   // Simulate the pending renderer's response, which leads to an unload request
   // being sent to orig_rvh.
   contents()->GetRenderManagerForTesting()->OnCrossSiteResponse(0, 0);
 
   // Suppose the original renderer navigates now, while the unload request is in
   // flight.  We should ignore it, wait for the unload ack, and let the pending
   // request continue.  Otherwise, the tab may close spontaneously or stop
   // responding to navigation requests.  (See bug 23942.)
   ViewHostMsg_FrameNavigate_Params params1a;
   InitNavigateParams(&params1a, 2, GURL("http://www.google.com/foo"),
                      content::PAGE_TRANSITION_TYPED);
   orig_rvh->SendNavigate(2, GURL("http://www.google.com/foo"));
 
   // Verify that the pending navigation is still in progress.
   EXPECT_TRUE(contents()->cross_navigation_pending());
-  EXPECT_TRUE(contents()->pending_rvh() != NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() != NULL);
 
   // DidNavigate from the pending page should commit it.
   contents()->TestDidNavigate(
       pending_rvh, 1, url2, content::PAGE_TRANSITION_TYPED);
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(pending_rvh, rvh());
   EXPECT_NE(instance1, instance2);
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 // Test that a cross-site navigation that doesn't commit after the unload
 // handler doesn't leave the tab in a stuck state.  http://crbug.com/88562.
 TEST_F(TabContentsTest, CrossSiteNavigationCanceled) {
   contents()->transition_cross_site = true;
   TestRenderViewHost* orig_rvh = test_rvh();
   SiteInstance* instance1 = contents()->GetSiteInstance();
 
   // Navigate to URL.  First URL should use first RenderViewHost.
   const GURL url("http://www.google.com");
   controller().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   contents()->TestDidNavigate(orig_rvh, 1, url, content::PAGE_TRANSITION_TYPED);
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, contents()->GetRenderViewHost());
 
   // Navigate to new site, simulating an onbeforeunload approval.
   const GURL url2("http://www.yahoo.com");
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_TRUE(orig_rvh->is_waiting_for_beforeunload_ack());
-  orig_rvh->TestOnMessageReceived(ViewHostMsg_ShouldClose_ACK(
+  orig_rvh->OnMessageReceived(ViewHostMsg_ShouldClose_ACK(
       0, true, base::TimeTicks(), base::TimeTicks()));
   EXPECT_TRUE(contents()->cross_navigation_pending());
 
   // Simulate swap out message when the response arrives.
   orig_rvh->set_is_swapped_out(true);
 
   // Suppose the navigation doesn't get a chance to commit, and the user
   // navigates in the current RVH's SiteInstance.
   controller().LoadURL(
       url, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
 
   // Verify that the pending navigation is cancelled and the renderer is no
   // longer swapped out.
   EXPECT_FALSE(orig_rvh->is_waiting_for_beforeunload_ack());
   SiteInstance* instance2 = contents()->GetSiteInstance();
   EXPECT_FALSE(contents()->cross_navigation_pending());
   EXPECT_EQ(orig_rvh, rvh());
   EXPECT_FALSE(orig_rvh->is_swapped_out());
   EXPECT_EQ(instance1, instance2);
-  EXPECT_TRUE(contents()->pending_rvh() == NULL);
+  EXPECT_TRUE(contents()->GetPendingRenderViewHost() == NULL);
 }
 
 // Test that NavigationEntries have the correct content state after going
 // forward and back.  Prevents regression for bug 1116137.
 TEST_F(TabContentsTest, NavigationEntryContentState) {
   TestRenderViewHost* orig_rvh = test_rvh();
 
   // Navigate to URL.  There should be no committed entry yet.
   const GURL url("http://www.google.com");
   controller().LoadURL(
@@ skipping 431 matching lines @@
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
   interstitial->TestDidNavigate(2, interstitial_url);
 
   // Crash the renderer
-  test_rvh()->TestOnMessageReceived(
+  test_rvh()->OnMessageReceived(
       ViewHostMsg_RenderViewGone(
           0, base::TERMINATION_STATUS_PROCESS_CRASHED, -1));
 
   // While the interstitial is showing, go back.
   controller().GoBack();
   test_rvh()->SendNavigate(1, url1);
 
   // Make sure we are back to the original page and that the interstitial is
   // gone.
   EXPECT_TRUE(deleted);
@@ skipping 16 matching lines @@
       TestInterstitialPage::UNDECIDED;
   bool deleted = false;
   GURL interstitial_url("http://interstitial");
   TestInterstitialPage* interstitial =
       new TestInterstitialPage(contents(), true, interstitial_url,
                                &state, &deleted);
   TestInterstitialPageStateGuard state_guard(interstitial);
   interstitial->Show();
 
   // Crash the renderer
-  test_rvh()->TestOnMessageReceived(
+  test_rvh()->OnMessageReceived(
       ViewHostMsg_RenderViewGone(
           0, base::TERMINATION_STATUS_PROCESS_CRASHED, -1));
 
   interstitial->TestDidNavigate(2, interstitial_url);
 }
 
 // Test navigating to a page that shows an interstitial, then close the tab.
 TEST_F(TabContentsTest, ShowInterstitialThenCloseTab) {
   // Show interstitial.
   TestInterstitialPage::InterstitialState state =
@@ skipping 426 matching lines @@
   // It should have a transient entry.
   EXPECT_TRUE(other_controller.GetTransientEntry());
 
   // And the interstitial should be showing.
   EXPECT_TRUE(other_contents->ShowingInterstitialPage());
 
   // And the interstitial should do a reload on don't proceed.
   EXPECT_TRUE(static_cast<InterstitialPageImpl*>(
       other_contents->GetInterstitialPage())->reload_on_dont_proceed());
 }