Moving notification types which are chrome specific to a new header file chrome_notification_type...

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-inl.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 25 matching lines @@
 
 // NavigationControllerTest ----------------------------------------------------
 
 class NavigationControllerTest : public RenderViewHostTestHarness {
  public:
   NavigationControllerTest() {}
 };
 
 void RegisterForAllNavNotifications(TestNotificationTracker* tracker,
                                     NavigationController* controller) {
-  tracker->ListenFor(NotificationType::NAV_ENTRY_COMMITTED,
+  tracker->ListenFor(content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                      Source<NavigationController>(controller));
-  tracker->ListenFor(NotificationType::NAV_LIST_PRUNED,
+  tracker->ListenFor(content::NOTIFICATION_NAV_LIST_PRUNED,
                      Source<NavigationController>(controller));
-  tracker->ListenFor(NotificationType::NAV_ENTRY_CHANGED,
+  tracker->ListenFor(content::NOTIFICATION_NAV_ENTRY_CHANGED,
                      Source<NavigationController>(controller));
 }
 
 class TestTabContentsDelegate : public TabContentsDelegate {
  public:
   explicit TestTabContentsDelegate() :
       navigation_state_change_count_(0) {}
 
   int navigation_state_change_count() {
     return navigation_state_change_count_;
@@ skipping 42 matching lines @@
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), -1);
 
   // We should have gotten no notifications from the preceeding checks.
   EXPECT_EQ(0U, notifications.size());
 
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // The load should now be committed.
   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);
@@ skipping 10 matching lines @@
   // TODO(darin): maybe this should really be true?
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
   EXPECT_EQ(contents()->GetMaxPageID(), 0);
 
   // Simulate the beforeunload ack for the cross-site transition, and then the
   // commit.
   rvh()->SendShouldCloseACK(true);
   contents()->pending_rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // The load should now be committed.
   EXPECT_EQ(controller().entry_count(), 2);
   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);
 }
 
 // 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);
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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);
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().LoadURL(url2, GURL(), PageTransition::TYPED);
   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);
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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);
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Make a pending entry to somewhere new.
   const GURL kExistingURL2("http://bee");
   controller().LoadURL(kExistingURL2, GURL(),
                                   PageTransition::TYPED);
   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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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);
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL kExistingURL2("http://foo/bee");
   controller().LoadURL(kExistingURL2, GURL(),
                                   PageTransition::TYPED);
   rvh()->SendNavigate(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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());
 
   // Before that commits, do a new navigation.
   const GURL kNewURL("http://foo/see");
   content::LoadCommittedDetails details;
   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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(2, controller().last_committed_entry_index());
   EXPECT_EQ(kNewURL, controller().GetActiveEntry()->url());
 }
 
 // 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);
   rvh()->SendNavigate(0, kExistingURL1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL kExistingURL2("http://foo/bee");
   controller().LoadURL(kExistingURL2, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, kExistingURL2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now make a pending new navigation.
   const GURL kNewURL("http://foo/see");
   controller().LoadURL(kNewURL, GURL(), PageTransition::TYPED);
   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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(-1, controller().pending_entry_index());
   EXPECT_EQ(0, controller().last_committed_entry_index());
   EXPECT_EQ(kExistingURL1, controller().GetActiveEntry()->url());
 }
 
 // Tests an ignored navigation when there is a pending new navigation.
 // This will happen if the user enters a URL, but before that commits, the
 // current blank page reloads.  See http://crbug.com/77507.
 TEST_F(NavigationControllerTest, LoadURL_IgnorePreemptsPending) {
   TestNotificationTracker notifications;
@@ skipping 131 matching lines @@
 TEST_F(NavigationControllerTest, Reload) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
 
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().Reload(true);
   EXPECT_EQ(0U, notifications.size());
 
   // The reload is pending.
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), 0);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
 
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now the reload is committed.
   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 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);
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().Reload(true);
   EXPECT_EQ(0U, notifications.size());
 
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now the reload is committed.
   EXPECT_EQ(controller().entry_count(), 2);
   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());
 }
 
 // Tests what happens when we navigate back successfully
 TEST_F(NavigationControllerTest, Back) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   const GURL url2("http://foo2");
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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);
   EXPECT_EQ(controller().pending_entry_index(), 0);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_TRUE(controller().CanGoForward());
 
   rvh()->SendNavigate(0, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // The back navigation completed successfully.
   EXPECT_EQ(controller().entry_count(), 2);
   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_TRUE(controller().CanGoForward());
 }
 
 // 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);
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().LoadURL(url2, GURL(), PageTransition::TYPED);
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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);
   EXPECT_EQ(controller().pending_entry_index(), 0);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_TRUE(controller().CanGoForward());
 
   rvh()->SendNavigate(2, url3);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // The back navigation resulted in a completely new navigation.
   // TODO(darin): perhaps this behavior will be confusing to users?
   EXPECT_EQ(controller().entry_count(), 3);
   EXPECT_EQ(controller().last_committed_entry_index(), 2);
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_TRUE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
 }
 
 // Receives a back message when there is a new pending navigation entry.
 TEST_F(NavigationControllerTest, Back_NewPending) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // controller().LoadURL(kUrl2, PageTransition::TYPED);
   rvh()->SendNavigate(1, kUrl2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Now start a new pending navigation and go back before it commits.
   controller().LoadURL(kUrl3, GURL(), PageTransition::TYPED);
   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());
@@ skipping 50 matching lines @@
 // Tests what happens when we navigate forward successfully.
 TEST_F(NavigationControllerTest, Forward) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().GoBack();
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().GoForward();
 
   // We should now have a pending navigation to go forward.
   EXPECT_EQ(controller().entry_count(), 2);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), 1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_TRUE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
 
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // The forward navigation completed successfully.
   EXPECT_EQ(controller().entry_count(), 2);
   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());
 }
 
 // Tests what happens when a forward navigation produces a new page.
 TEST_F(NavigationControllerTest, Forward_GeneratesNewPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
   const GURL url3("http://foo3");
 
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().GoBack();
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   controller().GoForward();
   EXPECT_EQ(0U, notifications.size());
 
   // Should now have a pending navigation to go forward.
   EXPECT_EQ(controller().entry_count(), 2);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_EQ(controller().pending_entry_index(), 1);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_TRUE(controller().pending_entry());
   EXPECT_TRUE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
 
   rvh()->SendNavigate(2, url3);
   EXPECT_TRUE(notifications.Check2AndReset(
-      NotificationType::NAV_LIST_PRUNED,
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_LIST_PRUNED,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   EXPECT_EQ(controller().entry_count(), 2);
   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());
 }
 
 // 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);
 
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Second request
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
 
   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.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());
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   EXPECT_TRUE(details.type == NavigationType::SAME_PAGE);
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_EQ(url2, controller().GetActiveEntry()->url());
 
   EXPECT_FALSE(controller().CanGoBack());
@@ skipping 10 matching lines @@
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");  // Redirection target
 
   // First request as POST
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
   controller().GetActiveEntry()->set_has_post_data(true);
 
   EXPECT_EQ(0U, notifications.size());
   rvh()->SendNavigate(0, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Second request
   controller().LoadURL(url1, GURL(), PageTransition::TYPED);
 
   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.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());
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   EXPECT_TRUE(details.type == NavigationType::SAME_PAGE);
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_EQ(url2, controller().GetActiveEntry()->url());
   EXPECT_FALSE(controller().GetActiveEntry()->has_post_data());
 
@@ skipping 25 matching lines @@
   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());
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   EXPECT_TRUE(details.type == NavigationType::NEW_PAGE);
   EXPECT_EQ(controller().entry_count(), 1);
   EXPECT_EQ(controller().last_committed_entry_index(), 0);
   EXPECT_TRUE(controller().GetLastCommittedEntry());
   EXPECT_EQ(controller().pending_entry_index(), -1);
   EXPECT_FALSE(controller().pending_entry());
   EXPECT_EQ(url2, controller().GetActiveEntry()->url());
 
   EXPECT_FALSE(controller().CanGoBack());
   EXPECT_FALSE(controller().CanGoForward());
 }
 
 // Tests navigation via link click within a subframe. A new navigation entry
 // should be created.
 TEST_F(NavigationControllerTest, NewSubframe) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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.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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(url1, details.previous_url);
   EXPECT_FALSE(details.is_in_page);
   EXPECT_FALSE(details.is_main_frame);
 
   // The new entry should be appended.
   EXPECT_EQ(2, controller().entry_count());
 
   // New entry should refer to the new page, but the old URL (entries only
   // reflect the toplevel URL).
   EXPECT_EQ(url1, details.entry->url());
@@ skipping 25 matching lines @@
 
 // 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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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.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());
 
   // There should still be only one entry.
   EXPECT_EQ(1, controller().entry_count());
 }
 
 // Tests navigation and then going back to a subframe navigation.
 TEST_F(NavigationControllerTest, BackSubframe) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // Main page.
   const GURL url1("http://foo1");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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.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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(2, controller().entry_count());
 
   // Second manual subframe navigation should also make a new entry.
   const GURL url3("http://foo3");
   params.page_id = 2;
   params.url = url3;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(3, controller().entry_count());
   EXPECT_EQ(2, controller().GetCurrentEntryIndex());
 
   // Go back one.
   controller().GoBack();
   params.url = url2;
   params.page_id = 1;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(3, controller().entry_count());
   EXPECT_EQ(1, controller().GetCurrentEntryIndex());
 
   // Go back one more.
   controller().GoBack();
   params.url = url1;
   params.page_id = 0;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_EQ(3, controller().entry_count());
   EXPECT_EQ(0, controller().GetCurrentEntryIndex());
 }
 
 TEST_F(NavigationControllerTest, LinkClick) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   const GURL url1("http://foo1");
   const GURL url2("http://foo2");
 
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   rvh()->SendNavigate(1, url2);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
 
   // Should not have produced a new session history entry.
   EXPECT_EQ(controller().entry_count(), 2);
   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());
 }
 
 TEST_F(NavigationControllerTest, InPage) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // Main page.
   const GURL url1("http://foo");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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.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(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_TRUE(details.is_in_page);
   EXPECT_FALSE(details.did_replace_entry);
   EXPECT_EQ(2, controller().entry_count());
 
   // Go back one.
   ViewHostMsg_FrameNavigate_Params back_params(params);
   controller().GoBack();
   back_params.url = url1;
   back_params.page_id = 0;
   EXPECT_TRUE(controller().RendererDidNavigate(back_params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   // is_in_page is false in that case but should be true.
   // See comment in AreURLsInPageNavigation() in navigation_controller.cc
   // EXPECT_TRUE(details.is_in_page);
   EXPECT_EQ(2, controller().entry_count());
   EXPECT_EQ(0, controller().GetCurrentEntryIndex());
   EXPECT_EQ(back_params.url, controller().GetActiveEntry()->url());
 
   // Go forward
   ViewHostMsg_FrameNavigate_Params forward_params(params);
   controller().GoForward();
   forward_params.url = url2;
   forward_params.page_id = 1;
   EXPECT_TRUE(controller().RendererDidNavigate(forward_params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_TRUE(details.is_in_page);
   EXPECT_EQ(2, controller().entry_count());
   EXPECT_EQ(1, controller().GetCurrentEntryIndex());
   EXPECT_EQ(forward_params.url,
             controller().GetActiveEntry()->url());
 
   // Now go back and forward again. This is to work around a bug where we would
   // compare the incoming URL with the last committed entry rather than the
   // one identified by an existing page ID. This would result in the second URL
   // losing the reference fragment when you navigate away from it and then back.
   controller().GoBack();
   EXPECT_TRUE(controller().RendererDidNavigate(back_params, &details));
   controller().GoForward();
   EXPECT_TRUE(controller().RendererDidNavigate(forward_params, &details));
   EXPECT_EQ(forward_params.url,
             controller().GetActiveEntry()->url());
 
   // Finally, navigate to an unrelated URL to make sure in_page is not sticky.
   const GURL url3("http://bar");
   params.page_id = 2;
   params.url = url3;
   notifications.Reset();
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_FALSE(details.is_in_page);
 }
 
 TEST_F(NavigationControllerTest, InPage_Replace) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // Main page.
   const GURL url1("http://foo");
   rvh()->SendNavigate(0, url1);
   EXPECT_TRUE(notifications.Check1AndReset(
-      NotificationType::NAV_ENTRY_COMMITTED));
+      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.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.
   content::LoadCommittedDetails details;
   EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
   EXPECT_TRUE(notifications.Check2AndReset(
-      NotificationType::NAV_LIST_PRUNED,
-      NotificationType::NAV_ENTRY_COMMITTED));
+      content::NOTIFICATION_NAV_LIST_PRUNED,
+      content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   EXPECT_TRUE(details.is_in_page);
   EXPECT_TRUE(details.did_replace_entry);
   EXPECT_EQ(1, controller().entry_count());
 }
 
 // Tests for http://crbug.com/40395
 // Simulates this:
 //   <script>
 //     window.location.replace("#a");
 //     window.location='http://foo3/';
 //   </script>
 TEST_F(NavigationControllerTest, ClientRedirectAfterInPageNavigation) {
   TestNotificationTracker notifications;
   RegisterForAllNavNotifications(&notifications, &controller());
 
   // Load an initial page.
   {
     const GURL url("http://foo/");
     rvh()->SendNavigate(0, url);
     EXPECT_TRUE(notifications.Check1AndReset(
-        NotificationType::NAV_ENTRY_COMMITTED));
+        content::NOTIFICATION_NAV_ENTRY_COMMITTED));
   }
 
   // Navigate to a new page.
   {
     const GURL url("http://foo2/");
     rvh()->SendNavigate(1, url);
     controller().DocumentLoadedInFrame();
     EXPECT_TRUE(notifications.Check1AndReset(
-        NotificationType::NAV_ENTRY_COMMITTED));
+        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.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.
     content::LoadCommittedDetails details;
     EXPECT_TRUE(controller().RendererDidNavigate(params, &details));
     EXPECT_TRUE(notifications.Check2AndReset(
-        NotificationType::NAV_LIST_PRUNED,
-        NotificationType::NAV_ENTRY_COMMITTED));
+        content::NOTIFICATION_NAV_LIST_PRUNED,
+        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.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));
     EXPECT_TRUE(notifications.Check1AndReset(
-        NotificationType::NAV_ENTRY_COMMITTED));
+        content::NOTIFICATION_NAV_ENTRY_COMMITTED));
     EXPECT_FALSE(details.is_in_page);
     EXPECT_EQ(3, controller().entry_count());
   }
 
   // Verify that BACK brings us back to http://foo2/.
   {
     const GURL url("http://foo2/");
     controller().GoBack();
     rvh()->SendNavigate(1, url);
     EXPECT_TRUE(notifications.Check1AndReset(
-        NotificationType::NAV_ENTRY_COMMITTED));
+        content::NOTIFICATION_NAV_ENTRY_COMMITTED));
     EXPECT_EQ(url, controller().GetActiveEntry()->url());
   }
 }
 
 // NotificationObserver implementation used in verifying we've received the
-// NotificationType::NAV_LIST_PRUNED method.
+// content::NOTIFICATION_NAV_LIST_PRUNED method.
 class PrunedListener : public NotificationObserver {
  public:
   explicit PrunedListener(NavigationController* controller)
       : notification_count_(0) {
-    registrar_.Add(this, NotificationType::NAV_LIST_PRUNED,
+    registrar_.Add(this, content::NOTIFICATION_NAV_LIST_PRUNED,
                    Source<NavigationController>(controller));
   }
 
-  virtual void Observe(NotificationType type,
+  virtual void Observe(int type,
                        const NotificationSource& source,
                        const NotificationDetails& details) {
-    if (type == NotificationType::NAV_LIST_PRUNED) {
+    if (type == content::NOTIFICATION_NAV_LIST_PRUNED) {
       notification_count_++;
       details_ = *(Details<content::PrunedDetails>(details).ptr());
     }
   }
 
   // Number of times NAV_LIST_PRUNED has been observed.
   int notification_count_;
 
   // Details from the last NAV_LIST_PRUNED.
   content::PrunedDetails details_;
@@ skipping 911 matching lines @@
   TabNavigation nav(0, url0, GURL(), string16(),
                     webkit_glue::CreateHistoryStateForURL(url0),
                     PageTransition::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]);
 }
 */