Topsites become keyedService based.

chrome/browser/history/top_sites_impl.cc

 // Copyright (c) 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 "chrome/browser/history/top_sites_impl.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 97 matching lines @@
   if (content::NotificationService::current()) {
     registrar_.Add(this, chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                    content::Source<Profile>(profile_));
     // Listen for any nav commits. We'll ignore those not related to this
     // profile when we get the notification.
     registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                    content::NotificationService::AllSources());
   }
   for (int i = 0; i < kPrepopulatedPagesCount; i++) {
     int url_id = kPrepopulatedPages[i].url_id;
-    prepopulated_page_urls_.push_back(
-        GURL(l10n_util::GetStringUTF8(url_id)));
+    prepopulated_page_urls_.push_back(GURL(l10n_util::GetStringUTF8(url_id)));
   }
 }
 
 void TopSitesImpl::Init(const base::FilePath& db_name) {
   // Create the backend here, rather than in the constructor, so that
   // unit tests that do not need the backend can run without a problem.
   backend_ = new TopSitesBackend;
   backend_->Init(db_name);
   backend_->GetMostVisitedThumbnails(
       base::Bind(&TopSitesImpl::OnGotMostVisitedThumbnails,
@@ skipping 77 matching lines @@
 // WARNING: this function may be invoked on any thread.
 void TopSitesImpl::GetMostVisitedURLs(
     const GetMostVisitedURLsCallback& callback,
     bool include_forced_urls) {
   MostVisitedURLList filtered_urls;
   {
     base::AutoLock lock(lock_);
     if (!loaded_) {
       // A request came in before we finished loading. Store the callback and
       // we'll run it on current thread when we finish loading.
-      pending_callbacks_.push_back(
-          base::Bind(&RunOrPostGetMostVisitedURLsCallback,
-                     base::MessageLoopProxy::current(),
-                     include_forced_urls,
-                     callback));
+      pending_callbacks_.push_back(base::Bind(
+          &RunOrPostGetMostVisitedURLsCallback,
+          base::MessageLoopProxy::current(), include_forced_urls, callback));
       return;
     }
     if (include_forced_urls) {
       filtered_urls = thread_safe_cache_->top_sites();
     } else {
       filtered_urls.assign(thread_safe_cache_->top_sites().begin() +
                               thread_safe_cache_->GetNumForcedURLs(),
                            thread_safe_cache_->top_sites().end());
     }
   }
   callback.Run(filtered_urls);
 }
 
 bool TopSitesImpl::GetPageThumbnail(
     const GURL& url,
     bool prefix_match,
     scoped_refptr<base::RefCountedMemory>* bytes) {
   // WARNING: this may be invoked on any thread.
   // Perform exact match.
   {
     base::AutoLock lock(lock_);
     if (thread_safe_cache_->GetPageThumbnail(url, bytes))
       return true;
   }
 
   // Resource bundle is thread safe.
   for (int i = 0; i < kPrepopulatedPagesCount; i++) {
     if (url == prepopulated_page_urls_[i]) {
-      *bytes = ResourceBundle::GetSharedInstance().
-          LoadDataResourceBytesForScale(
-              kPrepopulatedPages[i].thumbnail_id,
-              ui::SCALE_FACTOR_100P);
+      *bytes =
+          ResourceBundle::GetSharedInstance().LoadDataResourceBytesForScale(
+              kPrepopulatedPages[i].thumbnail_id, ui::SCALE_FACTOR_100P);
       return true;
     }
   }
 
   if (prefix_match) {
     // If http or https, search with |url| first, then try the other one.
     std::vector<GURL> url_list;
     url_list.push_back(url);
     if (url.SchemeIsHTTPOrHTTPS())
       url_list.push_back(ToggleHTTPAndHTTPS(url));
@@ skipping 27 matching lines @@
   for (TempImages::iterator i = temp_images_.begin(); i != temp_images_.end();
        ++i) {
     if (i->first == url) {
       *score = i->second.thumbnail_score;
       return true;
     }
   }
   return false;
 }
 
-
 // Returns the index of |url| in |urls|, or -1 if not found.
 static int IndexOf(const MostVisitedURLList& urls, const GURL& url) {
   for (size_t i = 0; i < urls.size(); i++) {
     if (urls[i].url == url)
       return i;
   }
   return -1;
 }
 
 void TopSitesImpl::SyncWithHistory() {
@@ skipping 67 matching lines @@
   // invoked Shutdown (this could happen if we have a pending request and
   // Shutdown is invoked).
   cancelable_task_tracker_.TryCancelAll();
   backend_->Shutdown();
 }
 
 // static
 void TopSitesImpl::DiffMostVisited(const MostVisitedURLList& old_list,
                                    const MostVisitedURLList& new_list,
                                    TopSitesDelta* delta) {
-
   // Add all the old URLs for quick lookup. This maps URLs to the corresponding
   // index in the input.
   std::map<GURL, size_t> all_old_urls;
   size_t num_old_forced = 0;
   for (size_t i = 0; i < old_list.size(); i++) {
     if (!old_list[i].last_forced_time.is_null())
       num_old_forced++;
     DCHECK(old_list[i].last_forced_time.is_null() || i < num_old_forced)
         << "Forced URLs must all appear before non-forced URLs.";
     all_old_urls[old_list[i].url] = i;
@@ skipping 14 matching lines @@
         << "Forced URLs must all appear before non-forced URLs.";
     std::map<GURL, size_t>::iterator found = all_old_urls.find(new_list[i].url);
     if (found == all_old_urls.end()) {
       MostVisitedURLWithRank added;
       added.url = new_list[i];
       added.rank = rank;
       delta->added.push_back(added);
     } else {
       DCHECK(found->second != kAlreadyFoundMarker)
           << "Same URL appears twice in the new list.";
-      int old_rank = found->second >= num_old_forced ?
-          found->second - num_old_forced : -1;
+      int old_rank =
+          found->second >= num_old_forced ? found->second - num_old_forced : -1;
       if (old_rank != rank ||
           old_list[found->second].last_forced_time !=
               new_list[i].last_forced_time) {
         MostVisitedURLWithRank moved;
         moved.url = new_list[i];
         moved.rank = rank;
         delta->moved.push_back(moved);
       }
       found->second = kAlreadyFoundMarker;
     }
   }
 
   // Any member without the special marker in the all_old_urls list means that
   // there wasn't a "new" URL that mapped to it, so it was deleted.
   for (std::map<GURL, size_t>::const_iterator i = all_old_urls.begin();
        i != all_old_urls.end(); ++i) {
     if (i->second != kAlreadyFoundMarker)
       delta->deleted.push_back(old_list[i->second]);
   }
 }
 
 base::CancelableTaskTracker::TaskId TopSitesImpl::StartQueryForMostVisited() {
   DCHECK(loaded_);
   if (!profile_)
     return base::CancelableTaskTracker::kBadTaskId;
 
-  HistoryService* hs = HistoryServiceFactory::GetForProfile(
-      profile_, Profile::EXPLICIT_ACCESS);
+  HistoryService* hs =
+      HistoryServiceFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS);

[sdefresne, 2015/01/12 17:24:24]

nit: Profile::EXPLICIT access has been removed with
https://codereview.chromium.org/839193002, you should now use
ServiceAccessType::EXPLICIT_ACCESS.

   // |hs| may be null during unit tests.
   if (hs) {
     return hs->QueryMostVisitedURLs(
-        num_results_to_request_from_history(),
-        kDaysOfHistory,
+        num_results_to_request_from_history(), kDaysOfHistory,
         base::Bind(&TopSitesImpl::OnTopSitesAvailableFromHistory,
                    base::Unretained(this)),
         &cancelable_task_tracker_);
   }
   return base::CancelableTaskTracker::kBadTaskId;
 }
 
 bool TopSitesImpl::IsKnownURL(const GURL& url) {
   return loaded_ && cache_->IsKnownURL(url);
 }
@@ skipping 50 matching lines @@
   if (!SetPageThumbnailNoDB(url, thumbnail, score))
     return false;
 
   // Update the database.
   if (!cache_->IsKnownURL(url))
     return false;
 
   size_t index = cache_->GetURLIndex(url);
   int url_rank = index - cache_->GetNumForcedURLs();
   const MostVisitedURL& most_visited = cache_->top_sites()[index];
-  backend_->SetPageThumbnail(most_visited,
-                             url_rank < 0 ? -1 : url_rank,
+  backend_->SetPageThumbnail(most_visited, url_rank < 0 ? -1 : url_rank,
                              *(cache_->GetImage(most_visited.url)));
   return true;
 }
 
 // static
 bool TopSitesImpl::EncodeBitmap(const gfx::Image& bitmap,
                                 scoped_refptr<base::RefCountedBytes>* bytes) {
   if (bitmap.IsEmpty())
     return false;
   *bytes = new base::RefCountedBytes();
@@ skipping 89 matching lines @@
   // since this is almost always where it needs to go, unless the user's local
   // clock is fiddled with.
   MostVisitedURLList::iterator mid = new_list.begin() + num_forced;
   new_list.insert(mid, new_url);
   mid = new_list.begin() + num_forced;  // Mid was invalidated.
   std::inplace_merge(new_list.begin(), mid, mid + 1, ForcedURLComparator);
   SetTopSites(new_list);
   return true;
 }
 
+void TopSitesImpl::ShutdownOnUIThread() {
+  DCHECK(!BrowserThread::IsThreadInitialized(BrowserThread::UI) ||

[sdefresne, 2015/01/12 17:24:24]

nit: can you removed this DCHECK? This is a guarantee of
RefcountedBrowserContextKeyedServiceFactory. Moreover,
//components/history/core/browser (were I'd like to move most of this file)
won't have access to content::BrowserThread.

+         BrowserThread::CurrentlyOn(BrowserThread::UI));
+  registrar_.RemoveAll();
+}
+
 bool TopSitesImpl::AddPrepopulatedPages(MostVisitedURLList* urls,
                                         size_t num_forced_urls) {
   bool added = false;
   MostVisitedURLList prepopulate_urls = GetPrepopulatePages();
   for (size_t i = 0; i < prepopulate_urls.size(); ++i) {
     if (urls->size() - num_forced_urls < kNonForcedTopSitesNumber &&
         IndexOf(*urls, prepopulate_urls[i].url) == -1) {
       urls->push_back(prepopulate_urls[i]);
       added = true;
     }
@@ skipping 19 matching lines @@
   MostVisitedURLList filtered_forced_urls;
   for (size_t i = 0; i < cache_->GetNumForcedURLs(); ++i) {
     if (all_new_urls.find(cache_->top_sites()[i].url) == all_new_urls.end())
       filtered_forced_urls.push_back(cache_->top_sites()[i]);
   }
   num_forced += filtered_forced_urls.size();
 
   // Prepend forced URLs and sort in order of ascending |last_forced_time|.
   new_list->insert(new_list->begin(), filtered_forced_urls.begin(),
                    filtered_forced_urls.end());
-  std::inplace_merge(
-      new_list->begin(), new_list->begin() + filtered_forced_urls.size(),
-      new_list->begin() + num_forced, ForcedURLComparator);
+  std::inplace_merge(new_list->begin(),
+                     new_list->begin() + filtered_forced_urls.size(),
+                     new_list->begin() + num_forced, ForcedURLComparator);
 
   // Drop older forced URLs if the list overflows. Since forced URLs are always
   // sort in increasing order of |last_forced_time|, drop the first ones.
   if (num_forced > kForcedTopSitesNumber) {
     new_list->erase(new_list->begin(),
                     new_list->begin() + (num_forced - kForcedTopSitesNumber));
     num_forced = kForcedTopSitesNumber;
   }
 
   return num_forced;
@@ skipping 117 matching lines @@
   // See if we have any tmp thumbnails for the new sites.
   if (!temp_images_.empty()) {
     for (size_t i = 0; i < top_sites.size(); ++i) {
       const MostVisitedURL& mv = top_sites[i];
       GURL canonical_url = cache_->GetCanonicalURL(mv.url);
       // At the time we get the thumbnail redirects aren't known, so we have to
       // iterate through all the images.
       for (TempImages::iterator it = temp_images_.begin();
            it != temp_images_.end(); ++it) {
         if (canonical_url == cache_->GetCanonicalURL(it->first)) {
-          SetPageThumbnailEncoded(
-              mv.url, it->second.thumbnail.get(), it->second.thumbnail_score);
+          SetPageThumbnailEncoded(mv.url, it->second.thumbnail.get(),
+                                  it->second.thumbnail_score);
           temp_images_.erase(it);
           break;
         }
       }
     }
   }
 
   if (top_sites.size() - num_forced_urls >= kNonForcedTopSitesNumber)
     temp_images_.clear();
 
@@ skipping 88 matching lines @@
       base::TimeDelta::FromSeconds(kUpdateIntervalSecs));
 }
 
 void TopSitesImpl::OnTopSitesAvailableFromHistory(
     const MostVisitedURLList* pages) {
   DCHECK(pages);
   SetTopSites(*pages);
 }
 
 }  // namespace history