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

content/browser/frame_host/navigation_controller_impl.cc

 // Copyright 2013 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/frame_host/navigation_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 77 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<NavigationEntryImpl> >* entries,
     NavigationController::RestoreType type) {
   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]->SetTransitionType(PAGE_TRANSITION_RELOAD);
+    (*entries)[i]->SetTransitionType(ui::PAGE_TRANSITION_RELOAD);
     (*entries)[i]->set_restore_type(ControllerRestoreTypeToEntryType(type));
     // NOTE(darin): This code is only needed for backwards compat.
     SetPageStateIfEmpty((*entries)[i].get());
   }
 }
 
 // There are two general cases where a navigation is in page:
 // 1. A fragment navigation, in which the url is kept the same except for the
 //    reference fragment.
 // 2. A history API navigation (pushState and replaceState). This case is
@@ skipping 43 matching lines @@
     kMaxEntryCountForTestingNotSet;
 
 // Should Reload check for post data? The default is true, but is set to false
 // when testing.
 static bool g_check_for_repost = true;
 
 // static
 NavigationEntry* NavigationController::CreateNavigationEntry(
       const GURL& url,
       const Referrer& referrer,
-      PageTransition transition,
+      ui::PageTransition transition,
       bool is_renderer_initiated,
       const std::string& extra_headers,
       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;
   BrowserURLHandlerImpl::GetInstance()->RewriteURLIfNecessary(
@@ skipping 108 matching lines @@
                                               ReloadType reload_type) {
   if (transient_entry_index_ != -1) {
     // If an interstitial is showing, treat a reload as a navigation to the
     // transient entry's URL.
     NavigationEntryImpl* transient_entry =
         NavigationEntryImpl::FromNavigationEntry(GetTransientEntry());
     if (!transient_entry)
       return;
     LoadURL(transient_entry->GetURL(),
             Referrer(),
-            PAGE_TRANSITION_RELOAD,
+            ui::PAGE_TRANSITION_RELOAD,
             transient_entry->extra_headers());
     return;
   }
 
   NavigationEntryImpl* entry = NULL;
   int current_index = -1;
 
   // If we are reloading the initial navigation, just use the current
   // pending entry.  Otherwise look up the current entry.
   if (IsInitialNavigation() && pending_entry_) {
@@ skipping 67 matching lines @@
     } else {
       pending_entry_ = entry;
       pending_entry_index_ = current_index;
 
       // The title of the page being reloaded might have been removed in the
       // meanwhile, so we need to revert to the default title upon reload and
       // invalidate the previously cached title (SetTitle will do both).
       // See Chromium issue 96041.
       pending_entry_->SetTitle(base::string16());
 
-      pending_entry_->SetTransitionType(PAGE_TRANSITION_RELOAD);
+      pending_entry_->SetTransitionType(ui::PAGE_TRANSITION_RELOAD);
     }
 
     NavigateToPendingEntry(reload_type);
   }
 }
 
 void NavigationControllerImpl::CancelPendingReload() {
   DCHECK(pending_reload_ != NO_RELOAD);
   pending_reload_ = NO_RELOAD;
 }
@@ skipping 155 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_]->SetTransitionType(
-      PageTransitionFromInt(
+      ui::PageTransitionFromInt(
           entries_[pending_entry_index_]->GetTransitionType() |
-          PAGE_TRANSITION_FORWARD_BACK));
+          ui::PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::GoForward() {
   if (!CanGoForward()) {
     NOTREACHED();
     return;
   }
 
   bool transient = (transient_entry_index_ != -1);
 
   // Base the navigation on where we are now...
   int current_index = GetCurrentEntryIndex();
 
   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_]->SetTransitionType(
-      PageTransitionFromInt(
+      ui::PageTransitionFromInt(
           entries_[pending_entry_index_]->GetTransitionType() |
-          PAGE_TRANSITION_FORWARD_BACK));
+          ui::PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::GoToIndex(int index) {
   if (index < 0 || index >= static_cast<int>(entries_.size())) {
     NOTREACHED();
     return;
   }
 
   if (transient_entry_index_ != -1) {
     if (index == transient_entry_index_) {
       // Nothing to do when navigating to the transient.
       return;
     }
     if (index > transient_entry_index_) {
       // Removing the transient is goint to shift all entries by 1.
       index--;
     }
   }
 
   DiscardNonCommittedEntries();
 
   pending_entry_index_ = index;
   entries_[pending_entry_index_]->SetTransitionType(
-      PageTransitionFromInt(
+      ui::PageTransitionFromInt(
           entries_[pending_entry_index_]->GetTransitionType() |
-          PAGE_TRANSITION_FORWARD_BACK));
+          ui::PAGE_TRANSITION_FORWARD_BACK));
   NavigateToPendingEntry(NO_RELOAD);
 }
 
 void NavigationControllerImpl::GoToOffset(int offset) {
   if (!CanGoToOffset(offset))
     return;
 
   GoToIndex(GetIndexForOffset(offset));
 }
 
@@ skipping 11 matching lines @@
   GURL new_virtual_url(new_url);
   if (BrowserURLHandlerImpl::GetInstance()->ReverseURLRewrite(
           &new_virtual_url, entry->GetVirtualURL(), browser_context_)) {
     entry->SetVirtualURL(new_virtual_url);
   }
 }
 
 void NavigationControllerImpl::LoadURL(
     const GURL& url,
     const Referrer& referrer,
-    PageTransition transition,
+    ui::PageTransition transition,
     const std::string& extra_headers) {
   LoadURLParams params(url);
   params.referrer = referrer;
   params.transition_type = transition;
   params.extra_headers = extra_headers;
   LoadURLWithParams(params);
 }
 
 void NavigationControllerImpl::LoadURLWithParams(const LoadURLParams& params) {
   TRACE_EVENT1("browser,navigation",
@@ skipping 200 matching lines @@
   }
   UMA_HISTOGRAM_COUNTS("Navigation.RedirectChainSize", redirect_chain_size);
 
   // Once it is committed, we no longer need to track several pieces of state on
   // the entry.
   active_entry->ResetForCommit();
 
   // The active entry's SiteInstance should match our SiteInstance.
   // TODO(creis): This check won't pass for subframes until we create entries
   // for subframe navigations.
-  if (PageTransitionIsMainFrame(params.transition))
+  if (ui::PageTransitionIsMainFrame(params.transition))
     CHECK(active_entry->site_instance() == rfh->GetSiteInstance());
 
   // Remember the bindings the renderer process has at this point, so that
   // we do not grant this entry additional bindings if we come back to it.
   active_entry->SetBindings(
       static_cast<RenderFrameHostImpl*>(rfh)->GetEnabledBindings());
 
   // Now prep the rest of the details for the notification and broadcast.
   details->entry = active_entry;
   details->is_main_frame =
-      PageTransitionIsMainFrame(params.transition);
+      ui::PageTransitionIsMainFrame(params.transition);
   details->serialized_security_info = params.security_info;
   details->http_status_code = params.http_status_code;
   NotifyNavigationEntryCommitted(details);
 
   return true;
 }
 
 NavigationType NavigationControllerImpl::ClassifyNavigation(
     RenderFrameHost* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) const {
@@ skipping 26 matching lines @@
     //
     // In these cases, there's nothing we can do with them, so ignore.
     return NAVIGATION_TYPE_NAV_IGNORE;
   }
 
   if (params.page_id > delegate_->GetMaxPageIDForSiteInstance(
           rfh->GetSiteInstance())) {
     // 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 (PageTransitionIsMainFrame(params.transition))
+    if (ui::PageTransitionIsMainFrame(params.transition))
       return NAVIGATION_TYPE_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 NAVIGATION_TYPE_NAV_IGNORE;
 
@@ skipping 44 matching lines @@
         temp.append("x");
       temp.append(",");
     }
     GURL url(temp);
     static_cast<RenderFrameHostImpl*>(rfh)->render_view_host()->Send(
         new ViewMsg_TempCrashWithData(url));
     return NAVIGATION_TYPE_NAV_IGNORE;
   }
   NavigationEntryImpl* existing_entry = entries_[existing_entry_index].get();
 
-  if (!PageTransitionIsMainFrame(params.transition)) {
+  if (!ui::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 NAVIGATION_TYPE_AUTO_SUBFRAME;
   }
 
   // Anything below here we know is a main frame navigation.
   if (pending_entry_ &&
       !pending_entry_->is_renderer_initiated() &&
@@ skipping 94 matching lines @@
     last_committed_entry_index_ = -1;
   }
 
   InsertOrReplaceEntry(new_entry, replace_entry);
 }
 
 void NavigationControllerImpl::RendererDidNavigateToExistingPage(
     RenderFrameHost* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
   // We should only get here for main frame navigations.
-  DCHECK(PageTransitionIsMainFrame(params.transition));
+  DCHECK(ui::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(rfh->GetSiteInstance(),
                                             params.page_id);
   DCHECK(entry_index >= 0 &&
          entry_index < static_cast<int>(entries_.size()));
   NavigationEntryImpl* entry = entries_[entry_index].get();
 
   // The URL may have changed due to redirects.
   entry->SetURL(params.url);
   entry->SetReferrer(params.referrer);
   if (entry->update_virtual_url_with_url())
     UpdateVirtualURLToURL(entry, params.url);
 
   // The redirected to page should not inherit the favicon from the previous
   // page.
-  if (PageTransitionIsRedirect(params.transition))
+  if (ui::PageTransitionIsRedirect(params.transition))
     entry->GetFavicon() = FaviconStatus();
 
   // The site instance will normally be the same except during session restore,
   // when no site instance will be assigned.
   DCHECK(entry->site_instance() == NULL ||
          entry->site_instance() == rfh->GetSiteInstance());
   entry->set_site_instance(
       static_cast<SiteInstanceImpl*>(rfh->GetSiteInstance()));
 
   entry->SetHasPostData(params.is_post);
@@ skipping 40 matching lines @@
   existing_entry->SetHasPostData(params.is_post);
   existing_entry->SetPostID(params.post_id);
 
   DiscardNonCommittedEntries();
 }
 
 void NavigationControllerImpl::RendererDidNavigateInPage(
     RenderFrameHost* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params,
     bool* did_replace_entry) {
-  DCHECK(PageTransitionIsMainFrame(params.transition)) <<
+  DCHECK(ui::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.
   NavigationEntryImpl* existing_entry = GetEntryWithPageID(
       rfh->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->SetURL(params.url);
@@ skipping 10 matching lines @@
 
   // 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(rfh->GetSiteInstance(), params.page_id);
 }
 
 void NavigationControllerImpl::RendererDidNavigateNewSubframe(
     RenderFrameHost* rfh,
     const FrameHostMsg_DidCommitProvisionalLoad_Params& params) {
-  if (PageTransitionCoreTypeIs(params.transition,
-                               PAGE_TRANSITION_AUTO_SUBFRAME)) {
+  if (ui::PageTransitionCoreTypeIs(params.transition,
+                                   ui::PAGE_TRANSITION_AUTO_SUBFRAME)) {
     // This is not user-initiated. Ignore.
     DiscardNonCommittedEntriesInternal();
     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 "
@@ skipping 310 matching lines @@
 NavigationEntry* NavigationControllerImpl::GetPendingEntry() const {
   return pending_entry_;
 }
 
 int NavigationControllerImpl::GetPendingEntryIndex() const {
   return pending_entry_index_;
 }
 
 void NavigationControllerImpl::InsertOrReplaceEntry(NavigationEntryImpl* entry,
                                                     bool replace) {
-  DCHECK(entry->GetTransitionType() != PAGE_TRANSITION_AUTO_SUBFRAME);
+  DCHECK(entry->GetTransitionType() != ui::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 NavigationEntryImpl* const pending_entry =
       (pending_entry_index_ == -1) ?
           pending_entry_ : entries_[pending_entry_index_].get();
   if (pending_entry)
     entry->set_unique_id(pending_entry->GetUniqueID());
 
   DiscardNonCommittedEntriesInternal();
@@ skipping 44 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() ==
           NavigationEntryImpl::RESTORE_NONE) &&
       (entries_[pending_entry_index_]->GetTransitionType() &
-          PAGE_TRANSITION_FORWARD_BACK)) {
+          ui::PAGE_TRANSITION_FORWARD_BACK)) {
     delegate_->Stop();
 
     // If an interstitial page is showing, we want to close it to get back
     // to what was showing before.
     if (delegate_->GetInterstitialPage())
       delegate_->GetInterstitialPage()->DontProceed();
 
     DiscardNonCommittedEntries();
     return;
   }
@@ skipping 168 matching lines @@
     }
   }
 }
 
 void NavigationControllerImpl::SetGetTimestampCallbackForTest(
     const base::Callback<base::Time()>& get_timestamp_callback) {
   get_timestamp_callback_ = get_timestamp_callback;
 }
 
 }  // namespace content