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

chrome/browser/ui/tabs/tab_strip_model.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 <algorithm>
 #include <map>
 #include <string>
 
@@ skipping 18 matching lines @@
 using base::UserMetricsAction;
 using content::WebContents;
 
 namespace {
 
 // Returns true if the specified transition is one of the types that cause the
 // opener relationships for the tab in which the transition occurred to be
 // forgotten. This is generally any navigation that isn't a link click (i.e.
 // any navigation that can be considered to be the start of a new task distinct
 // from what had previously occurred in that tab).
-bool ShouldForgetOpenersForTransition(content::PageTransition transition) {
-  return transition == content::PAGE_TRANSITION_TYPED ||
-      transition == content::PAGE_TRANSITION_AUTO_BOOKMARK ||
-      transition == content::PAGE_TRANSITION_GENERATED ||
-      transition == content::PAGE_TRANSITION_KEYWORD ||
-      transition == content::PAGE_TRANSITION_AUTO_TOPLEVEL;
+bool ShouldForgetOpenersForTransition(ui::PageTransition transition) {
+  return transition == ui::PAGE_TRANSITION_TYPED ||
+      transition == ui::PAGE_TRANSITION_AUTO_BOOKMARK ||
+      transition == ui::PAGE_TRANSITION_GENERATED ||
+      transition == ui::PAGE_TRANSITION_KEYWORD ||
+      transition == ui::PAGE_TRANSITION_AUTO_TOPLEVEL;
 }
 
 // CloseTracker is used when closing a set of WebContents. It listens for
 // deletions of the WebContents and removes from the internal set any time one
 // is deleted.
 class CloseTracker {
  public:
   typedef std::vector<WebContents*> Contents;
 
   explicit CloseTracker(const Contents& contents);
@@ skipping 543 matching lines @@
   DCHECK(ContainsIndex(start_index));
 
   for (int i = contents_data_.size() - 1; i > start_index; --i) {
     if (contents_data_[i]->opener() == opener)
       return i;
   }
   return kNoTab;
 }
 
 void TabStripModel::TabNavigating(WebContents* contents,
-                                  content::PageTransition transition) {
+                                  ui::PageTransition transition) {
   if (ShouldForgetOpenersForTransition(transition)) {
     // Don't forget the openers if this tab is a New Tab page opened at the
     // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one
     // navigation of one of these transition types before resetting the
     // opener relationships (this allows for the use case of opening a new
     // tab to do a quick look-up of something while viewing a tab earlier in
     // the strip). We can make this heuristic more permissive if need be.
     if (!IsNewTabAtEndOfTabStrip(contents)) {
       // If the user navigates the current tab to another page in any way
       // other than by clicking a link, we want to pro-actively forget all
@@ skipping 157 matching lines @@
 }
 
 void TabStripModel::SetSelectionFromModel(
     const ui::ListSelectionModel& source) {
   DCHECK_NE(ui::ListSelectionModel::kUnselectedIndex, source.active());
   SetSelection(source, NOTIFY_DEFAULT);
 }
 
 void TabStripModel::AddWebContents(WebContents* contents,
                                    int index,
-                                   content::PageTransition transition,
+                                   ui::PageTransition transition,
                                    int add_types) {
   // If the newly-opened tab is part of the same task as the parent tab, we want
   // to inherit the parent's "group" attribute, so that if this tab is then
   // closed we'll jump back to the parent tab.
   bool inherit_group = (add_types & ADD_INHERIT_GROUP) == ADD_INHERIT_GROUP;
 
-  if (transition == content::PAGE_TRANSITION_LINK &&
+  if (transition == ui::PAGE_TRANSITION_LINK &&
       (add_types & ADD_FORCE_INDEX) == 0) {
     // We assume tabs opened via link clicks are part of the same task as their
     // parent.  Note that when |force_index| is true (e.g. when the user
     // drag-and-drops a link to the tab strip), callers aren't really handling
     // link clicks, they just want to score the navigation like a link click in
     // the history backend, so we don't inherit the group in this case.
     index = order_controller_->DetermineInsertionIndex(transition,
                                                        add_types & ADD_ACTIVE);
     inherit_group = true;
   } else {
     // For all other types, respect what was passed to us, normalizing -1s and
     // values that are too large.
     if (index < 0 || index > count())
       index = count();
   }
 
-  if (transition == content::PAGE_TRANSITION_TYPED && index == count()) {
+  if (transition == ui::PAGE_TRANSITION_TYPED && index == count()) {
     // Also, any tab opened at the end of the TabStrip with a "TYPED"
     // transition inherit group as well. This covers the cases where the user
     // creates a New Tab (e.g. Ctrl+T, or clicks the New Tab button), or types
     // in the address bar and presses Alt+Enter. This allows for opening a new
     // Tab to quickly look up something. When this Tab is closed, the old one
     // is re-selected, not the next-adjacent.
     inherit_group = true;
   }
   InsertWebContentsAt(index, contents,
                       add_types | (inherit_group ? ADD_INHERIT_GROUP : 0));
   // Reset the index, just in case insert ended up moving it on us.
   index = GetIndexOfWebContents(contents);
 
-  if (inherit_group && transition == content::PAGE_TRANSITION_TYPED)
+  if (inherit_group && transition == ui::PAGE_TRANSITION_TYPED)
     contents_data_[index]->set_reset_group_on_select(true);
 
   // TODO(sky): figure out why this is here and not in InsertWebContentsAt. When
   // here we seem to get failures in startup perf tests.
   // Ensure that the new WebContentsView begins at the same size as the
   // previous WebContentsView if it existed.  Otherwise, the initial WebKit
   // layout will be performed based on a width of 0 pixels, causing a
   // very long, narrow, inaccurate layout.  Because some scripts on pages (as
   // well as WebKit's anchor link location calculation) are run on the
   // initial layout and not recalculated later, we need to ensure the first
@@ skipping 570 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     const WebContents* tab) {
   for (WebContentsDataVector::const_iterator i = contents_data_.begin();
        i != contents_data_.end(); ++i) {
     if ((*i)->group() == tab)
       (*i)->set_group(NULL);
     if ((*i)->opener() == tab)
       (*i)->set_opener(NULL);
   }
 }