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

chrome/browser/history/history_backend.cc

 // Copyright (c) 2012 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/history/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
@@ skipping 304 matching lines @@
     }
     visit_set.insert(visit_id);
   }
   return 0;
 }
 
 SegmentID HistoryBackend::UpdateSegments(
     const GURL& url,
     VisitID from_visit,
     VisitID visit_id,
-    content::PageTransition transition_type,
+    ui::PageTransition transition_type,
     const Time ts) {
   if (!db_)
     return 0;
 
   // We only consider main frames.
-  if (!content::PageTransitionIsMainFrame(transition_type))
+  if (!ui::PageTransitionIsMainFrame(transition_type))
     return 0;
 
   SegmentID segment_id = 0;
-  content::PageTransition t =
-      content::PageTransitionStripQualifier(transition_type);
+  ui::PageTransition t =
+      ui::PageTransitionStripQualifier(transition_type);
 
   // Are we at the beginning of a new segment?
   // Note that navigating to an existing entry (with back/forward) reuses the
   // same transition type.  We are not adding it as a new segment in that case
   // because if this was the target of a redirect, we might end up with
   // 2 entries for the same final URL. Ex: User types google.net, gets
   // redirected to google.com. A segment is created for google.net. On
   // google.com users navigates through a link, then press back. That last
   // navigation is for the entry google.com transition typed. We end up adding
   // a segment for that one as well. So we end up with google.net and google.com
   // in the segment table, showing as 2 entries in the NTP.
   // Note also that we should still be updating the visit count for that segment
   // which we are not doing now. It should be addressed when
   // http://crbug.com/96860 is fixed.
-  if ((t == content::PAGE_TRANSITION_TYPED ||
-       t == content::PAGE_TRANSITION_AUTO_BOOKMARK) &&
-      (transition_type & content::PAGE_TRANSITION_FORWARD_BACK) == 0) {
+  if ((t == ui::PAGE_TRANSITION_TYPED ||
+       t == ui::PAGE_TRANSITION_AUTO_BOOKMARK) &&
+      (transition_type & ui::PAGE_TRANSITION_FORWARD_BACK) == 0) {
     // If so, create or get the segment.
     std::string segment_name = db_->ComputeSegmentName(url);
     URLID url_id = db_->GetRowForURL(url, NULL);
     if (!url_id)
       return 0;
 
     segment_id = db_->GetSegmentNamed(segment_name);
     if (!segment_id) {
       segment_id = db_->CreateSegment(url_id, segment_name);
       if (!segment_id) {
@@ skipping 66 matching lines @@
   // If a redirect chain is given, we expect the last item in that chain to be
   // the final URL.
   DCHECK(request.redirects.empty() ||
          request.redirects.back() == request.url);
 
   // If the user is adding older history, we need to make sure our times
   // are correct.
   if (request.time < first_recorded_time_)
     first_recorded_time_ = request.time;
 
-  content::PageTransition request_transition = request.transition;
-  content::PageTransition stripped_transition =
-    content::PageTransitionStripQualifier(request_transition);
+  ui::PageTransition request_transition = request.transition;
+  ui::PageTransition stripped_transition =
+    ui::PageTransitionStripQualifier(request_transition);
   bool is_keyword_generated =
-      (stripped_transition == content::PAGE_TRANSITION_KEYWORD_GENERATED);
+      (stripped_transition == ui::PAGE_TRANSITION_KEYWORD_GENERATED);
 
   // If the user is navigating to a not-previously-typed intranet hostname,
   // change the transition to TYPED so that the omnibox will learn that this is
   // a known host.
   bool has_redirects = request.redirects.size() > 1;
-  if (content::PageTransitionIsMainFrame(request_transition) &&
-      (stripped_transition != content::PAGE_TRANSITION_TYPED) &&
+  if (ui::PageTransitionIsMainFrame(request_transition) &&
+      (stripped_transition != ui::PAGE_TRANSITION_TYPED) &&
       !is_keyword_generated) {
     const GURL& origin_url(has_redirects ?
         request.redirects[0] : request.url);
     if (origin_url.SchemeIs(url::kHttpScheme) ||
         origin_url.SchemeIs(url::kHttpsScheme) ||
         origin_url.SchemeIs(url::kFtpScheme)) {
       std::string host(origin_url.host());
       size_t registry_length =
           net::registry_controlled_domains::GetRegistryLength(
               host,
               net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
               net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
       if (registry_length == 0 && !db_->IsTypedHost(host)) {
-        stripped_transition = content::PAGE_TRANSITION_TYPED;
+        stripped_transition = ui::PAGE_TRANSITION_TYPED;
         request_transition =
-            content::PageTransitionFromInt(
+            ui::PageTransitionFromInt(
                 stripped_transition |
-                content::PageTransitionGetQualifier(request_transition));
+                ui::PageTransitionGetQualifier(request_transition));
       }
     }
   }
 
   if (!has_redirects) {
     // The single entry is both a chain start and end.
-    content::PageTransition t = content::PageTransitionFromInt(
+    ui::PageTransition t = ui::PageTransitionFromInt(
         request_transition |
-        content::PAGE_TRANSITION_CHAIN_START |
-        content::PAGE_TRANSITION_CHAIN_END);
+        ui::PAGE_TRANSITION_CHAIN_START |
+        ui::PAGE_TRANSITION_CHAIN_END);
 
     // No redirect case (one element means just the page itself).
     last_ids = AddPageVisit(request.url, request.time,
                             last_ids.second, t, request.visit_source);
 
     // Update the segment for this visit. KEYWORD_GENERATED visits should not
     // result in changing most visited, so we don't update segments (most
     // visited db).
     if (!is_keyword_generated) {
       UpdateSegments(request.url, from_visit_id, last_ids.second, t,
                      request.time);
 
       // Update the referrer's duration.
       UpdateVisitDuration(from_visit_id, request.time);
     }
   } else {
     // Redirect case. Add the redirect chain.
 
-    content::PageTransition redirect_info =
-        content::PAGE_TRANSITION_CHAIN_START;
+    ui::PageTransition redirect_info =
+        ui::PAGE_TRANSITION_CHAIN_START;
 
     RedirectList redirects = request.redirects;
     if (redirects[0].SchemeIs(url::kAboutScheme)) {
       // When the redirect source + referrer is "about" we skip it. This
       // happens when a page opens a new frame/window to about:blank and then
       // script sets the URL to somewhere else (used to hide the referrer). It
       // would be nice to keep all these redirects properly but we don't ever
       // see the initial about:blank load, so we don't know where the
       // subsequent client redirect came from.
       //
       // In this case, we just don't bother hooking up the source of the
       // redirects, so we remove it.
       redirects.erase(redirects.begin());
-    } else if (request_transition & content::PAGE_TRANSITION_CLIENT_REDIRECT) {
-      redirect_info = content::PAGE_TRANSITION_CLIENT_REDIRECT;
+    } else if (request_transition & ui::PAGE_TRANSITION_CLIENT_REDIRECT) {
+      redirect_info = ui::PAGE_TRANSITION_CLIENT_REDIRECT;
       // The first entry in the redirect chain initiated a client redirect.
       // We don't add this to the database since the referrer is already
       // there, so we skip over it but change the transition type of the first
       // transition to client redirect.
       //
       // The referrer is invalid when restoring a session that features an
       // https tab that redirects to a different host or to http. In this
       // case we don't need to reconnect the new redirect with the existing
       // chain.
       if (request.referrer.is_valid()) {
         DCHECK(request.referrer == redirects[0]);
         redirects.erase(redirects.begin());
 
         // If the navigation entry for this visit has replaced that for the
         // first visit, remove the CHAIN_END marker from the first visit. This
         // can be called a lot, for example, the page cycler, and most of the
         // time we won't have changed anything.
         VisitRow visit_row;
         if (request.did_replace_entry &&
             db_->GetRowForVisit(last_ids.second, &visit_row) &&
-            visit_row.transition & content::PAGE_TRANSITION_CHAIN_END) {
-          visit_row.transition = content::PageTransitionFromInt(
-              visit_row.transition & ~content::PAGE_TRANSITION_CHAIN_END);
+            visit_row.transition & ui::PAGE_TRANSITION_CHAIN_END) {
+          visit_row.transition = ui::PageTransitionFromInt(
+              visit_row.transition & ~ui::PAGE_TRANSITION_CHAIN_END);
           db_->UpdateVisitRow(visit_row);
         }
       }
     }
 
     for (size_t redirect_index = 0; redirect_index < redirects.size();
          redirect_index++) {
-      content::PageTransition t =
-          content::PageTransitionFromInt(stripped_transition | redirect_info);
+      ui::PageTransition t =
+          ui::PageTransitionFromInt(stripped_transition | redirect_info);
 
       // If this is the last transition, add a CHAIN_END marker
       if (redirect_index == (redirects.size() - 1)) {
-        t = content::PageTransitionFromInt(
-            t | content::PAGE_TRANSITION_CHAIN_END);
+        t = ui::PageTransitionFromInt(
+            t | ui::PAGE_TRANSITION_CHAIN_END);
       }
 
       // Record all redirect visits with the same timestamp. We don't display
       // them anyway, and if we ever decide to, we can reconstruct their order
       // from the redirect chain.
       last_ids = AddPageVisit(redirects[redirect_index],
                               request.time, last_ids.second,
                               t, request.visit_source);
-      if (t & content::PAGE_TRANSITION_CHAIN_START) {
+      if (t & ui::PAGE_TRANSITION_CHAIN_START) {
         // Update the segment for this visit.
         UpdateSegments(redirects[redirect_index],
                        from_visit_id, last_ids.second, t, request.time);
 
         // Update the visit_details for this visit.
         UpdateVisitDuration(from_visit_id, request.time);
       }
 
       // Subsequent transitions in the redirect list must all be server
       // redirects.
-      redirect_info = content::PAGE_TRANSITION_SERVER_REDIRECT;
+      redirect_info = ui::PAGE_TRANSITION_SERVER_REDIRECT;
     }
 
     // Last, save this redirect chain for later so we can set titles & favicons
     // on the redirected pages properly.
     recent_redirects_.Put(request.url, redirects);
   }
 
   // TODO(brettw) bug 1140015: Add an "add page" notification so the history
   // views can keep in sync.
 
   // Add the last visit to the tracker so we can get outgoing transitions.
   // TODO(evanm): Due to http://b/1194536 we lose the referrers of a subframe
   // navigation anyway, so last_visit_id is always zero for them.  But adding
   // them here confuses main frame history, so we skip them for now.
-  if (stripped_transition != content::PAGE_TRANSITION_AUTO_SUBFRAME &&
-      stripped_transition != content::PAGE_TRANSITION_MANUAL_SUBFRAME &&
+  if (stripped_transition != ui::PAGE_TRANSITION_AUTO_SUBFRAME &&
+      stripped_transition != ui::PAGE_TRANSITION_MANUAL_SUBFRAME &&
       !is_keyword_generated) {
     tracker_.AddVisit(request.context_id, request.page_id, request.url,
                       last_ids.second);
   }
 
   ScheduleCommit();
 }
 
 void HistoryBackend::InitImpl(const std::string& languages) {
   DCHECK(!db_) << "Initializing HistoryBackend twice";
@@ skipping 129 matching lines @@
   if (thumbnail_db_) {
     thumbnail_db_->CommitTransaction();
     thumbnail_db_.reset();
   }
 }
 
 std::pair<URLID, VisitID> HistoryBackend::AddPageVisit(
     const GURL& url,
     Time time,
     VisitID referring_visit,
-    content::PageTransition transition,
+    ui::PageTransition transition,
     VisitSource visit_source) {
   // Top-level frame navigations are visible, everything else is hidden
-  bool new_hidden = !content::PageTransitionIsMainFrame(transition);
+  bool new_hidden = !ui::PageTransitionIsMainFrame(transition);
 
   // NOTE: This code must stay in sync with
   // ExpireHistoryBackend::ExpireURLsForVisits().
   // TODO(pkasting): http://b/1148304 We shouldn't be marking so many URLs as
   // typed, which would eliminate the need for this code.
   int typed_increment = 0;
-  content::PageTransition transition_type =
-      content::PageTransitionStripQualifier(transition);
-  if ((transition_type == content::PAGE_TRANSITION_TYPED &&
-      !content::PageTransitionIsRedirect(transition)) ||
-      transition_type == content::PAGE_TRANSITION_KEYWORD_GENERATED)
+  ui::PageTransition transition_type =
+      ui::PageTransitionStripQualifier(transition);
+  if ((transition_type == ui::PAGE_TRANSITION_TYPED &&
+      !ui::PageTransitionIsRedirect(transition)) ||
+      transition_type == ui::PAGE_TRANSITION_KEYWORD_GENERATED)
     typed_increment = 1;
 
 #if defined(OS_ANDROID)
   // Only count the page visit if it came from user browsing and only count it
   // once when cycling through a redirect chain.
   if (visit_source == SOURCE_BROWSED &&
-      (transition & content::PAGE_TRANSITION_CHAIN_END) != 0) {
+      (transition & ui::PAGE_TRANSITION_CHAIN_END) != 0) {
     RecordTopPageVisitStats(url);
   }
 #endif
 
   // See if this URL is already in the DB.
   URLRow url_info(url);
   URLID url_id = db_->GetRowForURL(url, &url_info);
   if (url_id) {
     // Update of an existing row.
-    if (content::PageTransitionStripQualifier(transition) !=
-        content::PAGE_TRANSITION_RELOAD)
+    if (ui::PageTransitionStripQualifier(transition) !=
+        ui::PAGE_TRANSITION_RELOAD)
       url_info.set_visit_count(url_info.visit_count() + 1);
     if (typed_increment)
       url_info.set_typed_count(url_info.typed_count() + typed_increment);
     if (url_info.last_visit() < time)
       url_info.set_last_visit(time);
 
     // Only allow un-hiding of pages, never hiding.
     if (!new_hidden)
       url_info.set_hidden(false);
 
@@ skipping 67 matching lines @@
       }
 
       modified->changed_urls.push_back(*i);
       modified->changed_urls.back().set_id(url_id);  // i->id_ is likely 0.
     }
 
     // Sync code manages the visits itself.
     if (visit_source != SOURCE_SYNCED) {
       // Make up a visit to correspond to the last visit to the page.
       VisitRow visit_info(url_id, i->last_visit(), 0,
-                          content::PageTransitionFromInt(
-                              content::PAGE_TRANSITION_LINK |
-                              content::PAGE_TRANSITION_CHAIN_START |
-                              content::PAGE_TRANSITION_CHAIN_END), 0);
+                          ui::PageTransitionFromInt(
+                              ui::PAGE_TRANSITION_LINK |
+                              ui::PAGE_TRANSITION_CHAIN_START |
+                              ui::PAGE_TRANSITION_CHAIN_END), 0);
       if (!db_->AddVisit(&visit_info, visit_source)) {
         NOTREACHED() << "Adding visit failed.";
         return;
       }
       NotifyVisitObservers(visit_info);
 
       if (visit_info.visit_time < first_recorded_time_)
         first_recorded_time_ = visit_info.visit_time;
     }
   }
@@ skipping 375 matching lines @@
               << visit.url_id << ":  "
               << url_result.url().possibly_invalid_spec();
       continue;  // Don't report invalid URLs in case of corruption.
     }
 
     url_result.set_visit_time(visit.visit_time);
 
     // Set whether the visit was blocked for a managed user by looking at the
     // transition type.
     url_result.set_blocked_visit(
-        (visit.transition & content::PAGE_TRANSITION_BLOCKED) != 0);
+        (visit.transition & ui::PAGE_TRANSITION_BLOCKED) != 0);
 
     // We don't set any of the query-specific parts of the URLResult, since
     // snippets and stuff don't apply to basic querying.
     result->AppendURLBySwapping(&url_result);
   }
 
   if (!has_more_results && options.begin_time <= first_recorded_time_)
     result->set_reached_beginning(true);
 }
 
@@ skipping 1436 matching lines @@
   int rank = kPageVisitStatsMaxTopSites;
   std::map<GURL, int>::const_iterator it = most_visited_urls_map_.find(url);
   if (it != most_visited_urls_map_.end())
     rank = (*it).second;
   UMA_HISTOGRAM_ENUMERATION("History.TopSitesVisitsByRank",
                             rank, kPageVisitStatsMaxTopSites + 1);
 }
 #endif
 
 }  // namespace history