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

content/browser/tab_contents/tab_contents.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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 517 matching lines @@
   // TODO(creis): Should we fire even for interstitial pages?
   return notify_disconnection() &&
       !showing_interstitial_page() &&
       !render_view_host()->SuddenTerminationAllowed();
 }
 
 // TODO(adriansc): Remove this method once refactoring changed all call sites.
 TabContents* TabContents::OpenURL(const GURL& url,
                                   const GURL& referrer,
                                   WindowOpenDisposition disposition,
-                                  PageTransition::Type transition) {
+                                  content::PageTransition transition) {
   return OpenURL(OpenURLParams(url, referrer, disposition, transition));
 }
 
 TabContents* TabContents::OpenURL(const OpenURLParams& params) {
   if (delegate_) {
     TabContents* new_contents = delegate_->OpenURLFromTab(this, params);
     // Notify observers.
     FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                       DidOpenURL(params.url, params.referrer,
                                  params.disposition, params.transition));
@@ skipping 492 matching lines @@
 }
 
 void TabContents::OnGoToEntryAtOffset(int offset) {
   if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
     NavigationEntry* entry = controller_.GetEntryAtOffset(offset);
     if (!entry)
       return;
     // Note that we don't call NavigationController::GotToOffset() as we don't
     // want to create a pending navigation entry (it might end up lingering
     // http://crbug.com/51680).
-    entry->set_transition_type(entry->transition_type() |
-                               PageTransition::FORWARD_BACK);
+    entry->set_transition_type(
+        content::PageTransitionFromInt(
+            entry->transition_type() |
+            content::PAGE_TRANSITION_FORWARD_BACK));
     NavigateToEntry(*entry, NavigationController::NO_RELOAD);
 
     // If the entry is being restored and doesn't have a SiteInstance yet, fill
     // it in now that we know. This allows us to find the entry when it commits.
     if (!entry->site_instance() &&
         entry->restore_type() != NavigationEntry::RESTORE_NONE) {
       entry->set_site_instance(GetPendingSiteInstance());
     }
   }
 }
@@ skipping 385 matching lines @@
 
   FOR_EACH_OBSERVER(TabContentsObserver, observers_, RenderViewGone());
 }
 
 void TabContents::RenderViewDeleted(RenderViewHost* rvh) {
   render_manager_.RenderViewDeleted(rvh);
 }
 
 void TabContents::DidNavigate(RenderViewHost* rvh,
                               const ViewHostMsg_FrameNavigate_Params& params) {
-  if (PageTransition::IsMainFrame(params.transition))
+  if (content::PageTransitionIsMainFrame(params.transition))
     render_manager_.DidNavigateMainFrame(rvh);
 
   // Update the site of the SiteInstance if it doesn't have one yet.
   if (!GetSiteInstance()->has_site())
     GetSiteInstance()->SetSite(params.url);
 
   // Need to update MIME type here because it's referred to in
   // UpdateNavigationCommands() called by RendererDidNavigate() to
   // determine whether or not to enable the encoding menu.
   // It's updated only for the main frame. For a subframe,
   // RenderView::UpdateURL does not set params.contents_mime_type.
   // (see http://code.google.com/p/chromium/issues/detail?id=2929 )
   // TODO(jungshik): Add a test for the encoding menu to avoid
   // regressing it again.
-  if (PageTransition::IsMainFrame(params.transition))
+  if (content::PageTransitionIsMainFrame(params.transition))
     contents_mime_type_ = params.contents_mime_type;
 
   content::LoadCommittedDetails details;
   bool did_navigate = controller_.RendererDidNavigate(params, &details);
 
   // Send notification about committed provisional loads. This notification is
   // different from the NAV_ENTRY_COMMITTED notification which doesn't include
   // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
   if (details.type != NavigationType::NAV_IGNORE) {
     // For AUTO_SUBFRAME navigations, an event for the main frame is generated
     // that is not recorded in the navigation history. For the purpose of
     // tracking navigation events, we treat this event as a sub frame navigation
     // event.
     bool is_main_frame = did_navigate ? details.is_main_frame : false;
-    PageTransition::Type transition_type = params.transition;
+    content::PageTransition transition_type = params.transition;
     // Whether or not a page transition was triggered by going backward or
     // forward in the history is only stored in the navigation controller's
     // entry list.
     if (did_navigate &&
         (controller_.GetActiveEntry()->transition_type() &
-            PageTransition::FORWARD_BACK)) {
-      transition_type = params.transition | PageTransition::FORWARD_BACK;
+            content::PAGE_TRANSITION_FORWARD_BACK)) {
+      transition_type = content::PageTransitionFromInt(
+          params.transition | content::PAGE_TRANSITION_FORWARD_BACK);
     }
     // Notify observers about the commit of the provisional load.
     FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                       DidCommitProvisionalLoadForFrame(params.frame_id,
                       is_main_frame, params.url, transition_type));
   }
 
   if (!did_navigate)
     return;  // No navigation happened.
 
@@ skipping 155 matching lines @@
       content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
       Source<TabContents>(this),
       Details<int>(&page_id));
 }
 
 void TabContents::RequestOpenURL(const GURL& url,
                                  const GURL& referrer,
                                  WindowOpenDisposition disposition,
                                  int64 source_frame_id) {
   TabContents* new_contents = NULL;
-  PageTransition::Type transition_type = PageTransition::LINK;
+  content::PageTransition transition_type = content::PAGE_TRANSITION_LINK;
   if (render_manager_.web_ui()) {
     // When we're a Web UI, it will provide a page transition type for us (this
     // is so the new tab page can specify AUTO_BOOKMARK for automatically
     // generated suggestions).
     //
     // Note also that we hide the referrer for Web UI pages. We don't really
     // want web sites to see a referrer of "chrome://blah" (and some
     // chrome: URLs might have search terms or other stuff we don't want to
     // send to the site), so we send no referrer.
     new_contents = OpenURL(url, GURL(), disposition,
             render_manager_.web_ui()->link_transition_type());
     transition_type = render_manager_.web_ui()->link_transition_type();
   } else {
-    new_contents = OpenURL(url, referrer, disposition, PageTransition::LINK);
+    new_contents = OpenURL(
+        url, referrer, disposition, content::PAGE_TRANSITION_LINK);
   }
   if (new_contents) {
     // Notify observers.
     FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                       DidOpenRequestedURL(new_contents,
                                           url,
                                           referrer,
                                           disposition,
                                           transition_type,
                                           source_frame_id));
@@ skipping 269 matching lines @@
 
 void TabContents::set_encoding(const std::string& encoding) {
   encoding_ = content::GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }