Move PageTransition from //content/public/common to //ui/base

chrome/browser/ui/tabs/tab_strip_model_unittest.cc

 // Copyright (c) 2012 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/ui/tabs/tab_strip_model.h"
 
 #include <map>
 #include <string>
 
 #include "base/files/file_path.h"
@@ skipping 739 matching lines @@
   // If the last tab in the group is closed, the preceding tab in the same
   // group should be selected.
   EXPECT_EQ(3, tabstrip.GetIndexOfNextWebContentsOpenedBy(contents5, 4, false));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 static int GetInsertionIndex(TabStripModel* tabstrip) {
   return tabstrip->order_controller()->DetermineInsertionIndex(
-      content::PAGE_TRANSITION_LINK, false);
+      ui::PAGE_TRANSITION_LINK, false);
 }
 
 static void InsertWebContentses(TabStripModel* tabstrip,
                                 WebContents* contents1,
                                 WebContents* contents2,
                                 WebContents* contents3) {
   tabstrip->InsertWebContentsAt(GetInsertionIndex(tabstrip),
                                 contents1,
                                 TabStripModel::ADD_INHERIT_GROUP);
   tabstrip->InsertWebContentsAt(GetInsertionIndex(tabstrip),
@@ skipping 60 matching lines @@
 
   // The opener API should work...
   EXPECT_EQ(3, tabstrip.GetIndexOfNextWebContentsOpenedBy(opener, 2, false));
   EXPECT_EQ(2, tabstrip.GetIndexOfNextWebContentsOpenedBy(opener, 3, false));
   EXPECT_EQ(3, tabstrip.GetIndexOfLastWebContentsOpenedBy(opener, 1));
 
   // Now open a foreground tab from a link. It should be opened adjacent to the
   // opener tab.
   WebContents* fg_link_contents = CreateWebContents();
   int insert_index = tabstrip.order_controller()->DetermineInsertionIndex(
-      content::PAGE_TRANSITION_LINK, true);
+      ui::PAGE_TRANSITION_LINK, true);
   EXPECT_EQ(1, insert_index);
   tabstrip.InsertWebContentsAt(insert_index, fg_link_contents,
                                TabStripModel::ADD_ACTIVE |
                                TabStripModel::ADD_INHERIT_GROUP);
   EXPECT_EQ(1, tabstrip.active_index());
   EXPECT_EQ(fg_link_contents, tabstrip.GetActiveWebContents());
 
   // 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.
   WebContents* fg_nonlink_contents = CreateWebContents();
   insert_index = tabstrip.order_controller()->DetermineInsertionIndex(
-      content::PAGE_TRANSITION_AUTO_BOOKMARK, true);
+      ui::PAGE_TRANSITION_AUTO_BOOKMARK, true);
   EXPECT_EQ(tabstrip.count(), insert_index);
   // We break the opener relationship...
   tabstrip.InsertWebContentsAt(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.GetActiveWebContents());
@@ skipping 359 matching lines @@
 // using this "smart" function with a simulated middle click action on a series
 // of links on the home page.
 TEST_F(TabStripModelTest, AddWebContents_MiddleClickLinksAndClose) {
   TabStripDummyDelegate delegate;
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page.
   WebContents* homepage_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      homepage_contents, -1, ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   WebContents* typed_page_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
+      typed_page_contents, -1, ui::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.
   WebContents* middle_click_contents1 = CreateWebContents();
   tabstrip.AddWebContents(
-      middle_click_contents1, -1, content::PAGE_TRANSITION_LINK,
+      middle_click_contents1, -1, ui::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   WebContents* middle_click_contents2 = CreateWebContents();
   tabstrip.AddWebContents(
-      middle_click_contents2, -1, content::PAGE_TRANSITION_LINK,
+      middle_click_contents2, -1, ui::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   WebContents* middle_click_contents3 = CreateWebContents();
   tabstrip.AddWebContents(
-      middle_click_contents3, -1, content::PAGE_TRANSITION_LINK,
+      middle_click_contents3, -1, ui::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
 
   EXPECT_EQ(5, tabstrip.count());
 
   EXPECT_EQ(homepage_contents, tabstrip.GetWebContentsAt(0));
   EXPECT_EQ(middle_click_contents1, tabstrip.GetWebContentsAt(1));
   EXPECT_EQ(middle_click_contents2, tabstrip.GetWebContentsAt(2));
   EXPECT_EQ(middle_click_contents3, tabstrip.GetWebContentsAt(3));
   EXPECT_EQ(typed_page_contents, tabstrip.GetWebContentsAt(4));
 
@@ skipping 23 matching lines @@
 // that opens a new tab is inserted correctly adjacent to the tab that spawned
 // it.
 TEST_F(TabStripModelTest, AddWebContents_LeftClickPopup) {
   TabStripDummyDelegate delegate;
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page.
   WebContents* homepage_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      homepage_contents, -1, ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   WebContents* typed_page_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
+      typed_page_contents, -1, ui::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.
   WebContents* left_click_contents = CreateWebContents();
   tabstrip.AddWebContents(left_click_contents, -1,
-                          content::PAGE_TRANSITION_LINK,
+                          ui::PAGE_TRANSITION_LINK,
                           TabStripModel::ADD_ACTIVE);
 
   // Verify the state meets our expectations.
   EXPECT_EQ(3, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetWebContentsAt(0));
   EXPECT_EQ(left_click_contents, tabstrip.GetWebContentsAt(1));
   EXPECT_EQ(typed_page_contents, tabstrip.GetWebContentsAt(2));
 
   // The newly created tab should be selected.
   EXPECT_EQ(left_click_contents, tabstrip.GetActiveWebContents());
@@ skipping 13 matching lines @@
 // generated urls, also blank tabs) open at the end of the tabstrip instead of
 // in the middle.
 TEST_F(TabStripModelTest, AddWebContents_CreateNewBlankTab) {
   TabStripDummyDelegate delegate;
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page.
   WebContents* homepage_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      homepage_contents, -1, ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   WebContents* typed_page_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
+      typed_page_contents, -1, ui::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.
   WebContents* new_blank_contents = CreateWebContents();
   tabstrip.AddWebContents(new_blank_contents, -1,
-                          content::PAGE_TRANSITION_TYPED,
+                          ui::PAGE_TRANSITION_TYPED,
                           TabStripModel::ADD_ACTIVE);
 
   // Verify the state of the tabstrip.
   EXPECT_EQ(3, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetWebContentsAt(0));
   EXPECT_EQ(typed_page_contents, tabstrip.GetWebContentsAt(1));
   EXPECT_EQ(new_blank_contents, tabstrip.GetWebContentsAt(2));
 
   // Now open a couple more blank tabs in the background.
   WebContents* background_blank_contents1 = CreateWebContents();
   tabstrip.AddWebContents(
-      background_blank_contents1, -1, content::PAGE_TRANSITION_TYPED,
+      background_blank_contents1, -1, ui::PAGE_TRANSITION_TYPED,
       TabStripModel::ADD_NONE);
   WebContents* background_blank_contents2 = CreateWebContents();
   tabstrip.AddWebContents(
-      background_blank_contents2, -1, content::PAGE_TRANSITION_GENERATED,
+      background_blank_contents2, -1, ui::PAGE_TRANSITION_GENERATED,
       TabStripModel::ADD_NONE);
   EXPECT_EQ(5, tabstrip.count());
   EXPECT_EQ(homepage_contents, tabstrip.GetWebContentsAt(0));
   EXPECT_EQ(typed_page_contents, tabstrip.GetWebContentsAt(1));
   EXPECT_EQ(new_blank_contents, tabstrip.GetWebContentsAt(2));
   EXPECT_EQ(background_blank_contents1, tabstrip.GetWebContentsAt(3));
   EXPECT_EQ(background_blank_contents2, tabstrip.GetWebContentsAt(4));
 
   tabstrip.CloseAllTabs();
   EXPECT_TRUE(tabstrip.empty());
 }
 
 // Tests whether opener state is correctly forgotten when the user switches
 // context.
 TEST_F(TabStripModelTest, AddWebContents_ForgetOpeners) {
   TabStripDummyDelegate delegate;
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page
   WebContents* homepage_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      homepage_contents, -1, ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   WebContents* typed_page_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
+      typed_page_contents, -1, ui::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.
   WebContents* middle_click_contents1 = CreateWebContents();
   tabstrip.AddWebContents(
-      middle_click_contents1, -1, content::PAGE_TRANSITION_LINK,
+      middle_click_contents1, -1, ui::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   WebContents* middle_click_contents2 = CreateWebContents();
   tabstrip.AddWebContents(
-      middle_click_contents2, -1, content::PAGE_TRANSITION_LINK,
+      middle_click_contents2, -1, ui::PAGE_TRANSITION_LINK,
       TabStripModel::ADD_NONE);
   WebContents* middle_click_contents3 = CreateWebContents();
   tabstrip.AddWebContents(
-      middle_click_contents3, -1, content::PAGE_TRANSITION_LINK,
+      middle_click_contents3, -1, ui::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.GetWebContentsAt(4));
   tabstrip.SelectLastTab();
   EXPECT_EQ(typed_page_contents, tabstrip.GetActiveWebContents());
 
   // Step back into the context by selecting a tab inside it.
   tabstrip.ActivateTabAt(2, true);
   EXPECT_EQ(middle_click_contents2, tabstrip.GetActiveWebContents());
@@ skipping 18 matching lines @@
 
 // Added for http://b/issue?id=958960
 TEST_F(TabStripModelTest, AppendContentsReselectionTest) {
   TabStripDummyDelegate delegate;
   TabStripModel tabstrip(&delegate, profile());
   EXPECT_TRUE(tabstrip.empty());
 
   // Open the Home Page.
   WebContents* homepage_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      homepage_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      homepage_contents, -1, ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Open some other tab, by user typing.
   WebContents* typed_page_contents = CreateWebContents();
   tabstrip.AddWebContents(
-      typed_page_contents, -1, content::PAGE_TRANSITION_TYPED,
+      typed_page_contents, -1, ui::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 correct tab gets selected when the new tab is closed.
   WebContents* target_blank = CreateWebContents();
   tabstrip.AppendWebContents(target_blank, true);
   EXPECT_EQ(2, tabstrip.active_index());
   tabstrip.CloseWebContentsAt(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;
   TabStripModel strip(&delegate, profile());
 
   // Open page A
   WebContents* page_a_contents = CreateWebContents();
   strip.AddWebContents(
-      page_a_contents, -1, content::PAGE_TRANSITION_AUTO_BOOKMARK,
+      page_a_contents, -1, ui::PAGE_TRANSITION_AUTO_BOOKMARK,
       TabStripModel::ADD_ACTIVE);
 
   // Simulate middle click to open page A.A and A.B
   WebContents* page_a_a_contents = CreateWebContents();
-  strip.AddWebContents(page_a_a_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_a_a_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   WebContents* page_a_b_contents = CreateWebContents();
-  strip.AddWebContents(page_a_b_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_a_b_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Select page A.A
   strip.ActivateTabAt(1, true);
   EXPECT_EQ(page_a_a_contents, strip.GetActiveWebContents());
 
   // Simulate a middle click to open page A.A.A
   WebContents* page_a_a_a_contents = CreateWebContents();
-  strip.AddWebContents(page_a_a_a_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_a_a_a_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   EXPECT_EQ(page_a_a_a_contents, strip.GetWebContentsAt(2));
 
   // Close page A.A
   strip.CloseWebContentsAt(strip.active_index(), TabStripModel::CLOSE_NONE);
 
   // Page A.A.A should be selected, NOT A.B
   EXPECT_EQ(page_a_a_a_contents, strip.GetActiveWebContents());
 
@@ skipping 13 matching lines @@
   strip.CloseAllTabs();
 }
 
 TEST_F(TabStripModelTest, AddWebContents_NewTabAtEndOfStripInheritsGroup) {
   TabStripDummyDelegate delegate;
   TabStripModel strip(&delegate, profile());
 
   // Open page A
   WebContents* page_a_contents = CreateWebContents();
   strip.AddWebContents(page_a_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                        TabStripModel::ADD_ACTIVE);
 
   // Open pages B, C and D in the background from links on page A...
   WebContents* page_b_contents = CreateWebContents();
   WebContents* page_c_contents = CreateWebContents();
   WebContents* page_d_contents = CreateWebContents();
-  strip.AddWebContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_b_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddWebContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_c_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddWebContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_d_contents, -1, ui::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)
   WebContents* new_contents = CreateWebContents();
-  strip.AddWebContents(new_contents, -1, content::PAGE_TRANSITION_TYPED,
+  strip.AddWebContents(new_contents, -1, ui::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfWebContents(new_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.CloseWebContentsAt(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.
   WebContents* page_e_contents = CreateWebContents();
-  strip.AddWebContents(page_e_contents, -1, content::PAGE_TRANSITION_TYPED,
+  strip.AddWebContents(page_e_contents, -1, ui::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfWebContents(page_e_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the Tab. Selection should shift back to page B's Tab.
   strip.CloseWebContentsAt(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.
   WebContents* page_f_contents = CreateWebContents();
   strip.AddWebContents(page_f_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_BOOKMARK,
+                       ui::PAGE_TRANSITION_AUTO_BOOKMARK,
                        TabStripModel::ADD_ACTIVE);
 
   EXPECT_EQ(4, strip.GetIndexOfWebContents(page_f_contents));
   EXPECT_EQ(4, strip.active_index());
 
   // Close the Tab. The next-adjacent should be selected.
   strip.CloseWebContentsAt(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;
   TabStripModel strip(&delegate, profile());
 
   // Open page A
   WebContents* page_a_contents = CreateWebContents();
   strip.AddWebContents(page_a_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                        TabStripModel::ADD_ACTIVE);
 
   // Open pages B, C and D in the background from links on page A...
   WebContents* page_b_contents = CreateWebContents();
   WebContents* page_c_contents = CreateWebContents();
   WebContents* page_d_contents = CreateWebContents();
-  strip.AddWebContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_b_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddWebContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_c_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddWebContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_d_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Open page E in a different opener group from page A.
   WebContents* page_e_contents = CreateWebContents();
   strip.AddWebContents(page_e_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                        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, content::PAGE_TRANSITION_LINK);
+  strip.TabNavigating(page_d_contents, ui::PAGE_TRANSITION_LINK);
 
   // Close page D, page C should be selected. (part of same group).
   strip.CloseWebContentsAt(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, content::PAGE_TRANSITION_AUTO_BOOKMARK);
+  strip.TabNavigating(page_c_contents, ui::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.CloseWebContentsAt(2, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(page_e_contents, strip.GetWebContentsAt(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
 // selected (Test 2 below).
 TEST_F(TabStripModelTest, NavigationForgettingDoesntAffectNewTab) {
   TabStripDummyDelegate delegate;
   TabStripModel strip(&delegate, profile());
 
   // Open a tab and several tabs from it, then select one of the tabs that was
   // opened.
   WebContents* page_a_contents = CreateWebContents();
   strip.AddWebContents(page_a_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                        TabStripModel::ADD_ACTIVE);
 
   WebContents* page_b_contents = CreateWebContents();
   WebContents* page_c_contents = CreateWebContents();
   WebContents* page_d_contents = CreateWebContents();
-  strip.AddWebContents(page_b_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_b_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddWebContents(page_c_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_c_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
-  strip.AddWebContents(page_d_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_d_contents, -1, ui::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.
   WebContents* new_contents1 = CreateWebContents();
-  strip.AddWebContents(new_contents1, -1, content::PAGE_TRANSITION_TYPED,
+  strip.AddWebContents(new_contents1, -1, ui::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   // At this point, if we close this tab the last selected one should be
   // re-selected.
   strip.CloseWebContentsAt(strip.count() - 1, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(page_c_contents, strip.GetWebContentsAt(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.
   WebContents* new_contents2 = CreateWebContents();
-  strip.AddWebContents(new_contents2, -1, content::PAGE_TRANSITION_TYPED,
+  strip.AddWebContents(new_contents2, -1, ui::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.CloseWebContentsAt(strip.count() - 1, TabStripModel::CLOSE_NONE);
@@ skipping 370 matching lines @@
 
 // Makes sure the TabStripModel calls the right observer methods during a
 // replace.
 TEST_F(TabStripModelTest, ReplaceSendsSelected) {
   typedef MockTabStripModelObserver::State State;
 
   TabStripDummyDelegate delegate;
   TabStripModel strip(&delegate, profile());
 
   WebContents* first_contents = CreateWebContents();
-  strip.AddWebContents(first_contents, -1, content::PAGE_TRANSITION_TYPED,
+  strip.AddWebContents(first_contents, -1, ui::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_ACTIVE);
 
   MockTabStripModelObserver tabstrip_observer(&strip);
   strip.AddObserver(&tabstrip_observer);
 
   WebContents* new_contents = CreateWebContents();
   delete strip.ReplaceWebContentsAt(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;
   state.change_reason = TabStripModelObserver::CHANGE_REASON_REPLACED;
   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.
   WebContents* third_contents = CreateWebContents();
-  strip.AddWebContents(third_contents, 1, content::PAGE_TRANSITION_TYPED,
+  strip.AddWebContents(third_contents, 1, ui::PAGE_TRANSITION_TYPED,
                        TabStripModel::ADD_NONE);
 
   tabstrip_observer.ClearStates();
 
   // And replace it.
   new_contents = CreateWebContents();
   delete strip.ReplaceWebContentsAt(1, new_contents);
 
   ASSERT_EQ(1, tabstrip_observer.GetStateCount());
 
@@ skipping 172 matching lines @@
 }
 
 // Tests that moving a tab forgets all groups referencing it.
 TEST_F(TabStripModelTest, MoveSelectedTabsTo_ForgetGroups) {
   TabStripDummyDelegate delegate;
   TabStripModel strip(&delegate, profile());
 
   // Open page A as a new tab and then A1 in the background from A.
   WebContents* page_a_contents = CreateWebContents();
   strip.AddWebContents(page_a_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                        TabStripModel::ADD_ACTIVE);
   WebContents* page_a1_contents = CreateWebContents();
-  strip.AddWebContents(page_a1_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_a1_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   // Likewise, open pages B and B1.
   WebContents* page_b_contents = CreateWebContents();
   strip.AddWebContents(page_b_contents, -1,
-                       content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                       ui::PAGE_TRANSITION_AUTO_TOPLEVEL,
                        TabStripModel::ADD_ACTIVE);
   WebContents* page_b1_contents = CreateWebContents();
-  strip.AddWebContents(page_b1_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_b1_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
 
   EXPECT_EQ(page_a_contents, strip.GetWebContentsAt(0));
   EXPECT_EQ(page_a1_contents, strip.GetWebContentsAt(1));
   EXPECT_EQ(page_b_contents, strip.GetWebContentsAt(2));
   EXPECT_EQ(page_b1_contents, strip.GetWebContentsAt(3));
 
   // Move page B to the start of the tab strip.
   strip.MoveSelectedTabsTo(0);
 
   // Open page B2 in the background from B. It should end up after B.
   WebContents* page_b2_contents = CreateWebContents();
-  strip.AddWebContents(page_b2_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_b2_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   EXPECT_EQ(page_b_contents, strip.GetWebContentsAt(0));
   EXPECT_EQ(page_b2_contents, strip.GetWebContentsAt(1));
   EXPECT_EQ(page_a_contents, strip.GetWebContentsAt(2));
   EXPECT_EQ(page_a1_contents, strip.GetWebContentsAt(3));
   EXPECT_EQ(page_b1_contents, strip.GetWebContentsAt(4));
 
   // Switch to A.
   strip.ActivateTabAt(2, true);
   EXPECT_EQ(page_a_contents, strip.GetActiveWebContents());
 
   // Open page A2 in the background from A. It should end up after A1.
   WebContents* page_a2_contents = CreateWebContents();
-  strip.AddWebContents(page_a2_contents, -1, content::PAGE_TRANSITION_LINK,
+  strip.AddWebContents(page_a2_contents, -1, ui::PAGE_TRANSITION_LINK,
                        TabStripModel::ADD_NONE);
   EXPECT_EQ(page_b_contents, strip.GetWebContentsAt(0));
   EXPECT_EQ(page_b2_contents, strip.GetWebContentsAt(1));
   EXPECT_EQ(page_a_contents, strip.GetWebContentsAt(2));
   EXPECT_EQ(page_a1_contents, strip.GetWebContentsAt(3));
   EXPECT_EQ(page_a2_contents, strip.GetWebContentsAt(4));
   EXPECT_EQ(page_b1_contents, strip.GetWebContentsAt(5));
 
   strip.CloseAllTabs();
 }
@@ skipping 200 matching lines @@
   WebContents* moved_contents = strip_src.DetachWebContentsAt(1);
   EXPECT_EQ(contents2, moved_contents);
 
   // Attach the tab to the destination tab strip.
   strip_dst.AppendWebContents(moved_contents, true);
   EXPECT_TRUE(strip_dst.IsTabBlocked(0));
 
   strip_dst.CloseAllTabs();
   strip_src.CloseAllTabs();
 }