Plumb the referrer throughout the OpenURL APIs....

chrome/browser/navigation_controller_unittest.cc

 // Copyright (c) 2006-2008 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/path_service.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_type.h"
 #include "chrome/browser/navigation_controller.h"
 #include "chrome/browser/navigation_entry.h"
@@ skipping 55 matching lines @@
 
   void ClearContents() {
     contents->set_delegate(NULL);
     contents->CloseContents();
     contents = NULL;
   }
 
   // TabContentsDelegate methods (only care about ReplaceContents):
   virtual void OpenURLFromTab(TabContents*,
                               const GURL&,
+                              const GURL&,
                               WindowOpenDisposition,
                               PageTransition::Type) {}
   virtual void NavigationStateChanged(const TabContents*,
                                       unsigned flags) {}
   virtual void ReplaceContents(TabContents* source,
                                TabContents* new_contents) {
     contents->set_delegate(NULL);
     contents = static_cast<TestTabContents*>(new_contents);
     contents->set_delegate(this);
   }
@@ skipping 162 matching lines @@
   EXPECT_FALSE(contents->controller()->CanGoForward());
 }
 
 TEST_F(NavigationControllerTest, LoadURL) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo1");
   const GURL url2(scheme1() + ":foo2");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   // Creating a pending notification should not have issued any of the
   // notifications we're listening for.
   EXPECT_EQ(0, notifications.size());
 
   // The load should now be pending.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 0);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), -1);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), -1);
   EXPECT_FALSE(contents->controller()->GetLastCommittedEntry());
   EXPECT_TRUE(contents->controller()->GetPendingEntry());
@@ skipping 11 matching lines @@
   EXPECT_EQ(contents->controller()->GetEntryCount(), 1);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 0);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), -1);
   EXPECT_TRUE(contents->controller()->GetLastCommittedEntry());
   EXPECT_FALSE(contents->controller()->GetPendingEntry());
   EXPECT_FALSE(contents->controller()->CanGoBack());
   EXPECT_FALSE(contents->controller()->CanGoForward());
   EXPECT_EQ(contents->GetMaxPageID(), 0);
 
   // Load another...
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
 
   // The load should now be pending.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 1);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 0);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), -1);
   EXPECT_TRUE(contents->controller()->GetLastCommittedEntry());
   EXPECT_TRUE(contents->controller()->GetPendingEntry());
   // TODO(darin): maybe this should really be true?
   EXPECT_FALSE(contents->controller()->CanGoBack());
   EXPECT_FALSE(contents->controller()->CanGoForward());
@@ skipping 16 matching lines @@
 // Tests what happens when the same page is loaded again.  Should not create a
 // new session history entry. This is what happens when you press enter in the
 // URL bar to reload: a pending entry is created and then it is discarded when
 // the load commits (because WebCore didn't actually make a new entry).
 TEST_F(NavigationControllerTest, LoadURL_SamePage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo1");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0, notifications.size());
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0, notifications.size());
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   // We should not have produced a new session history entry.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 1);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 0);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), -1);
   EXPECT_TRUE(contents->controller()->GetLastCommittedEntry());
   EXPECT_FALSE(contents->controller()->GetPendingEntry());
   EXPECT_FALSE(contents->controller()->CanGoBack());
   EXPECT_FALSE(contents->controller()->CanGoForward());
 }
 
 // Tests loading a URL but discarding it before the load commits.
 TEST_F(NavigationControllerTest, LoadURL_Discarded) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo1");
   const GURL url2(scheme1() + ":foo2");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0, notifications.size());
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
   contents->controller()->DiscardNonCommittedEntries();
   EXPECT_EQ(0, notifications.size());
 
   // Should not have produced a new session history entry.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 1);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 0);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), -1);
   EXPECT_TRUE(contents->controller()->GetLastCommittedEntry());
   EXPECT_FALSE(contents->controller()->GetPendingEntry());
   EXPECT_FALSE(contents->controller()->CanGoBack());
   EXPECT_FALSE(contents->controller()->CanGoForward());
 }
 
 // Tests navigations that come in unrequested. This happens when the user
 // navigates from the web page, and here we test that there is no pending entry.
 TEST_F(NavigationControllerTest, LoadURL_NoPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   // First make an existing committed entry.
   const GURL kExistingURL1(scheme1() + ":eh");
-  contents->controller()->LoadURL(kExistingURL1, PageTransition::TYPED);
+  contents->controller()->LoadURL(kExistingURL1, GURL(),
+                                  PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
         
   // Do a new navigation without making a pending one.
   const GURL kNewURL(scheme1() + ":see");
   contents->CompleteNavigationAsRenderer(99, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, contents->controller()->GetPendingEntryIndex());
   EXPECT_EQ(1, contents->controller()->GetLastCommittedEntryIndex());
   EXPECT_EQ(kNewURL, contents->controller()->GetActiveEntry()->url());
 }
 
 // Tests navigating to a new URL when there is a new pending navigation that is
 // not the one that just loaded. This will happen if the user types in a URL to
 // somewhere slow, and then navigates the current page before the typed URL
 // commits.
 TEST_F(NavigationControllerTest, LoadURL_NewPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   // First make an existing committed entry.
   const GURL kExistingURL1(scheme1() + ":eh");
-  contents->controller()->LoadURL(kExistingURL1, PageTransition::TYPED);
+  contents->controller()->LoadURL(kExistingURL1, GURL(),
+                                  PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   // Make a pending entry to somewhere new.
   const GURL kExistingURL2(scheme1() + ":bee");
-  contents->controller()->LoadURL(kExistingURL2, PageTransition::TYPED);
+  contents->controller()->LoadURL(kExistingURL2, GURL(),
+                                  PageTransition::TYPED);
   EXPECT_EQ(0, notifications.size());
 
   // Before that commits, do a new navigation.
   const GURL kNewURL(scheme1() + ":see");
   contents->CompleteNavigationAsRenderer(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, contents->controller()->GetPendingEntryIndex());
   EXPECT_EQ(1, contents->controller()->GetLastCommittedEntryIndex());
   EXPECT_EQ(kNewURL, contents->controller()->GetActiveEntry()->url());
 }
 
 // Tests navigating to a new URL when there is a pending back/forward
 // navigation. This will happen if the user hits back, but before that commits,
 // they navigate somewhere new.
 TEST_F(NavigationControllerTest, LoadURL_ExistingPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   // First make some history.
   const GURL kExistingURL1(scheme1() + ":eh");
-  contents->controller()->LoadURL(kExistingURL1, PageTransition::TYPED);
+  contents->controller()->LoadURL(kExistingURL1, GURL(),
+                                  PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   const GURL kExistingURL2(scheme1() + ":bee");
-  contents->controller()->LoadURL(kExistingURL2, PageTransition::TYPED);
+  contents->controller()->LoadURL(kExistingURL2, GURL(),
+                                  PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   // Now make a pending back/forward navigation. The zeroth entry should be
   // pending.
   contents->controller()->GoBack();
   EXPECT_EQ(0, notifications.size());
   EXPECT_EQ(0, contents->controller()->GetPendingEntryIndex());
   EXPECT_EQ(1, contents->controller()->GetLastCommittedEntryIndex());
 
   // Before that commits, do a new navigation.
   const GURL kNewURL(scheme1() + ":see");
   NavigationController::LoadCommittedDetails details;
   contents->CompleteNavigationAsRenderer(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, contents->controller()->GetPendingEntryIndex());
   EXPECT_EQ(2, contents->controller()->GetLastCommittedEntryIndex());
   EXPECT_EQ(kNewURL, contents->controller()->GetActiveEntry()->url());
 }
 
 TEST_F(NavigationControllerTest, Reload) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo1");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0, notifications.size());
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   contents->controller()->Reload();
   EXPECT_EQ(0, notifications.size());
 
   // The reload is pending.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 1);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 0);
@@ skipping 17 matching lines @@
 }
 
 // Tests what happens when a reload navigation produces a new page.
 TEST_F(NavigationControllerTest, Reload_GeneratesNewPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo1");
   const GURL url2(scheme1() + ":foo2");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   contents->controller()->Reload();
   EXPECT_EQ(0, notifications.size());
 
   contents->CompleteNavigationAsRenderer(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   // Now the reload is committed.
@@ skipping 46 matching lines @@
 
 // Tests what happens when a back navigation produces a new page.
 TEST_F(NavigationControllerTest, Back_GeneratesNewPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo1");
   const GURL url2(scheme1() + ":foo2");
   const GURL url3(scheme1() + ":foo3");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   contents->controller()->GoBack();
   EXPECT_EQ(0, notifications.size());
 
   // We should now have a pending navigation to go back.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 2);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 1);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), 0);
@@ skipping 27 matching lines @@
 
   // First navigate two places so we have some back history.
   contents->CompleteNavigationAsRenderer(0, kUrl1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   //contents->controller()->LoadURL(kUrl2, PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(1, kUrl2);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   // Now start a new pending navigation and go back before it commits.
-  contents->controller()->LoadURL(kUrl3, PageTransition::TYPED);
+  contents->controller()->LoadURL(kUrl3, GURL(), PageTransition::TYPED);
   EXPECT_EQ(-1, contents->controller()->GetPendingEntryIndex());
   EXPECT_EQ(kUrl3, contents->controller()->GetPendingEntry()->url());
   contents->controller()->GoBack();
 
   // The pending navigation should now be the "back" item and the new one
   // should be gone.
   EXPECT_EQ(0, contents->controller()->GetPendingEntryIndex());
   EXPECT_EQ(kUrl1, contents->controller()->GetPendingEntry()->url());
 }
 
@@ skipping 365 matching lines @@
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo");
   const GURL url2(scheme2() + ":foo");
 
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   TestTabContents* initial_contents = contents;
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
 
   // The tab contents should have been replaced
   ASSERT_TRUE(initial_contents != contents);
 
   contents->CompleteNavigationAsRenderer(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   // A second navigation entry should have been committed even though the
   // PageIDs are the same.  PageIDs are scoped to the tab contents type.
   EXPECT_EQ(contents->controller()->GetEntryCount(), 2);
@@ skipping 29 matching lines @@
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url1(scheme1() + ":foo");
   const GURL url2(scheme2() + ":foo");
 
   contents->CompleteNavigationAsRenderer(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(NOTIFY_NAV_ENTRY_COMMITTED));
 
   TestTabContents* initial_contents = contents;
 
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0, notifications.size());
 
   // The tab contents should have been replaced
   ASSERT_TRUE(initial_contents != contents);
 
   contents->controller()->DiscardNonCommittedEntries();
   EXPECT_EQ(0, notifications.size());
 
   // The tab contents should have been replaced back
   ASSERT_TRUE(initial_contents == contents);
@@ skipping 13 matching lines @@
 // Tests that TabContentsTypes that are not in use are deleted (via a
 // TabContentsCollector task).  Prevents regression of bug 1296773.
 TEST_F(NavigationControllerTest, SwitchTypesCleanup) {
   const GURL url1(scheme1() + ":foo");
   const GURL url2(scheme2() + ":foo");
   const GURL url3(scheme2() + ":bar");
 
   // Note that we need the LoadURL calls so that pending entries and the
   // different tab contents types are created. "Renderer" navigations won't
   // actually cross tab contents boundaries without these.
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, url1);
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(1, url2);
-  contents->controller()->LoadURL(url3, PageTransition::TYPED);
+  contents->controller()->LoadURL(url3, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(2, url3);
 
   // Navigate back to the start.
   contents->controller()->GoToIndex(0);
   contents->CompleteNavigationAsRenderer(0, url1);
 
   // Now jump to the end.
   contents->controller()->GoToIndex(2);
   contents->CompleteNavigationAsRenderer(2, url3);
 
@@ skipping 48 matching lines @@
   const size_t kMaxEntryCount = 5;
 
   NavigationController::set_max_entry_count(kMaxEntryCount);
 
   int url_index;
   char buffer[128];
   // Load up to the max count, all entries should be there.
   for (url_index = 0; url_index < kMaxEntryCount; url_index++) {
     SNPrintF(buffer, 128, (scheme1() + "://www.a.com/%d").c_str(), url_index);
     GURL url(buffer);
-    contents->controller()->LoadURL(url, PageTransition::TYPED);
+    contents->controller()->LoadURL(url, GURL(), PageTransition::TYPED);
     contents->CompleteNavigationAsRenderer(url_index, url);
   }
 
   EXPECT_EQ(contents->controller()->GetEntryCount(), kMaxEntryCount);
 
   // Created a PrunedListener to observe prune notifications.
   PrunedListener listener(contents->controller());
 
   // Navigate some more.
   SNPrintF(buffer, 128, (scheme1() + "://www.a.com/%d").c_str(), url_index);
   GURL url(buffer);
-  contents->controller()->LoadURL(url, PageTransition::TYPED);
+  contents->controller()->LoadURL(url, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(url_index, url);
   url_index++;
 
   // We should have got a pruned navigation.
   EXPECT_EQ(1, listener.notification_count_);
   EXPECT_TRUE(listener.details_.from_front);
   EXPECT_EQ(1, listener.details_.count);
 
   // We expect http://www.a.com/0 to be gone.
   EXPECT_EQ(contents->controller()->GetEntryCount(), kMaxEntryCount);
   EXPECT_EQ(contents->controller()->GetEntryAtIndex(0)->url(),
             GURL(scheme1() + "://www.a.com/1"));
 
   // More navigations.
   for (int i = 0; i < 3; i++) {
     SNPrintF(buffer, 128, (scheme1() + "://www.a.com/%d").c_str(), url_index);
     url = GURL(buffer);
-    contents->controller()->LoadURL(url, PageTransition::TYPED);
+    contents->controller()->LoadURL(url, GURL(), PageTransition::TYPED);
       contents->CompleteNavigationAsRenderer(url_index, url);
     url_index++;
   }
   EXPECT_EQ(contents->controller()->GetEntryCount(), kMaxEntryCount);
   EXPECT_EQ(contents->controller()->GetEntryAtIndex(0)->url(),
             GURL(scheme1() + "://www.a.com/4"));
 
   NavigationController::set_max_entry_count(original_count);
 }
 
@@ skipping 43 matching lines @@
   ClearContents();
   controller->Destroy();
   TestTabContents::set_site_instance(NULL);
   site_instance->Release();
 }
 
 // Make sure that the page type and stuff is correct after an interstitial.
 TEST_F(NavigationControllerTest, Interstitial) {
   // First navigate somewhere normal.
   const GURL url1(scheme1() + ":foo");
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, url1);
 
   // Now navigate somewhere with an interstitial.
   const GURL url2(scheme1() + ":bar");
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->controller()->GetPendingEntry()->set_page_type(
       NavigationEntry::INTERSTITIAL_PAGE);
 
   // At this point the interstitial will be displayed and the load will still
   // be pending. If the user continues, the load will commit.
   contents->CompleteNavigationAsRenderer(1, url2);
 
   // The page should be a normal page again.
   EXPECT_EQ(url2, contents->controller()->GetLastCommittedEntry()->url());
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE,
             contents->controller()->GetLastCommittedEntry()->page_type());
 }
 
 TEST_F(NavigationControllerTest, RemoveEntry) {
   const GURL url1(scheme1() + ":foo1");
   const GURL url2(scheme1() + ":foo2");
   const GURL url3(scheme1() + ":foo3");
   const GURL url4(scheme1() + ":foo4");
   const GURL url5(scheme1() + ":foo5");
   const GURL pending_url(scheme1() + ":pending");
   const GURL default_url(scheme1() + ":default");
 
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, url1);
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(1, url2);
-  contents->controller()->LoadURL(url3, PageTransition::TYPED);
+  contents->controller()->LoadURL(url3, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(2, url3);
-  contents->controller()->LoadURL(url4, PageTransition::TYPED);
+  contents->controller()->LoadURL(url4, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(3, url4);
-  contents->controller()->LoadURL(url5, PageTransition::TYPED);
+  contents->controller()->LoadURL(url5, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(4, url5);
 
   // Remove the last entry.
   contents->controller()->RemoveEntryAtIndex(
       contents->controller()->GetEntryCount() - 1, default_url);
   EXPECT_EQ(4, contents->controller()->GetEntryCount());
   EXPECT_EQ(3, contents->controller()->GetLastCommittedEntryIndex());
   NavigationEntry* pending_entry = contents->controller()->GetPendingEntry();
   EXPECT_TRUE(pending_entry && pending_entry->url() == url4);
 
   // Add a pending entry.
-  contents->controller()->LoadURL(pending_url, PageTransition::TYPED);
+  contents->controller()->LoadURL(pending_url, GURL(), PageTransition::TYPED);
   // Now remove the last entry.
   contents->controller()->RemoveEntryAtIndex(
       contents->controller()->GetEntryCount() - 1, default_url);
   // The pending entry should have been discarded and the last committed entry
   // removed.
   EXPECT_EQ(3, contents->controller()->GetEntryCount());
   EXPECT_EQ(2, contents->controller()->GetLastCommittedEntryIndex());
   pending_entry = contents->controller()->GetPendingEntry();
   EXPECT_TRUE(pending_entry && pending_entry->url() == url3);
 
@@ skipping 21 matching lines @@
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, contents->controller());
 
   const GURL url0(scheme1() + ":foo0");
   const GURL url1(scheme1() + ":foo1");
   const GURL url2(scheme1() + ":foo2");
   const GURL url3(scheme1() + ":foo3");
   const GURL url4(scheme1() + ":foo4");
   const GURL transient_url(scheme1() + ":transient");
 
-  contents->controller()->LoadURL(url0, PageTransition::TYPED);
+  contents->controller()->LoadURL(url0, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(0, url0);
-  contents->controller()->LoadURL(url1, PageTransition::TYPED);
+  contents->controller()->LoadURL(url1, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(1, url1);
 
   notifications.Reset();
 
   // Adding a transient with no pending entry.
   NavigationEntry* transient_entry = new NavigationEntry(TAB_CONTENTS_WEB);
   transient_entry->set_url(transient_url);
   contents->controller()->AddTransientEntry(transient_entry);
 
   // We should not have received any notifications.
   EXPECT_EQ(0, notifications.size());
 
   // Check our state.
   EXPECT_EQ(transient_url, contents->controller()->GetActiveEntry()->url());
   EXPECT_EQ(contents->controller()->GetEntryCount(), 3);
   EXPECT_EQ(contents->controller()->GetLastCommittedEntryIndex(), 1);
   EXPECT_EQ(contents->controller()->GetPendingEntryIndex(), -1);
   EXPECT_TRUE(contents->controller()->GetLastCommittedEntry());
   EXPECT_FALSE(contents->controller()->GetPendingEntry());
   EXPECT_TRUE(contents->controller()->CanGoBack());
   EXPECT_FALSE(contents->controller()->CanGoForward());
   EXPECT_EQ(contents->GetMaxPageID(), 1);
 
   // Navigate.
-  contents->controller()->LoadURL(url2, PageTransition::TYPED);
+  contents->controller()->LoadURL(url2, GURL(), PageTransition::TYPED);
   contents->CompleteNavigationAsRenderer(2, url2);
 
   // We should have navigated, transient entry should be gone.
   EXPECT_EQ(url2, contents->controller()->GetActiveEntry()->url());
   EXPECT_EQ(contents->controller()->GetEntryCount(), 3);
   
   // Add a transient again, then navigate with no pending entry this time.
   transient_entry = new NavigationEntry(TAB_CONTENTS_WEB);
   transient_entry->set_url(transient_url);
   contents->controller()->AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, contents->controller()->GetActiveEntry()->url());
   contents->CompleteNavigationAsRenderer(3, url3);
   // Transient entry should be gone.
   EXPECT_EQ(url3, contents->controller()->GetActiveEntry()->url());
   EXPECT_EQ(contents->controller()->GetEntryCount(), 4);
 
   // Initiate a navigation, add a transient then commit navigation.
-  contents->controller()->LoadURL(url4, PageTransition::TYPED);
+  contents->controller()->LoadURL(url4, GURL(), PageTransition::TYPED);
   transient_entry = new NavigationEntry(TAB_CONTENTS_WEB);
   transient_entry->set_url(transient_url);
   contents->controller()->AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, contents->controller()->GetActiveEntry()->url());
   contents->CompleteNavigationAsRenderer(4, url4);
   EXPECT_EQ(url4, contents->controller()->GetActiveEntry()->url());
   EXPECT_EQ(contents->controller()->GetEntryCount(), 5);
 
   // Add a transient and go back.  This should simply remove the transient.
   transient_entry = new NavigationEntry(TAB_CONTENTS_WEB);
@@ skipping 72 matching lines @@
   EXPECT_FALSE(contents->controller()->IsURLInPageNavigation(url));
   EXPECT_FALSE(contents->controller()->IsURLInPageNavigation(other_url));
   const GURL other_url_with_ref("http://www.google.com/home.html#my_other_ref");
   EXPECT_TRUE(contents->controller()->IsURLInPageNavigation(
       other_url_with_ref));
 }
 
 // A basic test case. Navigates to a single url, and make sure the history
 // db matches.
 TEST_F(NavigationControllerHistoryTest, Basic) {
-  contents->controller()->LoadURL(url0, PageTransition::LINK);
+  contents->controller()->LoadURL(url0, GURL(), PageTransition::LINK);
   contents->CompleteNavigationAsRenderer(0, url0);
 
   GetLastSession();
 
   helper_.AssertSingleWindowWithSingleTab(windows_, 1);
   helper_.AssertTabEquals(0, 0, 1, *(windows_[0]->tabs[0]));
   TabNavigation nav1(0, url0, std::wstring(), std::string(),
                      PageTransition::LINK);
   helper_.AssertNavigationEquals(nav1, windows_[0]->tabs[0]->navigations[0]);
 }
@@ skipping 42 matching lines @@
 
   helper_.AssertSingleWindowWithSingleTab(windows_, 2);
   helper_.AssertTabEquals(0, 1, 2, *(windows_[0]->tabs[0]));
 
   TabNavigation nav(0, url0, std::wstring(), std::string(),
                     PageTransition::LINK);
   helper_.AssertNavigationEquals(nav, windows_[0]->tabs[0]->navigations[0]);
   nav.url = url2;
   helper_.AssertNavigationEquals(nav, windows_[0]->tabs[0]->navigations[1]);
 }