Moved typedef of RedirectList from HistoryService class to history namespace....

chrome/browser/history/history_backend.cc

 // Copyright (c) 2009 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 <set>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 731 matching lines @@
 }
 
 void HistoryBackend::SetPageTitle(const GURL& url,
                                   const std::wstring& title) {
   if (!db_.get())
     return;
 
   // Search for recent redirects which should get the same title. We make a
   // dummy list containing the exact URL visited if there are no redirects so
   // the processing below can be the same.
-  HistoryService::RedirectList dummy_list;
-  HistoryService::RedirectList* redirects;
+  history::RedirectList dummy_list;
+  history::RedirectList* redirects;
   RedirectCache::iterator iter = recent_redirects_.Get(url);
   if (iter != recent_redirects_.end()) {
     redirects = &iter->second;
 
     // This redirect chain should have the destination URL as the last item.
     DCHECK(!redirects->empty());
     DCHECK(redirects->back() == url);
   } else {
     // No redirect chain stored, make up one containing the URL we want so we
     // can use the same logic below.
@@ skipping 404 matching lines @@
 
   std::vector<GURL>* top_urls = &request->value.a;
   history::RedirectMap* redirects = &request->value.b;
 
   std::vector<PageUsageData*> data;
   db_->QuerySegmentUsage(base::Time::Now() - base::TimeDelta::FromDays(90),
       result_count, &data);
 
   for (size_t i = 0; i < data.size(); ++i) {
     top_urls->push_back(data[i]->GetURL());
-    HistoryService::RedirectList list;
+    history::RedirectList list;
     GetMostRecentRedirectsFrom(top_urls->back(), &list);
     (*redirects)[top_urls->back()] = new RefCountedVector<GURL>(list);
   }
 
   request->ForwardResult(QueryTopURLsAndRedirectsRequest::TupleType(
       top_urls, redirects));
 }
 
 void HistoryBackend::GetRedirectsFromSpecificVisit(
-    VisitID cur_visit, HistoryService::RedirectList* redirects) {
+    VisitID cur_visit, history::RedirectList* redirects) {
   // Follow any redirects from the given visit and add them to the list.
   // It *should* be impossible to get a circular chain here, but we check
   // just in case to avoid infinite loops.
   GURL cur_url;
   std::set<VisitID> visit_set;
   visit_set.insert(cur_visit);
   while (db_->GetRedirectFromVisit(cur_visit, &cur_visit, &cur_url)) {
     if (visit_set.find(cur_visit) != visit_set.end()) {
       NOTREACHED() << "Loop in visit chain, giving up";
       return;
     }
     visit_set.insert(cur_visit);
     redirects->push_back(cur_url);
   }
 }
 
 void HistoryBackend::GetRedirectsToSpecificVisit(
     VisitID cur_visit,
-    HistoryService::RedirectList* redirects) {
+    history::RedirectList* redirects) {
   // Follow redirects going to cur_visit. These are added to |redirects| in
   // the order they are found. If a redirect chain looks like A -> B -> C and
   // |cur_visit| = C, redirects will be {B, A} in that order.
   if (!db_.get())
     return;
 
   GURL cur_url;
   std::set<VisitID> visit_set;
   visit_set.insert(cur_visit);
   while (db_->GetRedirectToVisit(cur_visit, &cur_visit, &cur_url)) {
     if (visit_set.find(cur_visit) != visit_set.end()) {
       NOTREACHED() << "Loop in visit chain, giving up";
       return;
     }
     visit_set.insert(cur_visit);
     redirects->push_back(cur_url);
   }
 }
 
 bool HistoryBackend::GetMostRecentRedirectsFrom(
     const GURL& from_url,
-    HistoryService::RedirectList* redirects) {
+    history::RedirectList* redirects) {
   redirects->clear();
   if (!db_.get())
     return false;
 
   URLID from_url_id = db_->GetRowForURL(from_url, NULL);
   VisitID cur_visit = db_->GetMostRecentVisitForURL(from_url_id, NULL);
   if (!cur_visit)
     return false;  // No visits for URL.
 
   GetRedirectsFromSpecificVisit(cur_visit, redirects);
   return true;
 }
 
 bool HistoryBackend::GetMostRecentRedirectsTo(
     const GURL& to_url,
-    HistoryService::RedirectList* redirects) {
+    history::RedirectList* redirects) {
   redirects->clear();
   if (!db_.get())
     return false;
 
   URLID to_url_id = db_->GetRowForURL(to_url, NULL);
   VisitID cur_visit = db_->GetMostRecentVisitForURL(to_url_id, NULL);
   if (!cur_visit)
     return false;  // No visits for URL.
 
   GetRedirectsToSpecificVisit(cur_visit, redirects);
@@ skipping 46 matching lines @@
 
 void HistoryBackend::GetPageThumbnailDirectly(
     const GURL& page_url,
     scoped_refptr<RefCountedBytes>* data) {
   if (thumbnail_db_.get()) {
     *data = new RefCountedBytes;
 
     // Time the result.
     TimeTicks beginning_time = TimeTicks::Now();
 
-    HistoryService::RedirectList redirects;
+    history::RedirectList redirects;
     URLID url_id;
     bool success = false;
 
     // If there are some redirects, try to get a thumbnail from the last
     // redirect destination.
     if (GetMostRecentRedirectsFrom(page_url, &redirects) &&
         !redirects.empty()) {
       if ((url_id = db_->GetRowForURL(redirects.back(), NULL)))
         success = thumbnail_db_->GetPageThumbnail(url_id, &(*data)->data);
     }
@@ skipping 27 matching lines @@
   static const int kVisitsToSearchForThumbnail = 4;
   db_->GetMostRecentVisitsForURL(
       page_url_id, kVisitsToSearchForThumbnail, &older_sessions);
 
   // Iterate across all those previous visits, and see if any of the
   // final destinations of those redirect chains have a good thumbnail
   // for us.
   bool success = false;
   for (VisitVector::const_iterator it = older_sessions.begin();
        !success && it != older_sessions.end(); ++it) {
-    HistoryService::RedirectList redirects;
+    history::RedirectList redirects;
     if (it->visit_id) {
       GetRedirectsFromSpecificVisit(it->visit_id, &redirects);
 
       if (!redirects.empty()) {
         URLID url_id;
         if ((url_id = db_->GetRowForURL(redirects.back(), NULL)))
           success = thumbnail_db_->GetPageThumbnail(url_id, data);
       }
     }
   }
@@ skipping 155 matching lines @@
   // Set the image data.
   thumbnail_db_->SetFavIcon(id, data->data, Time::Now());
 
   SetFavIconMapping(page_url, id);
 }
 
 void HistoryBackend::SetFavIconMapping(const GURL& page_url,
                                        FavIconID id) {
   // Find all the pages whose favicons we should set, we want to set it for
   // all the pages in the redirect chain if it redirected.
-  HistoryService::RedirectList dummy_list;
-  HistoryService::RedirectList* redirects;
+  history::RedirectList dummy_list;
+  history::RedirectList* redirects;
   RedirectCache::iterator iter = recent_redirects_.Get(page_url);
   if (iter != recent_redirects_.end()) {
     redirects = &iter->second;
 
     // This redirect chain should have the destination URL as the last item.
     DCHECK(!redirects->empty());
     DCHECK(redirects->back() == page_url);
   } else {
     // No redirect chain stored, make up one containing the URL we want to we
     // can use the same logic below.
     dummy_list.push_back(page_url);
     redirects = &dummy_list;
   }
 
   std::set<GURL> favicons_changed;
 
   // Save page <-> favicon association.
-  for (HistoryService::RedirectList::const_iterator i(redirects->begin());
+  for (history::RedirectList::const_iterator i(redirects->begin());
        i != redirects->end(); ++i) {
     URLRow row;
     if (!db_->GetRowForURL(*i, &row) || row.favicon_id() == id)
       continue;
 
     FavIconID old_id = row.favicon_id();
     if (old_id == id)
       continue;
     row.set_favicon_id(id);
     db_->UpdateURLRow(row.id(), row);
@@ skipping 371 matching lines @@
   return true;
 }
 
 BookmarkService* HistoryBackend::GetBookmarkService() {
   if (bookmark_service_)
     bookmark_service_->BlockTillLoaded();
   return bookmark_service_;
 }
 
 }  // namespace history