Move PageTransition into content namespace. While I'm touching all these files, I've also updated...

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"
@@ skipping 72 matching lines @@
   EXPECT_FALSE(controller().CanGoForward());
 }
 
 TEST_F(NavigationControllerTest, LoadURL) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   // Creating a pending notification should not have issued any of the
   // notifications we're listening for.
   EXPECT_EQ(0U, notifications.size());
 
   // The load should now be pending.
   EXPECT_EQ(controller().entry_count(), 0);
   EXPECT_EQ(controller().last_committed_entry_index(), -1);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_FALSE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
@@ skipping 12 matching lines @@
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), 0);
 
   // Load another...
-  controller().LoadURL(url2, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url2, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
 
   // The load should now be pending.
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   // TODO(darin): maybe this should really be true?
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
@@ skipping 20 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, &controller());
 
   const GURL url1("http://foo1");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // We should not have produced a new session history entry.
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
 }
 
 // Tests loading a URL but discarding it before the load commits.
 TEST_F(NavigationControllerTest, LoadURL_Discarded) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
-  controller().LoadURL(url2, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url2, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   controller().DiscardNonCommittedEntries();
   EXPECT_EQ(0U, notifications.size());
 
   // Should not have produced a new session history entry.
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(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, &controller());
 
   // First make an existing committed entry.
   const GURL kExistingURL1("http://eh");
   controller().LoadURL(kExistingURL1, GURL(),
-                       PageTransition::TYPED, std::string());
+                       content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Do a new navigation without making a pending one.
   const GURL kNewURL("http://see");
   rvh()->SendNavigate(99, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
   EXPECT_EQ(kNewURL, 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, &controller());
 
   // First make an existing committed entry.
   const GURL kExistingURL1("http://eh");
   controller().LoadURL(kExistingURL1, GURL(),
-                       PageTransition::TYPED, std::string());
+                       content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Make a pending entry to somewhere new.
   const GURL kExistingURL2("http://bee");
   controller().LoadURL(kExistingURL2, GURL(),
-                       PageTransition::TYPED, std::string());
+                       content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
 
   // After the beforeunload but before it commits, do a new navigation.
   rvh()->SendShouldCloseACK(true);
   const GURL kNewURL("http://see");
   contents()->pending_rvh()->SendNavigate(3, kNewURL);
 
   // There should no longer be any pending entry, and the third navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
   EXPECT_EQ(kNewURL, 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, &controller());
 
   // First make some history.
   const GURL kExistingURL1("http://foo/eh");
   controller().LoadURL(kExistingURL1, GURL(),
-                       PageTransition::TYPED, std::string());
+                       content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL kExistingURL2("http://foo/bee");
   controller().LoadURL(kExistingURL2, GURL(),
-                       PageTransition::TYPED, std::string());
+                       content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now make a pending back/forward navigation. The zeroth entry should be
   // pending.
   controller().GoBack();
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(0, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
@@ skipping 14 matching lines @@
 
 // Tests navigating to an existing URL when there is a pending new navigation.
 // This will happen if the user enters a URL, but before that commits, the
 // current page fires history.back().
 TEST_F(NavigationControllerTest, LoadURL_BackPreemptsPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // First make some history.
   const GURL kExistingURL1("http://foo/eh");
-  controller().LoadURL(kExistingURL1, GURL(), PageTransition::TYPED,
+  controller().LoadURL(kExistingURL1, GURL(), content::PAGE_TRANSITION_TYPED,
                        std::string());
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL kExistingURL2("http://foo/bee");
-  controller().LoadURL(kExistingURL2, GURL(), PageTransition::TYPED,
+  controller().LoadURL(kExistingURL2, GURL(), content::PAGE_TRANSITION_TYPED,
                        std::string());
   rvh()->SendNavigate(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now make a pending new navigation.
   const GURL kNewURL("http://foo/see");
-  controller().LoadURL(kNewURL, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      kNewURL, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(1, controller().last_committed_entry_index());
 
   // Before that commits, a back navigation from the renderer commits.
   rvh()->SendNavigate(0, kExistingURL1);
 
   // There should no longer be any pending entry, and the back navigation we
   // just made should be committed.
   EXPECT_TRUE(notifications.Check1AndReset(
@@ skipping 13 matching lines @@
   // Set a TabContentsDelegate to listen for state changes.
   scoped_ptr<TestTabContentsDelegate> delegate(new TestTabContentsDelegate());
   EXPECT_FALSE(contents()->delegate());
   contents()->set_delegate(delegate.get());
 
   // Without any navigations, the renderer starts at about:blank.
   const GURL kExistingURL("about:blank");
 
   // Now make a pending new navigation.
   const GURL kNewURL("http://eh");
-  controller().LoadURL(kNewURL, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      kNewURL, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_EQ(-1, controller().last_committed_entry_index());
   EXPECT_EQ(1, delegate->navigation_state_change_count());
 
   // Before that commits, a document.write and location.reload can cause the
   // renderer to send a FrameNavigate with page_id -1.
   rvh()->SendNavigate(-1, kExistingURL);
 
@@ skipping 15 matching lines @@
   // Set a TabContentsDelegate to listen for state changes.
   scoped_ptr<TestTabContentsDelegate> delegate(new TestTabContentsDelegate());
   EXPECT_FALSE(contents()->delegate());
   contents()->set_delegate(delegate.get());
 
   // Without any navigations, the renderer starts at about:blank.
   const GURL kExistingURL("about:blank");
 
   // Now make a pending new navigation.
   const GURL kNewURL("http://eh");
-  controller().LoadURL(kNewURL, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      kNewURL, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_EQ(-1, controller().last_committed_entry_index());
   EXPECT_EQ(1, delegate->navigation_state_change_count());
 
   // It may abort before committing, if it's a download or due to a stop or
   // a new navigation from the user.
   ViewHostMsg_DidFailProvisionalLoadWithError_Params params;
   params.frame_id = 1;
@@ skipping 25 matching lines @@
   // Set a TabContentsDelegate to listen for state changes.
   scoped_ptr<TestTabContentsDelegate> delegate(new TestTabContentsDelegate());
   EXPECT_FALSE(contents()->delegate());
   contents()->set_delegate(delegate.get());
 
   // Without any navigations, the renderer starts at about:blank.
   const GURL kExistingURL("about:blank");
 
   // Now make a pending new navigation.
   const GURL kNewURL("http://eh");
-  controller().LoadURL(kNewURL, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      kNewURL, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_EQ(-1, controller().last_committed_entry_index());
   EXPECT_EQ(1, delegate->navigation_state_change_count());
 
   // Now the navigation redirects.
   const GURL kRedirectURL("http://bee");
   rvh()->TestOnMessageReceived(
       ViewHostMsg_DidRedirectProvisionalLoad(0,  // routing_id
@@ skipping 28 matching lines @@
 
   contents()->set_delegate(NULL);
 }
 
 TEST_F(NavigationControllerTest, Reload) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().Reload(true);
   EXPECT_EQ(0U, notifications.size());
 
   // The reload is pending.
   EXPECT_EQ(controller().entry_count(), 1);
@@ skipping 19 matching lines @@
 }
 
 // Tests what happens when a reload navigation produces a new page.
 TEST_F(NavigationControllerTest, Reload_GeneratesNewPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().Reload(true);
   EXPECT_EQ(0U, notifications.size());
 
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
@@ skipping 51 matching lines @@
 
 // Tests what happens when a back navigation produces a new page.
 TEST_F(NavigationControllerTest, Back_GeneratesNewPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo/1");
   const GURL url2("http://foo/2");
   const GURL url3("http://foo/3");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
-  controller().LoadURL(url2, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url2, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().GoBack();
   EXPECT_EQ(0U, notifications.size());
 
   // We should now have a pending navigation to go back.
   EXPECT_EQ(controller().entry_count(), 2);
   EXPECT_EQ(controller().last_committed_entry_index(), 1);
@@ skipping 25 matching lines @@
 
   const GURL kUrl1("http://foo1");
   const GURL kUrl2("http://foo2");
   const GURL kUrl3("http://foo3");
 
   // First navigate two places so we have some back history.
   rvh()->SendNavigate(0, kUrl1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
-  // controller().LoadURL(kUrl2, PageTransition::TYPED);
+  // controller().LoadURL(kUrl2, content::PAGE_TRANSITION_TYPED);
   rvh()->SendNavigate(1, kUrl2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now start a new pending navigation and go back before it commits.
-  controller().LoadURL(kUrl3, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      kUrl3, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(kUrl3, controller().pending_entry()->url());
   controller().GoBack();
 
   // The pending navigation should now be the "back" item and the new one
   // should be gone.
   EXPECT_EQ(0, controller().pending_entry_index());
   EXPECT_EQ(kUrl1, controller().pending_entry()->url());
 }
 
@@ skipping 140 matching lines @@
 // Two consequent navigation for the same URL entered in should be considered
 // as SAME_PAGE navigation even when we are redirected to some other page.
 TEST_F(NavigationControllerTest, Redirect) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");  // Redirection target
 
   // First request
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
 
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Second request
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
 
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_EQ(url1, controller().GetActiveEntry()->url());
 
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = url2;
-  params.transition = PageTransition::SERVER_REDIRECT;
+  params.transition = content::PAGE_TRANSITION_SERVER_REDIRECT;
   params.redirects.push_back(GURL("http://foo1"));
   params.redirects.push_back(GURL("http://foo2"));
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url2));
 
   content::LoadCommittedDetails details;
 
   EXPECT_EQ(0U, notifications.size());
@@ skipping 17 matching lines @@
 // the second URL is requested by GET. NavigationEntry::has_post_data_
 // must be cleared. http://crbug.com/21245
 TEST_F(NavigationControllerTest, PostThenRedirect) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");  // Redirection target
 
   // First request as POST
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   controller().GetActiveEntry()->set_has_post_data(true);
 
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Second request
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
 
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_EQ(url1, controller().GetActiveEntry()->url());
 
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = url2;
-  params.transition = PageTransition::SERVER_REDIRECT;
+  params.transition = content::PAGE_TRANSITION_SERVER_REDIRECT;
   params.redirects.push_back(GURL("http://foo1"));
   params.redirects.push_back(GURL("http://foo2"));
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url2));
 
   content::LoadCommittedDetails details;
 
   EXPECT_EQ(0U, notifications.size());
@@ skipping 16 matching lines @@
 
 // A redirect right off the bat should be a NEW_PAGE.
 TEST_F(NavigationControllerTest, ImmediateRedirect) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");  // Redirection target
 
   // First request
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
 
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_EQ(url1, controller().GetActiveEntry()->url());
 
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = url2;
-  params.transition = PageTransition::SERVER_REDIRECT;
+  params.transition = content::PAGE_TRANSITION_SERVER_REDIRECT;
   params.redirects.push_back(GURL("http://foo1"));
   params.redirects.push_back(GURL("http://foo2"));
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url2));
 
   content::LoadCommittedDetails details;
 
   EXPECT_EQ(0U, notifications.size());
@@ skipping 21 matching lines @@
 
   const GURL url1("http://foo1");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL url2("http://foo2");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 1;
   params.url = url2;
-  params.transition = PageTransition::MANUAL_SUBFRAME;
+  params.transition = content::PAGE_TRANSITION_MANUAL_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url2));
 
   content::LoadCommittedDetails details;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(url1, details.previous_url);
@@ skipping 14 matching lines @@
 // just get thrown on the ground, but we shouldn't crash.
 TEST_F(NavigationControllerTest, SubframeOnEmptyPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // Navigation controller currently has no entries.
   const GURL url("http://foo2");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 1;
   params.url = url;
-  params.transition = PageTransition::AUTO_SUBFRAME;
+  params.transition = content::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url));
 
   content::LoadCommittedDetails details;
   EXPECT_FALSE(controller().RendererDidNavigate(params, &details));
   EXPECT_EQ(0U, notifications.size());
 }
 
 // Auto subframes are ones the page loads automatically like ads. They should
 // not create new navigation entries.
 TEST_F(NavigationControllerTest, AutoSubframe) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL url2("http://foo2");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = url2;
-  params.transition = PageTransition::AUTO_SUBFRAME;
+  params.transition = content::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url2));
 
   // Navigating should do nothing.
   content::LoadCommittedDetails details;
   EXPECT_FALSE(controller().RendererDidNavigate(params, &details));
   EXPECT_EQ(0U, notifications.size());
 
@@ skipping 10 matching lines @@
   const GURL url1("http://foo1");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // First manual subframe navigation.
   const GURL url2("http://foo2");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 1;
   params.url = url2;
-  params.transition = PageTransition::MANUAL_SUBFRAME;
+  params.transition = content::PAGE_TRANSITION_MANUAL_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureUser;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url2));
 
   // This should generate a new entry.
   content::LoadCommittedDetails details;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
@@ skipping 63 matching lines @@
   const GURL url1("http://foo");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // First navigation.
   const GURL url2("http://foo#a");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 1;
   params.url = url2;
-  params.transition = PageTransition::LINK;
+  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(url2));
 
   // This should generate a new entry.
   content::LoadCommittedDetails details;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
@@ skipping 60 matching lines @@
   const GURL url1("http://foo");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // First navigation.
   const GURL url2("http://foo#a");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;  // Same page_id
   params.url = url2;
-  params.transition = PageTransition::LINK;
+  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(url2));
 
   // This should NOT generate a new entry, nor prune the list.
   content::LoadCommittedDetails details;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
@@ skipping 28 matching lines @@
     EXPECT_TRUE(notifications.Check1AndReset(
         content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   }
 
   // Navigate within the page.
   {
     const GURL url("http://foo2/#a");
     ViewHostMsg_FrameNavigate_Params params;
     params.page_id = 1;  // Same page_id
     params.url = url;
-    params.transition = PageTransition::LINK;
+    params.transition = content::PAGE_TRANSITION_LINK;
     params.redirects.push_back(url);
     params.should_update_history = true;
     params.gesture = NavigationGestureUnknown;
     params.is_post = false;
     params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url));
 
     // This should NOT generate a new entry, nor prune the list.
     content::LoadCommittedDetails details;
     EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
     EXPECT_TRUE(notifications.Check1AndReset(
       content::NOTIFICATION_NAV_ENTRY_COMMITTED));
     EXPECT_TRUE(details.is_in_page);
     EXPECT_TRUE(details.did_replace_entry);
     EXPECT_EQ(2, controller().entry_count());
   }
 
   // Perform a client redirect to a new page.
   {
     const GURL url("http://foo3/");
     ViewHostMsg_FrameNavigate_Params params;
     params.page_id = 2;  // New page_id
     params.url = url;
-    params.transition = PageTransition::CLIENT_REDIRECT;
+    params.transition = content::PAGE_TRANSITION_CLIENT_REDIRECT;
     params.redirects.push_back(GURL("http://foo2/#a"));
     params.redirects.push_back(url);
     params.should_update_history = true;
     params.gesture = NavigationGestureUnknown;
     params.is_post = false;
     params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url));
 
     // This SHOULD generate a new entry.
     content::LoadCommittedDetails details;
     EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
@@ skipping 49 matching lines @@
 TEST_F(NavigationControllerTest, EnforceMaxNavigationCount) {
   size_t original_count = NavigationController::max_entry_count();
   const int kMaxEntryCount = 5;
 
   NavigationController::set_max_entry_count_for_testing(kMaxEntryCount);
 
   int url_index;
   // Load up to the max count, all entries should be there.
   for (url_index = 0; url_index < kMaxEntryCount; url_index++) {
     GURL url(StringPrintf("http://www.a.com/%d", url_index));
-    controller().LoadURL(url, GURL(), PageTransition::TYPED, std::string());
+    controller().LoadURL(
+        url, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
     rvh()->SendNavigate(url_index, url);
   }
 
   EXPECT_EQ(controller().entry_count(), kMaxEntryCount);
 
   // Created a PrunedListener to observe prune notifications.
   PrunedListener listener(&controller());
 
   // Navigate some more.
   GURL url(StringPrintf("http://www.a.com/%d", url_index));
-  controller().LoadURL(url, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(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(controller().entry_count(), kMaxEntryCount);
   EXPECT_EQ(controller().GetEntryAtIndex(0)->url(),
             GURL("http:////www.a.com/1"));
 
   // More navigations.
   for (int i = 0; i < 3; i++) {
     url = GURL(StringPrintf("http:////www.a.com/%d", url_index));
-    controller().LoadURL(url, GURL(), PageTransition::TYPED, std::string());
-      rvh()->SendNavigate(url_index, url);
+    controller().LoadURL(
+        url, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
+    rvh()->SendNavigate(url_index, url);
     url_index++;
   }
   EXPECT_EQ(controller().entry_count(), kMaxEntryCount);
   EXPECT_EQ(controller().GetEntryAtIndex(0)->url(),
             GURL("http:////www.a.com/4"));
 
   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<NavigationEntry*> entries;
   NavigationEntry* entry = NavigationController::CreateNavigationEntry(
-      url, GURL(), PageTransition::RELOAD, std::string(), profile());
+      url, GURL(), content::PAGE_TRANSITION_RELOAD, std::string(), profile());
   entry->set_page_id(0);
   entry->set_title(ASCIIToUTF16("Title"));
   entry->set_content_state("state");
   entries.push_back(entry);
   TabContents our_contents(profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   NavigationController& our_controller = our_contents.controller();
   our_controller.Restore(0, true, &entries);
   ASSERT_EQ(0u, entries.size());
 
   // Before navigating to the restored entry, it should have a restore_type
@@ skipping 10 matching lines @@
             our_controller.pending_entry());
   EXPECT_EQ(0, our_controller.GetEntryAtIndex(0)->page_id());
   EXPECT_EQ(NavigationEntry::RESTORE_NONE,
             our_controller.GetEntryAtIndex(0)->restore_type());
   EXPECT_TRUE(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 = PageTransition::LINK;
+  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.pending_entry());
   EXPECT_EQ(url,
             our_controller.GetLastCommittedEntry()->site_instance()->site());
   EXPECT_EQ(NavigationEntry::RESTORE_NONE,
             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<NavigationEntry*> entries;
   NavigationEntry* entry = NavigationController::CreateNavigationEntry(
-      url, GURL(), PageTransition::RELOAD, std::string(), profile());
+      url, GURL(), content::PAGE_TRANSITION_RELOAD, std::string(), profile());
   entry->set_page_id(0);
   entry->set_title(ASCIIToUTF16("Title"));
   entry->set_content_state("state");
   entries.push_back(entry);
   TabContents our_contents(profile(), NULL, MSG_ROUTING_NONE, NULL, NULL);
   NavigationController& our_controller = our_contents.controller();
   our_controller.Restore(0, true, &entries);
   ASSERT_EQ(0u, entries.size());
 
   // Before navigating to the restored entry, it should have a restore_type
@@ skipping 25 matching lines @@
   fail_load_params.url = url;
   fail_load_params.showing_repost_interstitial = false;
   rvh->TestOnMessageReceived(
           ViewHostMsg_DidFailProvisionalLoadWithError(0,  // routing_id
                                                       fail_load_params));
 
   // Now the pending restored entry commits.
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = url;
-  params.transition = PageTransition::LINK;
+  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 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.pending_entry());
   EXPECT_EQ(url,
             our_controller.GetLastCommittedEntry()->site_instance()->site());
   EXPECT_EQ(NavigationEntry::RESTORE_NONE,
             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, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url1);
 
   // Now navigate somewhere with an interstitial.
   const GURL url2("http://bar");
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   controller().pending_entry()->set_page_type(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.
   rvh()->SendNavigate(1, url2);
 
   // The page should be a normal page again.
   EXPECT_EQ(url2, controller().GetLastCommittedEntry()->url());
   EXPECT_EQ(NORMAL_PAGE, controller().GetLastCommittedEntry()->page_type());
 }
 
 TEST_F(NavigationControllerTest, RemoveEntry) {
   const GURL url1("http://foo/1");
   const GURL url2("http://foo/2");
   const GURL url3("http://foo/3");
   const GURL url4("http://foo/4");
   const GURL url5("http://foo/5");
   const GURL pending_url("http://foo/pending");
   const GURL default_url("http://foo/default");
 
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url1);
-  controller().LoadURL(url2, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url2, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, url2);
-  controller().LoadURL(url3, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url3, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(2, url3);
-  controller().LoadURL(url4, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url4, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(3, url4);
-  controller().LoadURL(url5, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url5, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(4, url5);
 
   // Remove the last entry.
   controller().RemoveEntryAtIndex(
       controller().entry_count() - 1, default_url);
   EXPECT_EQ(4, controller().entry_count());
   EXPECT_EQ(3, controller().last_committed_entry_index());
   NavigationEntry* pending_entry = controller().pending_entry();
   EXPECT_TRUE(pending_entry && pending_entry->url() == url4);
 
   // Add a pending entry.
-  controller().LoadURL(pending_url, GURL(), PageTransition::TYPED,
+  controller().LoadURL(pending_url, GURL(), content::PAGE_TRANSITION_TYPED,
                        std::string());
   // Now remove the last entry.
   controller().RemoveEntryAtIndex(
       controller().entry_count() - 1, default_url);
   // The pending entry should have been discarded and the last committed entry
   // removed.
   EXPECT_EQ(3, controller().entry_count());
   EXPECT_EQ(2, controller().last_committed_entry_index());
   pending_entry = controller().pending_entry();
   EXPECT_TRUE(pending_entry && pending_entry->url() == url3);
@@ skipping 22 matching lines @@
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url0("http://foo/0");
   const GURL url1("http://foo/1");
   const GURL url2("http://foo/2");
   const GURL url3("http://foo/3");
   const GURL url4("http://foo/4");
   const GURL transient_url("http://foo/transient");
 
-  controller().LoadURL(url0, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url0, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url0);
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, url1);
 
   notifications.Reset();
 
   // Adding a transient with no pending entry.
   NavigationEntry* transient_entry = new NavigationEntry;
   transient_entry->set_url(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()->url());
   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().pending_entry());
   EXPECT_TRUE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), 1);
 
   // Navigate.
-  controller().LoadURL(url2, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url2, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(2, url2);
 
   // We should have navigated, transient entry should be gone.
   EXPECT_EQ(url2, controller().GetActiveEntry()->url());
   EXPECT_EQ(controller().entry_count(), 3);
 
   // Add a transient again, then navigate with no pending entry this time.
   transient_entry = new NavigationEntry;
   transient_entry->set_url(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->url());
   rvh()->SendNavigate(3, url3);
   // Transient entry should be gone.
   EXPECT_EQ(url3, controller().GetActiveEntry()->url());
   EXPECT_EQ(controller().entry_count(), 4);
 
   // Initiate a navigation, add a transient then commit navigation.
-  controller().LoadURL(url4, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url4, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   transient_entry = new NavigationEntry;
   transient_entry->set_url(transient_url);
   controller().AddTransientEntry(transient_entry);
   EXPECT_EQ(transient_url, controller().GetActiveEntry()->url());
   rvh()->SendNavigate(4, url4);
   EXPECT_EQ(url4, controller().GetActiveEntry()->url());
   EXPECT_EQ(controller().entry_count(), 5);
 
   // Add a transient and go back.  This should simply remove the transient.
   transient_entry = new NavigationEntry;
@@ skipping 94 matching lines @@
 
   // We should be at the first navigation entry.
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
 
   // Navigate a subframe that would normally count as in-page.
   const GURL subframe("http://www.google.com/#");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = 0;
   params.url = subframe;
-  params.transition = PageTransition::AUTO_SUBFRAME;
+  params.transition = content::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(subframe));
   content::LoadCommittedDetails details;
   EXPECT_FALSE(controller().RendererDidNavigate(params, &details));
 
   // Nothing should have changed.
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
@@ skipping 36 matching lines @@
 
 // Tests a subframe navigation while a toplevel navigation is pending.
 // http://crbug.com/43967
 TEST_F(NavigationControllerTest, SubframeWhilePending) {
   // Load the first page.
   const GURL url1("http://foo/");
   NavigateAndCommit(url1);
 
   // Now start a pending load to a totally different page, but don't commit it.
   const GURL url2("http://bar/");
-  controller().LoadURL(url2, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url2, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
 
   // Send a subframe update from the first page, as if one had just
   // automatically loaded. Auto subframes don't increment the page ID.
   const GURL url1_sub("http://foo/subframe");
   ViewHostMsg_FrameNavigate_Params params;
   params.page_id = controller().GetLastCommittedEntry()->page_id();
   params.url = url1_sub;
-  params.transition = PageTransition::AUTO_SUBFRAME;
+  params.transition = content::PAGE_TRANSITION_AUTO_SUBFRAME;
   params.should_update_history = false;
   params.gesture = NavigationGestureAuto;
   params.is_post = false;
   params.content_state = webkit_glue::CreateHistoryStateForURL(GURL(url1_sub));
   content::LoadCommittedDetails details;
 
   // This should return false meaning that nothing was actually updated.
   EXPECT_FALSE(controller().RendererDidNavigate(params, &details));
 
   // The notification should have updated the last committed one, and not
@@ skipping 63 matching lines @@
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
   const GURL url3("http://foo3");
 
   NavigateAndCommit(url1);
   NavigateAndCommit(url2);
   controller().GoBack();
 
   scoped_ptr<TestTabContents> other_contents(CreateTestTabContents());
   NavigationController& other_controller = other_contents->controller();
-  other_controller.LoadURL(url3, GURL(), PageTransition::TYPED, std::string());
+  other_controller.LoadURL(
+      url3, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   other_contents->ExpectSetHistoryLengthAndPrune(NULL, 1, -1);
   other_controller.CopyStateFromAndPrune(&controller());
 
   // other_controller should now contain 1 entry for url1, and a pending entry
   // for url3.
 
   ASSERT_EQ(1, other_controller.entry_count());
 
   EXPECT_EQ(0, other_controller.GetCurrentEntryIndex());
 
@@ skipping 115 matching lines @@
 
   EXPECT_EQ(0, controller().pending_entry_index());
 }
 
 // Test call to PruneAllButActive for transient entry.
 TEST_F(NavigationControllerTest, PruneAllButActiveForTransient) {
   const GURL url0("http://foo/0");
   const GURL url1("http://foo/1");
   const GURL transient_url("http://foo/transient");
 
-  controller().LoadURL(url0, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url0, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(0, url0);
-  controller().LoadURL(url1, GURL(), PageTransition::TYPED, std::string());
+  controller().LoadURL(
+      url1, GURL(), content::PAGE_TRANSITION_TYPED, std::string());
   rvh()->SendNavigate(1, url1);
 
   // Adding a transient with no pending entry.
   NavigationEntry* transient_entry = new NavigationEntry;
   transient_entry->set_url(transient_url);
   controller().AddTransientEntry(transient_entry);
 
   controller().PruneAllButActive();
 
   EXPECT_EQ(-1, controller().pending_entry_index());
@@ skipping 119 matching lines @@
   SessionServiceTestHelper session_helper_;
 
  private:
   ProfileManager* profile_manager_;
   FilePath test_dir_;
 };
 
 // A basic test case. Navigates to a single url, and make sure the history
 // db matches.
 TEST_F(NavigationControllerHistoryTest, Basic) {
-  controller().LoadURL(url0, GURL(), PageTransition::LINK);
+  controller().LoadURL(url0, GURL(), content::PAGE_TRANSITION_LINK);
   rvh()->SendNavigate(0, url0);
 
   GetLastSession();
 
   session_helper_.AssertSingleWindowWithSingleTab(windows_, 1);
   session_helper_.AssertTabEquals(0, 0, 1, *(windows_[0]->tabs[0]));
   TabNavigation nav1(0, url0, GURL(), string16(),
                      webkit_glue::CreateHistoryStateForURL(url0),
-                     PageTransition::LINK);
+                     content::PAGE_TRANSITION_LINK);
   session_helper_.AssertNavigationEquals(nav1,
                                          windows_[0]->tabs[0]->navigations[0]);
 }
 
 // Navigates to three urls, then goes back and make sure the history database
 // is in sync.
 TEST_F(NavigationControllerHistoryTest, NavigationThenBack) {
   rvh()->SendNavigate(0, url0);
   rvh()->SendNavigate(1, url1);
   rvh()->SendNavigate(2, url2);
 
   controller().GoBack();
   rvh()->SendNavigate(1, url1);
 
   GetLastSession();
 
   session_helper_.AssertSingleWindowWithSingleTab(windows_, 3);
   session_helper_.AssertTabEquals(0, 1, 3, *(windows_[0]->tabs[0]));
 
   TabNavigation nav(0, url0, GURL(), string16(),
                     webkit_glue::CreateHistoryStateForURL(url0),
-                    PageTransition::LINK);
+                    content::PAGE_TRANSITION_LINK);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[0]);
   nav.set_url(url1);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[1]);
   nav.set_url(url2);
   session_helper_.AssertNavigationEquals(nav,
                                          windows_[0]->tabs[0]->navigations[2]);
 }
 
@@ skipping 13 matching lines @@
 
   // Now have url0, and url2.
 
   GetLastSession();
 
   session_helper_.AssertSingleWindowWithSingleTab(windows_, 2);
   session_helper_.AssertTabEquals(0, 1, 2, *(windows_[0]->tabs[0]));
 
   TabNavigation nav(0, url0, GURL(), string16(),
                     webkit_glue::CreateHistoryStateForURL(url0),
-                    PageTransition::LINK);
+                    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]);
 }
 */