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

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 131 matching lines @@
 #include "content/browser/site_instance.h"
 #include "content/browser/tab_contents/interstitial_page.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
 #include "content/browser/user_metrics.h"
 #include "content/common/content_restriction.h"
 #include "content/common/content_switches.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
-#include "content/common/page_transition_types.h"
 #include "content/common/page_zoom.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources_standard.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_context.h"
 #include "ui/base/animation/animation.h"
@@ skipping 386 matching lines @@
 void Browser::OpenWindowWithRestoredTabs(Profile* profile) {
   TabRestoreService* service = TabRestoreServiceFactory::GetForProfile(profile);
   if (service)
     service->RestoreMostRecentEntry(NULL);
 }
 
 // static
 void Browser::OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Browser* browser = GetOrCreateTabbedBrowser(
       profile->GetOffTheRecordProfile());
-  browser->AddSelectedTabWithURL(url, PageTransition::LINK);
+  browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_LINK);
   browser->window()->Show();
 }
 
 // static
 TabContents* Browser::OpenApplication(
     Profile* profile,
     const Extension* extension,
     extension_misc::LaunchContainer container,
     WindowOpenDisposition disposition) {
   TabContents* tab = NULL;
@@ skipping 52 matching lines @@
     window_bounds.set_height(extension->launch_height());
   }
 
   Browser* browser = Browser::CreateForApp(type, app_name, window_bounds,
                                            profile);
 
   if (app_browser)
     *app_browser = browser;
 
   TabContentsWrapper* wrapper =
-      browser->AddSelectedTabWithURL(url, PageTransition::START_PAGE);
+      browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_START_PAGE);
   TabContents* contents = wrapper->tab_contents();
   contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   contents->render_view_host()->SyncRendererPrefs();
   browser->window()->Show();
 
   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
   //                focus explicitly.
   contents->view()->SetInitialFocus();
   return contents;
 }
@@ skipping 60 matching lines @@
   if (!extension_url.is_valid()) {
     extension_url = extension->options_url();
     if (!extension_url.is_valid())
       extension_url = GURL(std::string(chrome::kChromeUISettingsURL) +
                            chrome::kExtensionsSubPage);
   }
 
   // TODO(erikkay): START_PAGE doesn't seem like the right transition in all
   // cases.
   browser::NavigateParams params(browser, extension_url,
-                                 PageTransition::START_PAGE);
+                                 content::PAGE_TRANSITION_START_PAGE);
   params.tabstrip_add_types = add_type;
   params.disposition = disposition;
 
   if (disposition == CURRENT_TAB) {
     TabContents* existing_tab = browser->GetSelectedTabContents();
     TabStripModel* model = browser->tabstrip_model();
     int tab_index = model->GetWrapperIndex(existing_tab);
 
     existing_tab->OpenURL(extension->GetFullLaunchURL(), existing_tab->GetURL(),
-                          disposition, PageTransition::LINK);
+                          disposition, content::PAGE_TRANSITION_LINK);
     if (params.tabstrip_add_types & TabStripModel::ADD_PINNED) {
       model->SetTabPinned(tab_index, true);
       tab_index = model->GetWrapperIndex(existing_tab);
     }
     if (params.tabstrip_add_types & TabStripModel::ADD_ACTIVE)
       model->ActivateTabAt(tab_index, true);
 
     contents = existing_tab;
   } else {
     browser::Navigate(&params);
@@ skipping 358 matching lines @@
   return window()->IsTabStripEditable();
 }
 
 int Browser::GetIndexForInsertionDuringRestore(int relative_index) {
   return (tab_handler_->GetTabStripModel()->insertion_policy() ==
       TabStripModel::INSERT_AFTER) ? tab_count() : relative_index;
 }
 
 TabContentsWrapper* Browser::AddSelectedTabWithURL(
     const GURL& url,
-    PageTransition::Type transition) {
+    content::PageTransition transition) {
   browser::NavigateParams params(this, url, transition);
   params.disposition = NEW_FOREGROUND_TAB;
   browser::Navigate(&params);
   return params.target_contents;
 }
 
 TabContents* Browser::AddTab(TabContentsWrapper* tab_contents,
-                             PageTransition::Type type) {
+                             content::PageTransition type) {
   tab_handler_->GetTabStripModel()->AddTabContents(
       tab_contents, -1, type, TabStripModel::ADD_ACTIVE);
   return tab_contents->tab_contents();
 }
 
 void Browser::AddTabContents(TabContents* new_contents,
                              WindowOpenDisposition disposition,
                              const gfx::Rect& initial_pos,
                              bool user_gesture) {
   AddNewContents(NULL, new_contents, disposition, initial_pos, user_gesture);
@@ skipping 119 matching lines @@
   NavigationController& controller =
       GetOrCloneTabForDisposition(disp)->controller();
   if (index < 0 || index >= controller.entry_count())
     return false;
   controller.GoToIndex(index);
   return true;
 }
 
 browser::NavigateParams Browser::GetSingletonTabNavigateParams(
     const GURL& url) {
-  browser::NavigateParams params(this, url, PageTransition::AUTO_BOOKMARK);
+  browser::NavigateParams params(
+      this, url, content::PAGE_TRANSITION_AUTO_BOOKMARK);
   params.disposition = SINGLETON_TAB;
   params.window_action = browser::NavigateParams::SHOW_WINDOW;
   params.user_gesture = true;
   return params;
 }
 
 void Browser::ShowSingletonTab(const GURL& url) {
   browser::NavigateParams params(GetSingletonTabNavigateParams(url));
   browser::Navigate(&params);
 }
@@ skipping 47 matching lines @@
 // Browser, Assorted browser commands:
 
 TabContents* Browser::GetOrCloneTabForDisposition(
        WindowOpenDisposition disposition) {
   TabContentsWrapper* current_tab = GetSelectedTabContentsWrapper();
   switch (disposition) {
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB: {
       current_tab = current_tab->Clone();
       tab_handler_->GetTabStripModel()->AddTabContents(
-          current_tab, -1, PageTransition::LINK,
+          current_tab, -1, content::PAGE_TRANSITION_LINK,
           disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_ACTIVE :
                                               TabStripModel::ADD_NONE);
       break;
     }
     case NEW_WINDOW: {
       current_tab = current_tab->Clone();
       Browser* browser = Browser::Create(profile_);
       browser->tabstrip_model()->AddTabContents(
-          current_tab, -1, PageTransition::LINK, TabStripModel::ADD_ACTIVE);
+          current_tab, -1, content::PAGE_TRANSITION_LINK,
+          TabStripModel::ADD_ACTIVE);
       browser->window()->Show();
       break;
     }
     default:
       break;
   }
   return current_tab->tab_contents();
 }
 
 bool Browser::SupportsWindowFeatureImpl(WindowFeature feature,
@@ skipping 81 matching lines @@
   ReloadInternal(disposition, true);
 }
 
 void Browser::ReloadInternal(WindowOpenDisposition disposition,
                              bool ignore_cache) {
   // If we are showing an interstitial, treat this as an OpenURL.
   TabContents* current_tab = GetSelectedTabContents();
   if (current_tab && current_tab->showing_interstitial_page()) {
     NavigationEntry* entry = current_tab->controller().GetActiveEntry();
     DCHECK(entry);  // Should exist if interstitial is showing.
-    OpenURL(entry->url(), GURL(), disposition, PageTransition::RELOAD);
+    OpenURL(entry->url(), GURL(), disposition, content::PAGE_TRANSITION_RELOAD);
     return;
   }
 
   // As this is caused by a user action, give the focus to the page.
   TabContents* tab = GetOrCloneTabForDisposition(disposition);
   if (!tab->FocusLocationBarByDefault())
     tab->Focus();
   if (ignore_cache)
     tab->controller().ReloadIgnoringCache(true);
   else
     tab->controller().Reload(true);
 }
 
 void Browser::Home(WindowOpenDisposition disposition) {
   UserMetrics::RecordAction(UserMetricsAction("Home"));
-  OpenURL(GetHomePage(), GURL(), disposition,
-          PageTransition::AUTO_BOOKMARK | PageTransition::HOME_PAGE);
+  OpenURL(
+      GetHomePage(), GURL(), disposition,
+      content::PageTransitionFromInt(
+          content::PAGE_TRANSITION_AUTO_BOOKMARK |
+          content::PAGE_TRANSITION_HOME_PAGE));
 }
 
 void Browser::OpenCurrentURL() {
   UserMetrics::RecordAction(UserMetricsAction("LoadURL"));
   LocationBar* location_bar = window_->GetLocationBar();
   if (!location_bar)
     return;
 
   WindowOpenDisposition open_disposition =
       location_bar->GetWindowOpenDisposition();
@@ skipping 654 matching lines @@
 
 void Browser::ShowHelpTab() {
   UserMetrics::RecordAction(UserMetricsAction("ShowHelpTab"));
   GURL help_url(kHelpContentUrl);
   GURL localized_help_url = google_util::AppendGoogleLocaleParam(help_url);
   ShowSingletonTab(localized_help_url);
 }
 
 void Browser::OpenPrivacyDashboardTabAndActivate() {
   OpenURL(GURL(kPrivacyDashboardUrl), GURL(),
-          NEW_FOREGROUND_TAB, PageTransition::LINK);
+          NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_LINK);
   window_->Activate();
 }
 
 void Browser::OpenAutofillHelpTabAndActivate() {
   GURL help_url = google_util::AppendGoogleLocaleParam(GURL(kAutofillHelpUrl));
-  AddSelectedTabWithURL(help_url, PageTransition::LINK);
+  AddSelectedTabWithURL(help_url, content::PAGE_TRANSITION_LINK);
 }
 
 void Browser::OpenSearchEngineOptionsDialog() {
   UserMetrics::RecordAction(UserMetricsAction("EditSearchEngines"));
   ShowOptionsTab(chrome::kSearchEnginesSubPage);
 }
 
 #if defined(FILE_MANAGER_EXTENSION)
 void Browser::OpenFileManager() {
   UserMetrics::RecordAction(UserMetricsAction("OpenFileManager"));
@@ skipping 12 matching lines @@
   ShowOptionsTab(chrome::kInternetOptionsSubPage);
 }
 
 void Browser::OpenLanguageOptionsDialog() {
   UserMetrics::RecordAction(UserMetricsAction("OpenLanguageOptionsDialog"));
   ShowOptionsTab(chrome::kLanguageOptionsSubPage);
 }
 
 void Browser::OpenSystemTabAndActivate() {
   OpenURL(GURL(chrome::kChromeUISystemInfoURL), GURL(),
-          NEW_FOREGROUND_TAB, PageTransition::LINK);
+          NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_LINK);
   window_->Activate();
 }
 
 void Browser::OpenMobilePlanTabAndActivate() {
   OpenURL(GURL(chrome::kChromeUIMobileSetupURL), GURL(),
-          NEW_FOREGROUND_TAB, PageTransition::LINK);
+          NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_LINK);
   window_->Activate();
 }
 #endif
 
 void Browser::OpenPluginsTabAndActivate() {
   OpenURL(GURL(chrome::kChromeUIPluginsURL), GURL(),
-          NEW_FOREGROUND_TAB, PageTransition::LINK);
+          NEW_FOREGROUND_TAB, content::PAGE_TRANSITION_LINK);
   window_->Activate();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // static
 void Browser::SetNewHomePagePrefs(PrefService* prefs) {
   const PrefService::Preference* home_page_pref =
       prefs->FindPreference(prefs::kHomePage);
   if (home_page_pref &&
@@ skipping 613 matching lines @@
   }
 }
 
 int Browser::GetLastBlockedCommand(WindowOpenDisposition* disposition) {
   if (disposition)
     *disposition = last_blocked_command_disposition_;
   return last_blocked_command_id_;
 }
 
 void Browser::UpdateUIForNavigationInTab(TabContentsWrapper* contents,
-                                         PageTransition::Type transition,
+                                         content::PageTransition transition,
                                          bool user_initiated) {
   tabstrip_model()->TabNavigating(contents, transition);
 
   bool contents_is_selected = contents == GetSelectedTabContentsWrapper();
   if (user_initiated && contents_is_selected && window()->GetLocationBar()) {
     // Forcibly reset the location bar if the url is going to change in the
     // current tab, since otherwise it won't discard any ongoing user edits,
     // since it doesn't realize this is a user-initiated action.
     window()->GetLocationBar()->Revert();
   }
@@ skipping 40 matching lines @@
   return home_page;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, PageNavigator implementation:
 
 // TODO(adriansc): Remove this method once refactoring changed all call sites.
 TabContents* Browser::OpenURL(const GURL& url,
                               const GURL& referrer,
                               WindowOpenDisposition disposition,
-                              PageTransition::Type transition) {
+                              content::PageTransition transition) {
   return OpenURLFromTab(NULL,
                         OpenURLParams(url, referrer, disposition, transition));
 }
 
 TabContents* Browser::OpenURL(const OpenURLParams& params) {
   return OpenURLFromTab(NULL, params);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CommandUpdater::CommandUpdaterDelegate implementation:
@@ skipping 22 matching lines @@
 
   return AddBlankTabAt(-1, foreground);
 }
 
 TabContentsWrapper* Browser::AddBlankTabAt(int index, bool foreground) {
   // Time new tab page creation time.  We keep track of the timing data in
   // TabContents, but we want to include the time it takes to create the
   // TabContents object too.
   base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
   browser::NavigateParams params(this, GURL(chrome::kChromeUINewTabURL),
-                                 PageTransition::TYPED);
+                                 content::PAGE_TRANSITION_TYPED);
   params.disposition = foreground ? NEW_FOREGROUND_TAB : NEW_BACKGROUND_TAB;
   params.tabstrip_index = index;
   browser::Navigate(&params);
   params.target_contents->tab_contents()->set_new_tab_start_time(
       new_tab_start_time);
   return params.target_contents;
 }
 
 Browser* Browser::CreateNewStripWithContents(
     TabContentsWrapper* detached_contents,
@@ skipping 19 matching lines @@
   return browser;
 }
 
 int Browser::GetDragActions() const {
   return TabStripModelDelegate::TAB_TEAROFF_ACTION | (tab_count() > 1 ?
       TabStripModelDelegate::TAB_MOVE_ACTION : 0);
 }
 
 TabContentsWrapper* Browser::CreateTabContentsForURL(
     const GURL& url, const GURL& referrer, Profile* profile,
-    PageTransition::Type transition, bool defer_load,
+    content::PageTransition transition, bool defer_load,
     SiteInstance* instance) const {
   TabContentsWrapper* contents = TabContentsFactory(profile, instance,
       MSG_ROUTING_NONE,
       GetSelectedTabContents(), NULL);
   if (!defer_load) {
     // Load the initial URL before adding the new tab contents to the tab strip
     // so that the tab contents has navigation state.
     contents->controller().LoadURL(url, referrer, transition, std::string());
   }
 
@@ skipping 38 matching lines @@
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now.  Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
-    browser->AddTab(contents_dupe, PageTransition::LINK);
+    browser->AddTab(contents_dupe, content::PAGE_TRANSITION_LINK);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(contents_dupe, pinned);
 }
 
 void Browser::CloseFrameAfterDragSession() {
 #if !defined(OS_MACOSX)
@@ skipping 263 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabContentsDelegate implementation:
 
 // TODO(adriansc): Remove this method once refactoring changed all call sites.
 TabContents* Browser::OpenURLFromTab(TabContents* source,
                                      const GURL& url,
                                      const GURL& referrer,
                                      WindowOpenDisposition disposition,
-                                     PageTransition::Type transition) {
+                                     content::PageTransition transition) {
   return OpenURLFromTab(source, OpenURLParams(url, referrer, disposition,
                                               transition));
 }
 
 TabContents* Browser::OpenURLFromTab(TabContents* source,
                                      const OpenURLParams& params) {
   browser::NavigateParams nav_params(this, params.url, params.transition);
   nav_params.source_contents =
       tabstrip_model()->GetTabContentsAt(
           tabstrip_model()->GetWrapperIndex(source));
@@ skipping 637 matching lines @@
     window_->SetStarredState(starred);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, SelectFileDialog::Listener implementation:
 
 void Browser::FileSelected(const FilePath& path, int index, void* params) {
   profile_->set_last_selected_directory(path.DirName());
   GURL file_url = net::FilePathToFileURL(path);
   if (!file_url.is_empty())
-    OpenURL(file_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
+    OpenURL(file_url, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, NotificationObserver implementation:
 
 void Browser::Observe(int type,
                       const NotificationSource& source,
                       const NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_TAB_CONTENTS_DISCONNECTED:
@@ skipping 1213 matching lines @@
     // been given an offset by the OS, so we shouldn't copy the old bounds.
     BrowserWindow* new_window = browser->window();
     new_window->SetBounds(gfx::Rect(new_window->GetRestoredBounds().origin(),
                           window()->GetRestoredBounds().size()));
 
     // We need to show the browser now. Otherwise ContainerWin assumes the
     // TabContents is invisible and won't size it.
     browser->window()->Show();
 
     // The page transition below is only for the purpose of inserting the tab.
-    browser->AddTab(view_source_contents, PageTransition::LINK);
+    browser->AddTab(view_source_contents, content::PAGE_TRANSITION_LINK);
   }
 
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile_);
   if (session_service)
     session_service->TabRestored(view_source_contents, false);
 }
 
 int Browser::GetContentRestrictionsForSelectedTab() {
   int content_restrictions = 0;
@@ skipping 82 matching lines @@
     window_->GetLocationBar()->ShowFirstRunBubble(bubble_type);
   } else if (is_type_tabbed()) {
     GlobalErrorService* service =
         GlobalErrorServiceFactory::GetForProfile(profile());
     GlobalError* error = service->GetFirstGlobalErrorWithBubbleView();
     if (error) {
       error->ShowBubbleView(this);
     }
   }
 }