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

content/browser/tab_contents/navigation_controller.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/navigation_controller.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 52 matching lines @@
 }
 
 // Configure all the NavigationEntries in entries for restore. This resets
 // the transition type to reload and makes sure the content state isn't empty.
 void ConfigureEntriesForRestore(
     std::vector<linked_ptr<NavigationEntry> >* entries,
     bool from_last_session) {
   for (size_t i = 0; i < entries->size(); ++i) {
     // Use a transition type of reload so that we don't incorrectly increase
     // the typed count.
-    (*entries)[i]->set_transition_type(PageTransition::RELOAD);
+    (*entries)[i]->set_transition_type(content::PAGE_TRANSITION_RELOAD);
     (*entries)[i]->set_restore_type(from_last_session ?
         NavigationEntry::RESTORE_LAST_SESSION :
         NavigationEntry::RESTORE_CURRENT_SESSION);
     // NOTE(darin): This code is only needed for backwards compat.
     SetContentStateIfEmpty((*entries)[i].get());
   }
 }
 
 // See NavigationController::IsURLInPageNavigation for how this works and why.
 bool AreURLsInPageNavigation(const GURL& existing_url, const GURL& new_url) {
@@ skipping 104 matching lines @@
         Source<NavigationController>(this),
         NotificationService::NoDetails());
 
     pending_reload_ = reload_type;
     tab_contents_->Activate();
     tab_contents_->delegate()->ShowRepostFormWarningDialog(tab_contents_);
   } else {
     DiscardNonCommittedEntriesInternal();
 
     pending_entry_index_ = current_index;
-    entries_[pending_entry_index_]->set_transition_type(PageTransition::RELOAD);
+    entries_[pending_entry_index_]->set_transition_type(
+        content::PAGE_TRANSITION_RELOAD);
     NavigateToPendingEntry(reload_type);
   }
 }
 
 void NavigationController::CancelPendingReload() {
   DCHECK(pending_reload_ != NO_RELOAD);
   pending_reload_ = NO_RELOAD;
 }
 
 void NavigationController::ContinuePendingReload() {
   if (pending_reload_ == NO_RELOAD) {
     NOTREACHED();
   } else {
     ReloadInternal(false, pending_reload_);
     pending_reload_ = NO_RELOAD;
   }
 }
 
 bool NavigationController::IsInitialNavigation() {
   return last_document_loaded_.is_null();
 }
 
 // static
 NavigationEntry* NavigationController::CreateNavigationEntry(
-    const GURL& url, const GURL& referrer, PageTransition::Type transition,
+    const GURL& url, const GURL& referrer, content::PageTransition transition,
     const std::string& extra_headers,
     content::BrowserContext* browser_context) {
   // Allow the browser URL handler to rewrite the URL. This will, for example,
   // remove "view-source:" from the beginning of the URL to get the URL that
   // will actually be loaded. This real URL won't be shown to the user, just
   // used internally.
   GURL loaded_url(url);
   bool reverse_on_redirect = false;
   BrowserURLHandler::GetInstance()->RewriteURLIfNecessary(
       &loaded_url, browser_context, &reverse_on_redirect);
@@ skipping 116 matching lines @@
     return;
   }
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index - 1;
   entries_[pending_entry_index_]->set_transition_type(
-      entries_[pending_entry_index_]->transition_type() |
-      PageTransition::FORWARD_BACK);
+      content::PageTransitionFromInt(
+          entries_[pending_entry_index_]->transition_type() |
+          content::PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoForward() {
   if (!CanGoForward()) {
     NOTREACHED();
     return;
   }
 
   // If an interstitial page is showing, the previous renderer is blocked and
@@ skipping 11 matching lines @@
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = current_index;
   // If there was a transient entry, we removed it making the current index
   // the next page.
   if (!transient)
     pending_entry_index_++;
 
   entries_[pending_entry_index_]->set_transition_type(
-      entries_[pending_entry_index_]->transition_type() |
-      PageTransition::FORWARD_BACK);
+      content::PageTransitionFromInt(
+          entries_[pending_entry_index_]->transition_type() |
+          content::PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoToIndex(int index) {
   if (index < 0 || index >= static_cast<int>(entries_.size())) {
     NOTREACHED();
     return;
   }
 
   if (transient_entry_index_ != -1) {
@@ skipping 19 matching lines @@
       // navigation to succeed.  The interstitial will stay visible until the
       // resulting DidNavigate.
       tab_contents_->interstitial_page()->CancelForNavigation();
     }
   }
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = index;
   entries_[pending_entry_index_]->set_transition_type(
-      entries_[pending_entry_index_]->transition_type() |
-      PageTransition::FORWARD_BACK);
+      content::PageTransitionFromInt(
+          entries_[pending_entry_index_]->transition_type() |
+          content::PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationController::GoToOffset(int offset) {
   int index = (transient_entry_index_ != -1) ?
                   transient_entry_index_ + offset :
                   last_committed_entry_index_ + offset;
   if (index < 0 || index >= entry_count())
     return;
 
   GoToIndex(index);
 }
 
 void NavigationController::RemoveEntryAtIndex(int index,
                                               const GURL& default_url) {
   bool is_current = index == last_committed_entry_index_;
   RemoveEntryAtIndexInternal(index);
   if (is_current) {
     // We removed the currently shown entry, so we have to load something else.
     if (last_committed_entry_index_ != -1) {
       pending_entry_index_ = last_committed_entry_index_;
       NavigateToPendingEntry(NO_RELOAD);
     } else {
       // If there is nothing to show, show a default page.
       LoadURL(default_url.is_empty() ? GURL("about:blank") : default_url,
-              GURL(), PageTransition::START_PAGE, std::string());
+              GURL(), content::PAGE_TRANSITION_START_PAGE, std::string());
     }
   }
 }
 
 void NavigationController::UpdateVirtualURLToURL(
     NavigationEntry* entry, const GURL& new_url) {
   GURL new_virtual_url(new_url);
   if (BrowserURLHandler::GetInstance()->ReverseURLRewrite(
           &new_virtual_url, entry->virtual_url(), browser_context_)) {
     entry->set_virtual_url(new_virtual_url);
   }
 }
 
 void NavigationController::AddTransientEntry(NavigationEntry* entry) {
   // Discard any current transient entry, we can only have one at a time.
   int index = 0;
   if (last_committed_entry_index_ != -1)
     index = last_committed_entry_index_ + 1;
   DiscardTransientEntry();
   entries_.insert(entries_.begin() + index, linked_ptr<NavigationEntry>(entry));
   transient_entry_index_ = index;
   tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
 }
 
 void NavigationController::LoadURL(
     const GURL& url,
     const GURL& referrer,
-    PageTransition::Type transition,
+    content::PageTransition transition,
     const std::string& extra_headers) {
   // The user initiated a load, we don't need to reload anymore.
   needs_reload_ = false;
 
   NavigationEntry* entry = CreateNavigationEntry(url, referrer, transition,
                                                  extra_headers,
                                                  browser_context_);
 
   LoadEntry(entry);
 }
@@ skipping 65 matching lines @@
   // get confused when we go back to them (see the function for details).
   DCHECK(!params.content_state.empty());
   NavigationEntry* active_entry = GetActiveEntry();
   active_entry->set_content_state(params.content_state);
 
   // The active entry's SiteInstance should match our SiteInstance.
   DCHECK(active_entry->site_instance() == tab_contents_->GetSiteInstance());
 
   // Now prep the rest of the details for the notification and broadcast.
   details->entry = active_entry;
-  details->is_main_frame = PageTransition::IsMainFrame(params.transition);
+  details->is_main_frame =
+      content::PageTransitionIsMainFrame(params.transition);
   details->serialized_security_info = params.security_info;
   details->http_status_code = params.http_status_code;
   NotifyNavigationEntryCommitted(details);
 
   return true;
 }
 
 NavigationType::Type NavigationController::ClassifyNavigation(
     const ViewHostMsg_FrameNavigate_Params& params) const {
   if (params.page_id == -1) {
@@ skipping 15 matching lines @@
     //   list.
     //
     // In these cases, there's nothing we can do with them, so ignore.
     return NavigationType::NAV_IGNORE;
   }
 
   if (params.page_id > tab_contents_->GetMaxPageID()) {
     // Greater page IDs than we've ever seen before are new pages. We may or may
     // not have a pending entry for the page, and this may or may not be the
     // main frame.
-    if (PageTransition::IsMainFrame(params.transition))
+    if (content::PageTransitionIsMainFrame(params.transition))
       return NavigationType::NEW_PAGE;
 
     // When this is a new subframe navigation, we should have a committed page
     // for which it's a suframe in. This may not be the case when an iframe is
     // navigated on a popup navigated to about:blank (the iframe would be
     // written into the popup by script on the main page). For these cases,
     // there isn't any navigation stuff we can do, so just ignore it.
     if (!GetLastCommittedEntry())
       return NavigationType::NAV_IGNORE;
 
@@ skipping 14 matching lines @@
     // Because the unknown entry has committed, we risk showing the wrong URL in
     // release builds. Instead, we'll kill the renderer process to be safe.
     LOG(ERROR) << "terminating renderer for bad navigation: " << params.url;
     UserMetrics::RecordAction(UserMetricsAction("BadMessageTerminate_NC"));
     if (tab_contents_->GetSiteInstance()->HasProcess())
       tab_contents_->GetSiteInstance()->GetProcess()->ReceivedBadMessage();
     return NavigationType::NAV_IGNORE;
   }
   NavigationEntry* existing_entry = entries_[existing_entry_index].get();
 
-  if (!PageTransition::IsMainFrame(params.transition)) {
+  if (!content::PageTransitionIsMainFrame(params.transition)) {
     // All manual subframes would get new IDs and were handled above, so we
     // know this is auto. Since the current page was found in the navigation
     // entry list, we're guaranteed to have a last committed entry.
     DCHECK(GetLastCommittedEntry());
     return NavigationType::AUTO_SUBFRAME;
   }
 
   // Anything below here we know is a main frame navigation.
   if (pending_entry_ &&
       existing_entry != pending_entry_ &&
@@ skipping 19 matching lines @@
 
   // Since we weeded out "new" navigations above, we know this is an existing
   // (back/forward) navigation.
   return NavigationType::EXISTING_PAGE;
 }
 
 bool NavigationController::IsRedirect(
   const ViewHostMsg_FrameNavigate_Params& params) {
   // For main frame transition, we judge by params.transition.
   // Otherwise, by params.redirects.
-  if (PageTransition::IsMainFrame(params.transition)) {
-    return PageTransition::IsRedirect(params.transition);
+  if (content::PageTransitionIsMainFrame(params.transition)) {
+    return content::PageTransitionIsRedirect(params.transition);
   }
   return params.redirects.size() > 1;
 }
 
 void NavigationController::RendererDidNavigateToNewPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
   NavigationEntry* new_entry;
   bool update_virtual_url;
   if (pending_entry_) {
     // TODO(brettw) this assumes that the pending entry is appropriate for the
@@ skipping 23 matching lines @@
   new_entry->set_transition_type(params.transition);
   new_entry->set_site_instance(tab_contents_->GetSiteInstance());
   new_entry->set_has_post_data(params.is_post);
 
   InsertOrReplaceEntry(new_entry, *did_replace_entry);
 }
 
 void NavigationController::RendererDidNavigateToExistingPage(
     const ViewHostMsg_FrameNavigate_Params& params) {
   // We should only get here for main frame navigations.
-  DCHECK(PageTransition::IsMainFrame(params.transition));
+  DCHECK(content::PageTransitionIsMainFrame(params.transition));
 
   // This is a back/forward navigation. The existing page for the ID is
   // guaranteed to exist by ClassifyNavigation, and we just need to update it
   // with new information from the renderer.
   int entry_index = GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
   NavigationEntry* entry = entries_[entry_index].get();
 
@@ skipping 44 matching lines @@
   // The URL may have changed due to redirects.
   if (existing_entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(existing_entry, params.url);
   existing_entry->set_url(params.url);
 
   DiscardNonCommittedEntries();
 }
 
 void NavigationController::RendererDidNavigateInPage(
     const ViewHostMsg_FrameNavigate_Params& params, bool* did_replace_entry) {
-  DCHECK(PageTransition::IsMainFrame(params.transition)) <<
+  DCHECK(content::PageTransitionIsMainFrame(params.transition)) <<
       "WebKit should only tell us about in-page navs for the main frame.";
   // We're guaranteed to have an entry for this one.
   NavigationEntry* existing_entry = GetEntryWithPageID(
       tab_contents_->GetSiteInstance(),
       params.page_id);
 
   // Reference fragment navigation. We're guaranteed to have the last_committed
   // entry and it will be the same page as the new navigation (minus the
   // reference fragments, of course).  We'll update the URL of the existing
   // entry without pruning the forward history.
   existing_entry->set_url(params.url);
   if (existing_entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(existing_entry, params.url);
 
   // This replaces the existing entry since the page ID didn't change.
   *did_replace_entry = true;
 
   if (pending_entry_)
     DiscardNonCommittedEntriesInternal();
 
   // If a transient entry was removed, the indices might have changed, so we
   // have to query the entry index again.
   last_committed_entry_index_ =
       GetEntryIndexWithPageID(tab_contents_->GetSiteInstance(), params.page_id);
 }
 
 void NavigationController::RendererDidNavigateNewSubframe(
     const ViewHostMsg_FrameNavigate_Params& params) {
-  if (PageTransition::StripQualifier(params.transition) ==
-      PageTransition::AUTO_SUBFRAME) {
+  if (content::PageTransitionStripQualifier(params.transition) ==
+      content::PAGE_TRANSITION_AUTO_SUBFRAME) {
     // This is not user-initiated. Ignore.
     return;
   }
 
   // Manual subframe navigations just get the current entry cloned so the user
   // can go back or forward to it. The actual subframe information will be
   // stored in the page state for each of those entries. This happens out of
   // band with the actual navigations.
   DCHECK(GetLastCommittedEntry()) << "ClassifyNavigation should guarantee "
                                   << "that a last committed entry exists.";
@@ skipping 161 matching lines @@
 
   // If there was a transient entry, invalidate everything so the new active
   // entry state is shown.
   if (transient) {
     tab_contents_->NotifyNavigationStateChanged(kInvalidateAll);
   }
 }
 
 void NavigationController::InsertOrReplaceEntry(NavigationEntry* entry,
                                                 bool replace) {
-  DCHECK(entry->transition_type() != PageTransition::AUTO_SUBFRAME);
+  DCHECK(entry->transition_type() != content::PAGE_TRANSITION_AUTO_SUBFRAME);
 
   // Copy the pending entry's unique ID to the committed entry.
   // I don't know if pending_entry_index_ can be other than -1 here.
   const NavigationEntry* const pending_entry = (pending_entry_index_ == -1) ?
       pending_entry_ : entries_[pending_entry_index_].get();
   if (pending_entry)
     entry->set_unique_id(pending_entry->unique_id());
 
   DiscardNonCommittedEntriesInternal();
 
@@ skipping 37 matching lines @@
   // a session history navigation to the last committed page, RenderViewHost
   // will force the throbber to start, but WebKit will essentially ignore the
   // navigation, and won't send a message to stop the throbber. To prevent this
   // from happening, we drop the navigation here and stop the slow-to-commit
   // page from loading (which would normally happen during the navigation).
   if (pending_entry_index_ != -1 &&
       pending_entry_index_ == last_committed_entry_index_ &&
       (entries_[pending_entry_index_]->restore_type() ==
           NavigationEntry::RESTORE_NONE) &&
       (entries_[pending_entry_index_]->transition_type() &
-          PageTransition::FORWARD_BACK)) {
+          content::PAGE_TRANSITION_FORWARD_BACK)) {
     tab_contents_->Stop();
     DiscardNonCommittedEntries();
     return;
   }
 
   // For session history navigations only the pending_entry_index_ is set.
   if (!pending_entry_) {
     DCHECK_NE(pending_entry_index_, -1);
     pending_entry_ = entries_[pending_entry_index_].get();
   }
@@ skipping 117 matching lines @@
   size_t insert_index = 0;
   for (int i = 0; i < max_index; i++) {
     // When cloning a tab, copy all entries except interstitial pages
     if (source.entries_[i].get()->page_type() != INTERSTITIAL_PAGE) {
       entries_.insert(entries_.begin() + insert_index++,
                       linked_ptr<NavigationEntry>(
                           new NavigationEntry(*source.entries_[i])));
     }
   }
 }