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

chrome/browser/tabs/tab_strip_model.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 <algorithm>
 #include <map>
 
 #include "base/command_line.h"
@@ skipping 22 matching lines @@
 #include "content/browser/user_metrics.h"
 #include "content/common/notification_service.h"
 
 namespace {
 
 // Returns true if the specified transition is one of the types that cause the
 // opener relationships for the tab in which the transition occured 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(PageTransition::Type transition) {
-  return transition == PageTransition::TYPED ||
-      transition == PageTransition::AUTO_BOOKMARK ||
-      transition == PageTransition::GENERATED ||
-      transition == PageTransition::KEYWORD ||
-      transition == PageTransition::START_PAGE;
+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_START_PAGE;
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModelDelegate, public:
 
 bool TabStripModelDelegate::CanCloseTab() const {
   return true;
 }
@@ skipping 414 matching lines @@
     next = iter - 1;
     if (next == end)
       break;
     if ((*next)->opener == opener)
       return static_cast<int>(next - contents_data_.begin());
   }
   return kNoTab;
 }
 
 void TabStripModel::TabNavigating(TabContentsWrapper* contents,
-                                  PageTransition::Type transition) {
+                                  content::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 164 matching lines @@
   DCHECK_NE(TabStripSelectionModel::kUnselectedIndex, source.active());
   TabContentsWrapper* old_contents = GetActiveTabContents();
   TabStripSelectionModel old_model;
   old_model.Copy(selection_model());
   selection_model_.Copy(source);
   NotifyIfActiveOrSelectionChanged(old_contents, false, old_model);
 }
 
 void TabStripModel::AddTabContents(TabContentsWrapper* contents,
                                    int index,
-                                   PageTransition::Type transition,
+                                   content::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 == PageTransition::LINK &&
+  if (transition == content::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(
         contents, 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 = order_controller_->DetermineInsertionIndexForAppending();
   }
 
-  if (transition == PageTransition::TYPED && index == count()) {
+  if (transition == content::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;
   }
   InsertTabContentsAt(
       index, contents,
       add_types | (inherit_group ? ADD_INHERIT_GROUP : 0));
   // Reset the index, just in case insert ended up moving it on us.
   index = GetIndexOfTabContents(contents);
 
-  if (inherit_group && transition == PageTransition::TYPED)
+  if (inherit_group && transition == content::PAGE_TRANSITION_TYPED)
     contents_data_.at(index)->reset_group_on_select = true;
 
   // TODO(sky): figure out why this is here and not in InsertTabContentsAt. When
   // here we seem to get failures in startup perf tests.
   // Ensure that the new TabContentsView begins at the same size as the
   // previous TabContentsView 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 600 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     const NavigationController* tab) {
   for (TabContentsDataVector::const_iterator i = contents_data_.begin();
        i != contents_data_.end(); ++i) {
     if ((*i)->group == tab)
       (*i)->group = NULL;
     if ((*i)->opener == tab)
       (*i)->opener = NULL;
   }
 }