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

chrome/browser/tabs/tab_strip_model_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 "chrome/browser/tabs/tab_strip_model.h"
 
 #include <map>
 #include <string>
 
 #include "base/file_path.h"
@@ skipping 86 matching lines @@
   }
   virtual void ContinueDraggingDetachedTab(TabContentsWrapper* contents,
                                            const gfx::Rect& window_bounds,
                                            const gfx::Rect& tab_bounds) {
   }
   virtual int GetDragActions() const { return 0; }
   virtual TabContentsWrapper* CreateTabContentsForURL(
       const GURL& url,
       const GURL& referrer,
       Profile* profile,
-      PageTransition::Type transition,
+      content::PageTransition transition,
       bool defer_load,
       SiteInstance* instance) const {
     if (url == GURL(chrome::kChromeUINewTabURL))
       return dummy_contents_;
     return NULL;
   }
   virtual bool CanDuplicateContentsAt(int index) { return false; }
   virtual void DuplicateContentsAt(int index) {}
   virtual void CloseFrameAfterDragSession() {}
   virtual void CreateHistoricalTab(TabContentsWrapper* contents) {}
@@ skipping 41 matching lines @@
         tab_contents->render_view_host()->site_instance(), MSG_ROUTING_NONE,
         NULL, NULL);
     EXPECT_EQ(retval->tab_contents()->GetRenderProcessHost(),
               tab_contents->GetRenderProcessHost());
     return retval;
   }
 
   // Forwards a URL "load" request through to our dummy TabContents
   // implementation.
   void LoadURL(TabContents* con, const std::wstring& url) {
-    controller().LoadURL(GURL(WideToUTF16(url)), GURL(), PageTransition::LINK,
-                         std::string());
+    controller().LoadURL(GURL(WideToUTF16(url)), GURL(),
+                         content::PAGE_TRANSITION_LINK, std::string());
   }
 
   void GoBack(TabContents* contents) {
     controller().GoBack();
   }
 
   void GoForward(TabContents* contents) {
     controller().GoForward();
   }
 
@@ skipping 501 matching lines @@
   EXPECT_EQ(-1, tabstrip.GetIndexOfNextTabContentsOpenedBy(opener, 5, false));
   EXPECT_EQ(-1, tabstrip.GetIndexOfLastTabContentsOpenedBy(opener, 1));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 static int GetInsertionIndex(TabStripModel* tabstrip,
                              TabContentsWrapper* contents) {
   return tabstrip->order_controller()->DetermineInsertionIndex(
-      contents, PageTransition::LINK, false);
+      contents, content::PAGE_TRANSITION_LINK, false);
 }
 
 static void InsertTabContentses(TabStripModel* tabstrip,
                                 TabContentsWrapper* contents1,
                                 TabContentsWrapper* contents2,
                                 TabContentsWrapper* contents3) {
   tabstrip->InsertTabContentsAt(GetInsertionIndex(tabstrip, contents1),
                                 contents1, TabStripModel::ADD_INHERIT_GROUP);
   tabstrip->InsertTabContentsAt(GetInsertionIndex(tabstrip, contents2),
                                 contents2, TabStripModel::ADD_INHERIT_GROUP);
@@ skipping 104 matching lines @@
 
   // The opener API should work...
   EXPECT_EQ(3, tabstrip.GetIndexOfNextTabContentsOpenedBy(opener, 2, false));
   EXPECT_EQ(2, tabstrip.GetIndexOfNextTabContentsOpenedBy(opener, 3, false));
   EXPECT_EQ(3, tabstrip.GetIndexOfLastTabContentsOpenedBy(opener, 1));
 
   // Now open a foreground tab from a link. It should be opened adjacent to the
   // opener tab.
   TabContentsWrapper* fg_link_contents = CreateTabContents();
   int insert_index = tabstrip.order_controller()->DetermineInsertionIndex(
-      fg_link_contents, PageTransition::LINK, true);
+      fg_link_contents, content::PAGE_TRANSITION_LINK, true);
   EXPECT_EQ(1, insert_index);
   tabstrip.InsertTabContentsAt(insert_index, fg_link_contents,
                                TabStripModel::ADD_ACTIVE |
                                TabStripModel::ADD_INHERIT_GROUP);
   EXPECT_EQ(1, tabstrip.active_index());
   EXPECT_EQ(fg_link_contents, tabstrip.GetActiveTabContents());
 
   // Now close this contents. The selection should move to the opener contents.
   tabstrip.CloseSelectedTabs();
   EXPECT_EQ(0, tabstrip.active_index());
 
   // Now open a new empty tab. It should open at the end of the strip.
   TabContentsWrapper* fg_nonlink_contents = CreateTabContents();
   insert_index = tabstrip.order_controller()->DetermineInsertionIndex(
-      fg_nonlink_contents, PageTransition::AUTO_BOOKMARK, true);
+      fg_nonlink_contents, content::PAGE_TRANSITION_AUTO_BOOKMARK, true);
   EXPECT_EQ(tabstrip.count(), insert_index);
   // We break the opener relationship...
   tabstrip.InsertTabContentsAt(insert_index, fg_nonlink_contents,
                                TabStripModel::ADD_NONE);
   // Now select it, so that user_gesture == true causes the opener relationship
   // to be forgotten...
   tabstrip.ActivateTabAt(tabstrip.count() - 1, true);
   EXPECT_EQ(tabstrip.count() - 1, tabstrip.active_index());
   EXPECT_EQ(fg_nonlink_contents, tabstrip.GetActiveTabContents());
 
@@ skipping 361 matching lines @@
 // using this "smart" function with a simulated middle click action on a series
 // of links on the home page.
 TEST_F(TabStripModelTest, AddTabContents_MiddleClickLinksAndClose) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
   TabContentsWrapper* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      homepage_contents, -1, PageTransition::AUTO_BOOKMARK,
+      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   TabContentsWrapper* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      typed_page_contents, -1, PageTransition::TYPED,
+      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a bunch of tabs by simulating middle clicking on links on the home
   // page.
   TabContentsWrapper* middle_click_contents1 = CreateTabContents();
   tabstrip.AddTabContents(
-      middle_click_contents1, -1, PageTransition::LINK,
+      middle_click_contents1, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   TabContentsWrapper* middle_click_contents2 = CreateTabContents();
   tabstrip.AddTabContents(
-      middle_click_contents2, -1, PageTransition::LINK,
+      middle_click_contents2, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   TabContentsWrapper* middle_click_contents3 = CreateTabContents();
   tabstrip.AddTabContents(
-      middle_click_contents3, -1, PageTransition::LINK,
+      middle_click_contents3, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
 
   EXPECT_EQ(5, tabstrip.count());
 
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(middle_click_contents1, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(middle_click_contents2, tabstrip.GetTabContentsAt(2));
   EXPECT_EQ(middle_click_contents3, tabstrip.GetTabContentsAt(3));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(4));
 
@@ skipping 22 matching lines @@
 // Tests whether or not a TabContents created by a left click on a link that
 // opens a new tab is inserted correctly adjacent to the tab that spawned it.
 TEST_F(TabStripModelTest, AddTabContents_LeftClickPopup) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
   TabContentsWrapper* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      homepage_contents, -1, PageTransition::AUTO_BOOKMARK,
+      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   TabContentsWrapper* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      typed_page_contents, -1, PageTransition::TYPED,
+      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a tab by simulating a left click on a link that opens in a new tab.
   TabContentsWrapper* left_click_contents = CreateTabContents();
-  tabstrip.AddTabContents(left_click_contents, -1, PageTransition::LINK,
+  tabstrip.AddTabContents(left_click_contents, -1,
+                          content::PAGE_TRANSITION_LINK,
                           TabStripModel::ADD_ACTIVE);
 
   // Verify the state meets our expectations.
   EXPECT_EQ(3, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(left_click_contents, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(2));
 
   // The newly created tab should be selected.
   EXPECT_EQ(left_click_contents, tabstrip.GetActiveTabContents());
@@ skipping 13 matching lines @@
 // generated urls, also blank tabs) open at the end of the tabstrip instead of
 // in the middle.
 TEST_F(TabStripModelTest, AddTabContents_CreateNewBlankTab) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
   TabContentsWrapper* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      homepage_contents, -1, PageTransition::AUTO_BOOKMARK,
+      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   TabContentsWrapper* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      typed_page_contents, -1, PageTransition::TYPED,
+      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a new blank tab in the foreground.
   TabContentsWrapper* new_blank_contents = CreateTabContents();
-  tabstrip.AddTabContents(new_blank_contents, -1, PageTransition::TYPED,
+  tabstrip.AddTabContents(new_blank_contents, -1,
+                          content::PAGE_TRANSITION_TYPED,
                           TabStripModel::ADD_ACTIVE);
 
   // Verify the state of the tabstrip.
   EXPECT_EQ(3, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(new_blank_contents, tabstrip.GetTabContentsAt(2));
 
   // Now open a couple more blank tabs in the background.
   TabContentsWrapper* background_blank_contents1 = CreateTabContents();
   tabstrip.AddTabContents(
-      background_blank_contents1, -1, PageTransition::TYPED,
+      background_blank_contents1, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_NONE);
   TabContentsWrapper* background_blank_contents2 = CreateTabContents();
   tabstrip.AddTabContents(
-      background_blank_contents2, -1, PageTransition::GENERATED,
+      background_blank_contents2, -1, content::PAGE_TRANSITION_GENERATED,
       TabStripModel::ADD_NONE);
   EXPECT_EQ(5, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetTabContentsAt(0));
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(1));
   EXPECT_EQ(new_blank_contents, tabstrip.GetTabContentsAt(2));
   EXPECT_EQ(background_blank_contents1, tabstrip.GetTabContentsAt(3));
   EXPECT_EQ(background_blank_contents2, tabstrip.GetTabContentsAt(4));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Tests whether opener state is correctly forgotten when the user switches
 // context.
 TEST_F(TabStripModelTest, AddTabContents_ForgetOpeners) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
   TabContentsWrapper* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      homepage_contents, -1, PageTransition::AUTO_BOOKMARK,
+      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   TabContentsWrapper* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      typed_page_contents, -1, PageTransition::TYPED,
+      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(2, tabstrip.count());
 
   // Re-select the home page.
   tabstrip.ActivateTabAt(0, true);
 
   // Open a bunch of tabs by simulating middle clicking on links on the home
   // page.
   TabContentsWrapper* middle_click_contents1 = CreateTabContents();
   tabstrip.AddTabContents(
-      middle_click_contents1, -1, PageTransition::LINK,
+      middle_click_contents1, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   TabContentsWrapper* middle_click_contents2 = CreateTabContents();
   tabstrip.AddTabContents(
-      middle_click_contents2, -1, PageTransition::LINK,
+      middle_click_contents2, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   TabContentsWrapper* middle_click_contents3 = CreateTabContents();
   tabstrip.AddTabContents(
-      middle_click_contents3, -1, PageTransition::LINK,
+      middle_click_contents3, -1, content::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
 
   // Break out of the context by selecting a tab in a different context.
   EXPECT_EQ(typed_page_contents, tabstrip.GetTabContentsAt(4));
   tabstrip.SelectLastTab();
   EXPECT_EQ(typed_page_contents, tabstrip.GetActiveTabContents());
 
   // Step back into the context by selecting a tab inside it.
   tabstrip.ActivateTabAt(2, true);
   EXPECT_EQ(middle_click_contents2, tabstrip.GetActiveTabContents());
@@ skipping 21 matching lines @@
   TabContents* fake_destinations_tab =
       new TabContents(profile(), NULL, 0, NULL, NULL);
   TabContentsWrapper wrapper(fake_destinations_tab);
   TabStripDummyDelegate delegate(&wrapper);
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
   TabContentsWrapper* homepage_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      homepage_contents, -1, PageTransition::AUTO_BOOKMARK,
+      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   TabContentsWrapper* typed_page_contents = CreateTabContents();
   tabstrip.AddTabContents(
-      typed_page_contents, -1, PageTransition::TYPED,
+      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_NONE);
 
   // The selected tab should still be the first.
   EXPECT_EQ(0, tabstrip.active_index());
 
   // Now simulate a link click that opens a new tab (by virtue of target=_blank)
   // and make sure the right tab gets selected when the new tab is closed.
   TabContentsWrapper* target_blank_contents = CreateTabContents();
   tabstrip.AppendTabContents(target_blank_contents, true);
   EXPECT_EQ(2, tabstrip.active_index());
   tabstrip.CloseTabContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(0, tabstrip.active_index());
 
   // clean up after ourselves
   tabstrip.CloseAllTabs();
 }
 
 // Added for http://b/issue?id=1027661
 TEST_F(TabStripModelTest, ReselectionConsidersChildrenTest) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open page A
   TabContentsWrapper* page_a_contents = CreateTabContents();
   strip.AddTabContents(
-      page_a_contents, -1, PageTransition::AUTO_BOOKMARK,
+      page_a_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Simulate middle click to open page A.A and A.B
   TabContentsWrapper* page_a_a_contents = CreateTabContents();
-  strip.AddTabContents(page_a_a_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_a_a_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   TabContentsWrapper* page_a_b_contents = CreateTabContents();
-  strip.AddTabContents(page_a_b_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_a_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Select page A.A
   strip.ActivateTabAt(1, true);
   EXPECT_EQ(page_a_a_contents, strip.GetActiveTabContents());
 
   // Simulate a middle click to open page A.A.A
   TabContentsWrapper* page_a_a_a_contents = CreateTabContents();
-  strip.AddTabContents(page_a_a_a_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_a_a_a_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   EXPECT_EQ(page_a_a_a_contents, strip.GetTabContentsAt(2));
 
   // Close page A.A
   strip.CloseTabContentsAt(strip.active_index(), TabStripModel::CLOSE_NONE);
 
   // Page A.A.A should be selected, NOT A.B
   EXPECT_EQ(page_a_a_a_contents, strip.GetActiveTabContents());
 
@@ skipping 12 matching lines @@
   // Clean up.
   strip.CloseAllTabs();
 }
 
 TEST_F(TabStripModelTest, AddTabContents_NewTabAtEndOfStripInheritsGroup) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open page A
   TabContentsWrapper* page_a_contents = CreateTabContents();
-  strip.AddTabContents(page_a_contents, -1, PageTransition::START_PAGE,
+  strip.AddTabContents(page_a_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_ACTIVE);
 
   // Open pages B, C and D in the background from links on page A...
   TabContentsWrapper* page_b_contents = CreateTabContents();
   TabContentsWrapper* page_c_contents = CreateTabContents();
   TabContentsWrapper* page_d_contents = CreateTabContents();
-  strip.AddTabContents(page_b_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddTabContents(page_c_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddTabContents(page_d_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Switch to page B's tab.
   strip.ActivateTabAt(1, true);
 
   // Open a New Tab at the end of the strip (simulate Ctrl+T)
   TabContentsWrapper* new_tab_contents = CreateTabContents();
-  strip.AddTabContents(new_tab_contents, -1, PageTransition::TYPED,
+  strip.AddTabContents(new_tab_contents, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfTabContents(new_tab_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the New Tab that was just opened. We should be returned to page B's
   // Tab...
   strip.CloseTabContentsAt(4, TabStripModel::CLOSE_NONE);
 
   EXPECT_EQ(1, strip.active_index());
 
   // Open a non-New Tab tab at the end of the strip, with a TYPED transition.
   // This is like typing a URL in the address bar and pressing Alt+Enter. The
   // behavior should be the same as above.
   TabContentsWrapper* page_e_contents = CreateTabContents();
-  strip.AddTabContents(page_e_contents, -1, PageTransition::TYPED,
+  strip.AddTabContents(page_e_contents, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfTabContents(page_e_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the Tab. Selection should shift back to page B's Tab.
   strip.CloseTabContentsAt(4, TabStripModel::CLOSE_NONE);
 
   EXPECT_EQ(1, strip.active_index());
 
   // Open a non-New Tab tab at the end of the strip, with some other
   // transition. This is like right clicking on a bookmark and choosing "Open
   // in New Tab". No opener relationship should be preserved between this Tab
   // and the one that was active when the gesture was performed.
   TabContentsWrapper* page_f_contents = CreateTabContents();
-  strip.AddTabContents(page_f_contents, -1, PageTransition::AUTO_BOOKMARK,
+  strip.AddTabContents(page_f_contents, -1,
+                       content::PAGE_TRANSITION_AUTO_BOOKMARK,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfTabContents(page_f_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the Tab. The next-adjacent should be selected.
   strip.CloseTabContentsAt(4, TabStripModel::CLOSE_NONE);
 
   EXPECT_EQ(3, strip.active_index());
 
   // Clean up.
   strip.CloseAllTabs();
 }
 
 // A test of navigations in a tab that is part of a group of opened from some
 // parent tab. If the navigations are link clicks, the group relationship of
 // the tab to its parent are preserved. If they are of any other type, they are
 // not preserved.
 TEST_F(TabStripModelTest, NavigationForgetsOpeners) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open page A
   TabContentsWrapper* page_a_contents = CreateTabContents();
-  strip.AddTabContents(page_a_contents, -1, PageTransition::START_PAGE,
+  strip.AddTabContents(page_a_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_ACTIVE);
 
   // Open pages B, C and D in the background from links on page A...
   TabContentsWrapper* page_b_contents = CreateTabContents();
   TabContentsWrapper* page_c_contents = CreateTabContents();
   TabContentsWrapper* page_d_contents = CreateTabContents();
-  strip.AddTabContents(page_b_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddTabContents(page_c_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddTabContents(page_d_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Open page E in a different opener group from page A.
   TabContentsWrapper* page_e_contents = CreateTabContents();
-  strip.AddTabContents(page_e_contents, -1, PageTransition::START_PAGE,
+  strip.AddTabContents(page_e_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_NONE);
 
   // Tell the TabStripModel that we are navigating page D via a link click.
   strip.ActivateTabAt(3, true);
-  strip.TabNavigating(page_d_contents, PageTransition::LINK);
+  strip.TabNavigating(page_d_contents, content::PAGE_TRANSITION_LINK);
 
   // Close page D, page C should be selected. (part of same group).
   strip.CloseTabContentsAt(3, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(2, strip.active_index());
 
   // Tell the TabStripModel that we are navigating in page C via a bookmark.
-  strip.TabNavigating(page_c_contents, PageTransition::AUTO_BOOKMARK);
+  strip.TabNavigating(page_c_contents, content::PAGE_TRANSITION_AUTO_BOOKMARK);
 
   // Close page C, page E should be selected. (C is no longer part of the
   // A-B-C-D group, selection moves to the right).
   strip.CloseTabContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(page_e_contents, strip.GetTabContentsAt(strip.active_index()));
 
   strip.CloseAllTabs();
 }
 
 // A test that the forgetting behavior tested in NavigationForgetsOpeners above
 // doesn't cause the opener relationship for a New Tab opened at the end of the
 // TabStrip to be reset (Test 1 below), unless another any other tab is
 // seelcted (Test 2 below).
 TEST_F(TabStripModelTest, NavigationForgettingDoesntAffectNewTab) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   // Open a tab and several tabs from it, then select one of the tabs that was
   // opened.
   TabContentsWrapper* page_a_contents = CreateTabContents();
-  strip.AddTabContents(page_a_contents, -1, PageTransition::START_PAGE,
+  strip.AddTabContents(page_a_contents, -1, content::PAGE_TRANSITION_START_PAGE,
                        TabStripModel::ADD_ACTIVE);
 
   TabContentsWrapper* page_b_contents = CreateTabContents();
   TabContentsWrapper* page_c_contents = CreateTabContents();
   TabContentsWrapper* page_d_contents = CreateTabContents();
-  strip.AddTabContents(page_b_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddTabContents(page_c_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddTabContents(page_d_contents, -1, PageTransition::LINK,
+  strip.AddTabContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   strip.ActivateTabAt(2, true);
 
   // TEST 1: If the user is in a group of tabs and opens a new tab at the end
   // of the strip, closing that new tab will select the tab that they were
   // last on.
 
   // Now simulate opening a new tab at the end of the TabStrip.
   TabContentsWrapper* new_tab_contents1 = CreateTabContents();
-  strip.AddTabContents(new_tab_contents1, -1, PageTransition::TYPED,
+  strip.AddTabContents(new_tab_contents1, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   // At this point, if we close this tab the last selected one should be
   // re-selected.
   strip.CloseTabContentsAt(strip.count() - 1, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(page_c_contents, strip.GetTabContentsAt(strip.active_index()));
 
   // TEST 2: If the user is in a group of tabs and opens a new tab at the end
   // of the strip, selecting any other tab in the strip will cause that new
   // tab's opener relationship to be forgotten.
 
   // Open a new tab again.
   TabContentsWrapper* new_tab_contents2 = CreateTabContents();
-  strip.AddTabContents(new_tab_contents2, -1, PageTransition::TYPED,
+  strip.AddTabContents(new_tab_contents2, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   // Now select the first tab.
   strip.ActivateTabAt(0, true);
 
   // Now select the last tab.
   strip.ActivateTabAt(strip.count() - 1, true);
 
   // Now close the last tab. The next adjacent should be selected.
   strip.CloseTabContentsAt(strip.count() - 1, TabStripModel::CLOSE_NONE);
@@ skipping 355 matching lines @@
 
 // Makes sure the TabStripModel calls the right observer methods during a
 // replace.
 TEST_F(TabStripModelTest, ReplaceSendsSelected) {
   typedef MockTabStripModelObserver::State State;
 
   TabStripDummyDelegate delegate(NULL);
   TabStripModel strip(&delegate, profile());
 
   TabContentsWrapper* first_contents = CreateTabContents();
-  strip.AddTabContents(first_contents, -1, PageTransition::TYPED,
+  strip.AddTabContents(first_contents, -1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   MockTabStripModelObserver tabstrip_observer;
   strip.AddObserver(&tabstrip_observer);
 
   TabContentsWrapper* new_contents = CreateTabContents();
   delete strip.ReplaceTabContentsAt(0, new_contents);
 
   ASSERT_EQ(2, tabstrip_observer.GetStateCount());
 
   // First event should be for replaced.
   State state(new_contents, 0, MockTabStripModelObserver::REPLACED);
   state.src_contents = first_contents;
   EXPECT_TRUE(tabstrip_observer.StateEquals(0, state));
 
   // And the second for selected.
   state = State(new_contents, 0, MockTabStripModelObserver::ACTIVATE);
   state.src_contents = first_contents;
   EXPECT_TRUE(tabstrip_observer.StateEquals(1, state));
 
   // Now add another tab and replace it, making sure we don't get a selected
   // event this time.
   TabContentsWrapper* third_contents = CreateTabContents();
-  strip.AddTabContents(third_contents, 1, PageTransition::TYPED,
+  strip.AddTabContents(third_contents, 1, content::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_NONE);
 
   tabstrip_observer.ClearStates();
 
   // And replace it.
   new_contents = CreateTabContents();
   delete strip.ReplaceTabContentsAt(1, new_contents);
 
   ASSERT_EQ(1, tabstrip_observer.GetStateCount());
 
@@ skipping 260 matching lines @@
   ASSERT_EQ(1, observer.GetStateCount());
   MockTabStripModelObserver::State s(
       contents2, 1, MockTabStripModelObserver::SELECT);
   s.src_contents = contents2;
   s.src_index = 1;
   s.user_gesture = false;
   EXPECT_TRUE(observer.StateEquals(0, s));
   strip.RemoveObserver(&observer);
   strip.CloseAllTabs();
 }