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

chrome/browser/history/history_backend.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/history/history_backend.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 292 matching lines @@
 
     if (visit_set.find(visit_id) != visit_set.end()) {
       NOTREACHED() << "Loop in referer chain, giving up";
       break;
     }
     visit_set.insert(visit_id);
   }
   return 0;
 }
 
-SegmentID HistoryBackend::UpdateSegments(const GURL& url,
-                                         VisitID from_visit,
-                                         VisitID visit_id,
-                                         PageTransition::Type transition_type,
-                                         const Time ts) {
+SegmentID HistoryBackend::UpdateSegments(
+    const GURL& url,
+    VisitID from_visit,
+    VisitID visit_id,
+    content::PageTransition transition_type,
+    const Time ts) {
   if (!db_.get())
     return 0;
 
   // We only consider main frames.
-  if (!PageTransition::IsMainFrame(transition_type))
+  if (!content::PageTransitionIsMainFrame(transition_type))
     return 0;
 
   SegmentID segment_id = 0;
-  PageTransition::Type t = PageTransition::StripQualifier(transition_type);
+  content::PageTransition t =
+      content::PageTransitionStripQualifier(transition_type);
 
   // Are we at the beginning of a new segment?
-  if (t == PageTransition::TYPED || t == PageTransition::AUTO_BOOKMARK) {
+  if (t == content::PAGE_TRANSITION_TYPED ||
+      t == content::PAGE_TRANSITION_AUTO_BOOKMARK) {
     // 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;
 
     if (!(segment_id = db_->GetSegmentNamed(segment_name))) {
       if (!(segment_id = db_->CreateSegment(url_id, segment_name))) {
         NOTREACHED();
         return 0;
@@ skipping 51 matching lines @@
   } else {
     last_requested_time_ = request->time;
     last_recorded_time_ = last_requested_time_;
   }
 
   // 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;
 
-  PageTransition::Type transition =
-      PageTransition::StripQualifier(request->transition);
-  bool is_keyword_generated = (transition == PageTransition::KEYWORD_GENERATED);
+  content::PageTransition transition =
+    content::PageTransitionStripQualifier(request->transition);
+  bool is_keyword_generated =
+      (transition == content::PAGE_TRANSITION_KEYWORD_GENERATED);
 
   if (request->redirects.size() <= 1) {
     // The single entry is both a chain start and end.
-    PageTransition::Type t = request->transition |
-        PageTransition::CHAIN_START | PageTransition::CHAIN_END;
+    content::PageTransition t = content::PageTransitionFromInt(
+        request->transition |
+        content::PAGE_TRANSITION_CHAIN_START |
+        content::PAGE_TRANSITION_CHAIN_END);
 
     // No redirect case (one element means just the page itself).
     last_ids = AddPageVisit(request->url, last_recorded_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,
                      last_recorded_time_);
     }
   } else {
     // Redirect case. Add the redirect chain.
 
-    PageTransition::Type redirect_info = PageTransition::CHAIN_START;
+    content::PageTransition redirect_info =
+        content::PAGE_TRANSITION_CHAIN_START;
 
     if (request->redirects[0].SchemeIs(chrome::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.
       request->redirects.erase(request->redirects.begin());
-    } else if (request->transition & PageTransition::CLIENT_REDIRECT) {
-      redirect_info = PageTransition::CLIENT_REDIRECT;
+    } else if (request->transition & content::PAGE_TRANSITION_CLIENT_REDIRECT) {
+      redirect_info = content::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 == request->redirects[0]);
         request->redirects.erase(request->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 | PageTransition::CHAIN_END) {
-          visit_row.transition &= ~PageTransition::CHAIN_END;
+            visit_row.transition | content::PAGE_TRANSITION_CHAIN_END) {
+          visit_row.transition = content::PageTransitionFromInt(
+              visit_row.transition & ~content::PAGE_TRANSITION_CHAIN_END);
           db_->UpdateVisitRow(visit_row);
         }
       }
     }
 
     for (size_t redirect_index = 0; redirect_index < request->redirects.size();
          redirect_index++) {
-      PageTransition::Type t = transition | redirect_info;
+      content::PageTransition t =
+          content::PageTransitionFromInt(transition | redirect_info);
 
       // If this is the last transition, add a CHAIN_END marker
-      if (redirect_index == (request->redirects.size() - 1))
-        t = t | PageTransition::CHAIN_END;
+      if (redirect_index == (request->redirects.size() - 1)) {
+        t = content::PageTransitionFromInt(
+            t | content::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(request->redirects[redirect_index],
                               last_recorded_time_, last_ids.second,
                               t, request->visit_source);
-      if (t & PageTransition::CHAIN_START) {
+      if (t & content::PAGE_TRANSITION_CHAIN_START) {
         // Update the segment for this visit.
         UpdateSegments(request->redirects[redirect_index],
                        from_visit_id, last_ids.second, t, last_recorded_time_);
       }
 
       // Subsequent transitions in the redirect list must all be sever
       // redirects.
-      redirect_info = PageTransition::SERVER_REDIRECT;
+      redirect_info = content::PAGE_TRANSITION_SERVER_REDIRECT;
     }
 
     // Last, save this redirect chain for later so we can set titles & favicons
     // on the redirected pages properly. It is indexed by the destination page.
     recent_redirects_.Put(request->url, request->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 (transition != PageTransition::AUTO_SUBFRAME &&
-      transition != PageTransition::MANUAL_SUBFRAME && !is_keyword_generated) {
+  if (transition != content::PAGE_TRANSITION_AUTO_SUBFRAME &&
+      transition != content::PAGE_TRANSITION_MANUAL_SUBFRAME &&
+      !is_keyword_generated) {
     tracker_.AddVisit(request->id_scope, request->page_id, request->url,
                       last_ids.second);
   }
 
   if (text_database_.get()) {
     text_database_->AddPageURL(request->url, last_ids.first, last_ids.second,
                                last_recorded_time_);
   }
 
   ScheduleCommit();
@@ skipping 129 matching lines @@
   expirer_.StartArchivingOldStuff(TimeDelta::FromDays(kArchiveDaysThreshold));
 
   HISTOGRAM_TIMES("History.InitTime",
                   TimeTicks::Now() - beginning_time);
 }
 
 std::pair<URLID, VisitID> HistoryBackend::AddPageVisit(
     const GURL& url,
     Time time,
     VisitID referring_visit,
-    PageTransition::Type transition,
+    content::PageTransition transition,
     VisitSource visit_source) {
   // Top-level frame navigations are visible, everything else is hidden
-  bool new_hidden = !PageTransition::IsMainFrame(transition);
+  bool new_hidden = !content::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;
-  PageTransition::Type transition_type =
-      PageTransition::StripQualifier(transition);
-  if ((transition_type == PageTransition::TYPED &&
-       !PageTransition::IsRedirect(transition)) ||
-      transition_type == PageTransition::KEYWORD_GENERATED)
+  content::PageTransition transition_type =
+      content::PageTransitionStripQualifier(transition);
+  if ((transition_type == content::PAGE_TRANSITION_TYPED &&
+      !content::PageTransitionIsRedirect(transition)) ||
+      transition_type == content::PAGE_TRANSITION_KEYWORD_GENERATED)
     typed_increment = 1;
 
   // 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 (PageTransition::StripQualifier(transition) != PageTransition::RELOAD)
+    if (content::PageTransitionStripQualifier(transition) !=
+        content::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);
     url_info.set_last_visit(time);
 
     // Only allow un-hiding of pages, never hiding.
     if (!new_hidden)
       url_info.set_hidden(false);
 
     db_->UpdateURLRow(url_id, url_info);
@@ skipping 99 matching lines @@
       // create the visit entry with the indexed flag set.
       has_indexed = text_database_->AddPageData(i->url(), url_id, 0,
                                                 i->last_visit(),
                                                 i->title(), string16());
     }
 
     // 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,
-                          PageTransition::LINK | PageTransition::CHAIN_START |
-                          PageTransition::CHAIN_END, 0);
+                          content::PageTransitionFromInt(
+                              content::PAGE_TRANSITION_LINK |
+                              content::PAGE_TRANSITION_CHAIN_START |
+                              content::PAGE_TRANSITION_CHAIN_END), 0);
       visit_info.is_indexed = has_indexed;
       if (!visit_database->AddVisit(&visit_info, visit_source)) {
         NOTREACHED() << "Adding visit failed.";
         return;
       }
 
       if (visit_info.visit_time < first_recorded_time_)
         first_recorded_time_ = visit_info.visit_time;
     }
   }
@@ skipping 1448 matching lines @@
         break;
       }
     }
   }
   UMA_HISTOGRAM_TIMES("History.GetFavIconFromDB",  // historical name
                       TimeTicks::Now() - beginning_time);
   return success;
 }
 
 }  // namespace history