Rename NavigationController to NavigationControllerImpl and put it into the content namespace. Al...

content/browser/tab_contents/navigation_controller_unittest.cc

 // Copyright (c) 2011 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/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 //  These are only used for commented out tests.  If someone wants to enable
 //  them, they should be moved to chrome first.
 //  #include "chrome/browser/history/history.h"
 //  #include "chrome/browser/profiles/profile_manager.h"
 //  #include "chrome/browser/sessions/session_service.h"
 //  #include "chrome/browser/sessions/session_service_factory.h"
 //  #include "chrome/browser/sessions/session_service_test_helper.h"
 //  #include "chrome/browser/sessions/session_types.h"
 #include "content/browser/renderer_host/test_render_view_host.h"
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/navigation_controller.h"
-#include "content/browser/tab_contents/navigation_entry.h"
+#include "content/browser/tab_contents/navigation_entry_impl.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/test_tab_contents.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/test/test_browser_context.h"
 #include "content/test/test_notification_tracker.h"
 #include "net/base/net_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/glue/webkit_glue.h"
 
 using base::Time;
+using content::NavigationEntry;
+using content::NavigationEntryImpl;
 
 // NavigationControllerTest ----------------------------------------------------
 
 class NavigationControllerTest : public RenderViewHostTestHarness {
  public:
   NavigationControllerTest() {}
 };
 
 void RegisterForAllNavNotifications(TestNotificationTracker* tracker,
                                     NavigationController* controller) {
@@ skipping 673 matching lines @@
   // First navigate three places so we have some back history.
   rvh()->SendNavigate(0, kUrl1);
   rvh()->SendNavigate(1, kUrl2);
   rvh()->SendNavigate(2, kUrl3);
 
   // With nothing pending, say we get a navigation to the second entry.
   rvh()->SendNavigate(1, kUrl2);
 
   // We know all the entries have the same site instance, so we can just grab
   // a random one for looking up other entries.
-  SiteInstance* site_instance = NavigationEntry::FromNavigationEntry(
+  SiteInstance* site_instance = NavigationEntryImpl::FromNavigationEntry(
       controller().GetLastCommittedEntry())->site_instance();
 
   // That second URL should be the last committed and it should have gotten the
   // new title.
   EXPECT_EQ(kUrl2, controller().GetEntryWithPageID(site_instance, 1)->GetURL());
   EXPECT_EQ(1, controller().last_committed_entry_index());
   EXPECT_EQ(-1, controller().pending_entry_index());
 
   // Now go forward to the last item again and say it was committed.
   controller().GoForward();
@@ skipping 727 matching lines @@
 
   NavigationController::set_max_entry_count_for_testing(original_count);
 }
 
 // Tests that we can do a restore and navigate to the restored entries and
 // everything is updated properly. This can be tricky since there is no
 // SiteInstance for the entries created initially.
 TEST_F(NavigationControllerTest, RestoreNavigate) {
   // Create a NavigationController with a restored set of tabs.
   GURL url("http://foo");
-  std::vector<content::NavigationEntry*> entries;
+  std::vector<NavigationEntry*> entries;
   NavigationEntry* entry = NavigationController::CreateNavigationEntryImpl(
       url, content::Referrer(), content::PAGE_TRANSITION_RELOAD, false,
       std::string(), browser_context());
   entry->SetPageID(0);
   entry->SetTitle(ASCIIToUTF16("Title"));
   entry->SetContentState("state");
   entries.push_back(entry);
   TabContents our_contents(
       browser_context(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   NavigationController& our_controller = our_contents.GetController();
   our_controller.Restore(0, true, &entries);
   ASSERT_EQ(0u, entries.size());
 
   // Before navigating to the restored entry, it should have a restore_type
   // and no SiteInstance.
-  EXPECT_EQ(NavigationEntry::RESTORE_LAST_SESSION,
-            NavigationEntry::FromNavigationEntry(
+  EXPECT_EQ(NavigationEntryImpl::RESTORE_LAST_SESSION,
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetEntryAtIndex(0))->restore_type());
-  EXPECT_FALSE(NavigationEntry::FromNavigationEntry(
+  EXPECT_FALSE(NavigationEntryImpl::FromNavigationEntry(
       our_controller.GetEntryAtIndex(0))->site_instance());
 
   // After navigating, we should have one entry, and it should be "pending".
   // It should now have a SiteInstance and no restore_type.
   our_controller.GoToIndex(0);
   EXPECT_EQ(1, our_controller.entry_count());
   EXPECT_EQ(our_controller.GetEntryAtIndex(0),
             our_controller.GetPendingEntry());
   EXPECT_EQ(0, our_controller.GetEntryAtIndex(0)->GetPageID());
-  EXPECT_EQ(NavigationEntry::RESTORE_NONE,
-            NavigationEntry::FromNavigationEntry
+  EXPECT_EQ(NavigationEntryImpl::RESTORE_NONE,
+            NavigationEntryImpl::FromNavigationEntry
                 (our_controller.GetEntryAtIndex(0))->restore_type());
-  EXPECT_TRUE(NavigationEntry::FromNavigationEntry(
+  EXPECT_TRUE(NavigationEntryImpl::FromNavigationEntry(
       our_controller.GetEntryAtIndex(0))->site_instance());
 
   // Say we navigated to that entry.
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = url;
   params.transition = content::PAGE_TRANSITION_LINK;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url));
   content::LoadCommittedDetails details;
   our_controller.RendererDidNavigate(params, &details);
 
   // There should be no longer any pending entry and one committed one. This
   // means that we were able to locate the entry, assign its site instance, and
   // commit it properly.
   EXPECT_EQ(1, our_controller.entry_count());
   EXPECT_EQ(0, our_controller.last_committed_entry_index());
   EXPECT_FALSE(our_controller.GetPendingEntry());
   EXPECT_EQ(url,
-            NavigationEntry::FromNavigationEntry(
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetLastCommittedEntry())->site_instance()->
                     site());
-  EXPECT_EQ(NavigationEntry::RESTORE_NONE,
-            NavigationEntry::FromNavigationEntry(
+  EXPECT_EQ(NavigationEntryImpl::RESTORE_NONE,
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetEntryAtIndex(0))->restore_type());
 }
 
 // Tests that we can still navigate to a restored entry after a different
 // navigation fails and clears the pending entry.  http://crbug.com/90085
 TEST_F(NavigationControllerTest, RestoreNavigateAfterFailure) {
   // Create a NavigationController with a restored set of tabs.
   GURL url("http://foo");
-  std::vector<content::NavigationEntry*> entries;
+  std::vector<NavigationEntry*> entries;
   NavigationEntry* entry = NavigationController::CreateNavigationEntryImpl(
       url, content::Referrer(), content::PAGE_TRANSITION_RELOAD, false,
       std::string(), browser_context());
   entry->SetPageID(0);
   entry->SetTitle(ASCIIToUTF16("Title"));
   entry->SetContentState("state");
   entries.push_back(entry);
   TabContents our_contents(
       browser_context(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   NavigationController& our_controller = our_contents.GetController();
   our_controller.Restore(0, true, &entries);
   ASSERT_EQ(0u, entries.size());
 
   // Before navigating to the restored entry, it should have a restore_type
   // and no SiteInstance.
-  EXPECT_EQ(NavigationEntry::RESTORE_LAST_SESSION,
-            NavigationEntry::FromNavigationEntry(
+  EXPECT_EQ(NavigationEntryImpl::RESTORE_LAST_SESSION,
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetEntryAtIndex(0))->restore_type());
-  EXPECT_FALSE(NavigationEntry::FromNavigationEntry(
+  EXPECT_FALSE(NavigationEntryImpl::FromNavigationEntry(
       our_controller.GetEntryAtIndex(0))->site_instance());
 
   // After navigating, we should have one entry, and it should be "pending".
   // It should now have a SiteInstance and no restore_type.
   our_controller.GoToIndex(0);
   EXPECT_EQ(1, our_controller.entry_count());
   EXPECT_EQ(our_controller.GetEntryAtIndex(0),
             our_controller.GetPendingEntry());
   EXPECT_EQ(0, our_controller.GetEntryAtIndex(0)->GetPageID());
-  EXPECT_EQ(NavigationEntry::RESTORE_NONE,
-            NavigationEntry::FromNavigationEntry(
+  EXPECT_EQ(NavigationEntryImpl::RESTORE_NONE,
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetEntryAtIndex(0))->restore_type());
-  EXPECT_TRUE(NavigationEntry::FromNavigationEntry(
+  EXPECT_TRUE(NavigationEntryImpl::FromNavigationEntry(
       our_controller.GetEntryAtIndex(0))->site_instance());
 
   // This pending navigation may have caused a different navigation to fail,
   // which causes the pending entry to be cleared.
   TestRenderViewHost* rvh =
       static_cast<TestRenderViewHost*>(our_contents.GetRenderViewHost());
   ViewHostMsg_DidFailProvisionalLoadWithError_Params fail_load_params;
   fail_load_params.frame_id = 1;
   fail_load_params.is_main_frame = true;
   fail_load_params.error_code = net::ERR_ABORTED;
@@ skipping 14 matching lines @@
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url));
   content::LoadCommittedDetails details;
   our_controller.RendererDidNavigate(params, &details);
 
   // There should be no pending entry and one committed one.
   EXPECT_EQ(1, our_controller.entry_count());
   EXPECT_EQ(0, our_controller.last_committed_entry_index());
   EXPECT_FALSE(our_controller.GetPendingEntry());
   EXPECT_EQ(url,
-            NavigationEntry::FromNavigationEntry(
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetLastCommittedEntry())->site_instance()->
                     site());
-  EXPECT_EQ(NavigationEntry::RESTORE_NONE,
-            NavigationEntry::FromNavigationEntry(
+  EXPECT_EQ(NavigationEntryImpl::RESTORE_NONE,
+            NavigationEntryImpl::FromNavigationEntry(
                 our_controller.GetEntryAtIndex(0))->restore_type());
 }
 
 // Make sure that the page type and stuff is correct after an interstitial.
 TEST_F(NavigationControllerTest, Interstitial) {
   // First navigate somewhere normal.
   const GURL url1("http://foo");
   controller().LoadURL(
       url1, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url1);
 
   // Now navigate somewhere with an interstitial.
   const GURL url2("http://bar");
   controller().LoadURL(
       url1, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  NavigationEntry::FromNavigationEntry(controller().GetPendingEntry())->
+  NavigationEntryImpl::FromNavigationEntry(controller().GetPendingEntry())->
       set_page_type(content::PAGE_TYPE_INTERSTITIAL);
 
   // At this point the interstitial will be displayed and the load will still
   // be pending. If the user continues, the load will commit.
   rvh()->SendNavigate(1, url2);
 
   // The page should be a normal page again.
   EXPECT_EQ(url2, controller().GetLastCommittedEntry()->GetURL());
   EXPECT_EQ(content::PAGE_TYPE_NORMAL,
             controller().GetLastCommittedEntry()->GetPageType());
@@ skipping 67 matching lines @@
   controller().LoadURL(
       url0, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url0);
   controller().LoadURL(
       url1, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, url1);
 
   notifications.Reset();
 
   // Adding a transient with no pending entry.
-  NavigationEntry* transient_entry = new NavigationEntry;
+  NavigationEntryImpl* transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
 
   // We should not have received any notifications.
   EXPECT_EQ(0U, notifications.size());
 
   // Check our state.
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(controller().entry_count(), 3);
   EXPECT_EQ(controller().last_committed_entry_index(), 1);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_FALSE(controller().GetPendingEntry());
   EXPECT_TRUE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), 1);
 
   // Navigate.
   controller().LoadURL(
       url2, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(2, url2);
 
   // We should have navigated, transient entry should be gone.
   EXPECT_EQ(url2, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(controller().entry_count(), 3);
 
   // Add a transient again, then navigate with no pending entry this time.
-  transient_entry = new NavigationEntry;
+  transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   rvh()->SendNavigate(3, url3);
   // Transient entry should be gone.
   EXPECT_EQ(url3, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(controller().entry_count(), 4);
 
   // Initiate a navigation, add a transient then commit navigation.
   controller().LoadURL(
       url4, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
-  transient_entry = new NavigationEntry;
+  transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   rvh()->SendNavigate(4, url4);
   EXPECT_EQ(url4, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(controller().entry_count(), 5);
 
   // Add a transient and go back.  This should simply remove the transient.
-  transient_entry = new NavigationEntry;
+  transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   EXPECT_TRUE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   controller().GoBack();
   // Transient entry should be gone.
   EXPECT_EQ(url4, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(controller().entry_count(), 5);
   rvh()->SendNavigate(3, url3);
 
   // Add a transient and go to an entry before the current one.
-  transient_entry = new NavigationEntry;
+  transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   controller().GoToIndex(1);
   // The navigation should have been initiated, transient entry should be gone.
   EXPECT_EQ(url1, controller().GetActiveEntry()->GetURL());
   // Visible entry does not update for history navigations until commit.
   EXPECT_EQ(url3, controller().GetVisibleEntry()->GetURL());
   rvh()->SendNavigate(1, url1);
   EXPECT_EQ(url1, controller().GetVisibleEntry()->GetURL());
 
   // Add a transient and go to an entry after the current one.
-  transient_entry = new NavigationEntry;
+  transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   controller().GoToIndex(3);
   // The navigation should have been initiated, transient entry should be gone.
   // Because of the transient entry that is removed, going to index 3 makes us
   // land on url2 (which is visible after the commit).
   EXPECT_EQ(url2, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(url1, controller().GetVisibleEntry()->GetURL());
   rvh()->SendNavigate(2, url2);
   EXPECT_EQ(url2, controller().GetVisibleEntry()->GetURL());
 
   // Add a transient and go forward.
-  transient_entry = new NavigationEntry;
+  transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->GetURL());
   EXPECT_TRUE(controller().CanGoForward());
   controller().GoForward();
   // We should have navigated, transient entry should be gone.
   EXPECT_EQ(url3, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(url2, controller().GetVisibleEntry()->GetURL());
   rvh()->SendNavigate(3, url3);
   EXPECT_EQ(url3, controller().GetVisibleEntry()->GetURL());
@@ skipping 26 matching lines @@
   rvh()->SendNavigate(0, url0);
 
   // For link clicks (renderer-initiated navigations), the active entry should
   // update before commit but the visible should not.
   controller().LoadURLFromRenderer(url1, content::Referrer(),
                                    content::PAGE_TRANSITION_LINK,
                                    std::string());
   EXPECT_EQ(url1, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(url0, controller().GetVisibleEntry()->GetURL());
   EXPECT_TRUE(
-      NavigationEntry::FromNavigationEntry(controller().GetPendingEntry())->
+      NavigationEntryImpl::FromNavigationEntry(controller().GetPendingEntry())->
           is_renderer_initiated());
 
   // After commit, both should be updated, and we should no longer treat the
   // entry as renderer-initiated.
   rvh()->SendNavigate(1, url1);
   EXPECT_EQ(url1, controller().GetActiveEntry()->GetURL());
   EXPECT_EQ(url1, controller().GetVisibleEntry()->GetURL());
   EXPECT_FALSE(
-      NavigationEntry::FromNavigationEntry(
+      NavigationEntryImpl::FromNavigationEntry(
           controller().GetLastCommittedEntry())->is_renderer_initiated());
 
   notifications.Reset();
 }
 
 // Tests that IsInPageNavigation returns appropriate results.  Prevents
 // regression for bug 1126349.
 TEST_F(NavigationControllerTest, IsInPageNavigation) {
   // Navigate to URL with no refs.
   const GURL url("http://www.google.com/home.html");
@@ skipping 68 matching lines @@
 
 // Make sure that cloning a tabcontents doesn't copy interstitials.
 TEST_F(NavigationControllerTest, CloneOmitsInterstitials) {
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
 
   // Add an interstitial entry.  Should be deleted with controller.
-  NavigationEntry* interstitial_entry = new NavigationEntry();
+  NavigationEntryImpl* interstitial_entry = new NavigationEntryImpl();
   interstitial_entry->set_page_type(content::PAGE_TYPE_INTERSTITIAL);
   controller().AddTransientEntry(interstitial_entry);
 
   scoped_ptr<TabContents> clone(controller().tab_contents()->Clone());
 
   ASSERT_EQ(2, clone->GetController().entry_count());
 }
 
 // Tests a subframe navigation while a toplevel navigation is pending.
 // http://crbug.com/43967
@@ skipping 37 matching lines @@
   const GURL url2("http://foo2");
   const GURL url3("http://foo3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
 
   scoped_ptr<TestTabContents> other_contents(CreateTestTabContents());
   NavigationController& other_controller = other_contents->GetController();
   other_contents->NavigateAndCommit(url3);
   other_contents->ExpectSetHistoryLengthAndPrune(
-      NavigationEntry::FromNavigationEntry(
+      NavigationEntryImpl::FromNavigationEntry(
           other_controller.GetEntryAtIndex(0))->site_instance(), 2,
       other_controller.GetEntryAtIndex(0)->GetPageID());
   other_controller.CopyStateFromAndPrune(&controller());
 
   // other_controller should now contain the 3 urls: url1, url2 and url3.
 
   ASSERT_EQ(3, other_controller.entry_count());
 
   ASSERT_EQ(2, other_controller.GetCurrentEntryIndex());
 
@@ skipping 178 matching lines @@
   const GURL transient_url("http://foo/transient");
 
   controller().LoadURL(
       url0, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url0);
   controller().LoadURL(
       url1, content::Referrer(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, url1);
 
   // Adding a transient with no pending entry.
-  NavigationEntry* transient_entry = new NavigationEntry;
+  NavigationEntryImpl* transient_entry = new NavigationEntryImpl;
   transient_entry->SetURL(transient_url);
   controller().AddTransientEntry(transient_entry);
 
   controller().PruneAllButActive();
 
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(controller().GetTransientEntry()->GetURL(), transient_url);
 }
 
@@ skipping 188 matching lines @@
   TabNavigation nav(0, url0, GURL(), string16(),
                     webkit_glue::CreateHistoryStateForURL(url0),
                     content::PAGE_TRANSITION_LINK);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[0]);
   nav.set_url(url2);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[1]);
 }
 */