Add heuristics to skip thumbnail generation when it's unnecessary.

chrome/browser/history/top_sites.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/top_sites.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/command_line.h"
@@ skipping 109 matching lines @@
   const int result_count_;
 
   ThumbnailMigration data_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadThumbnailsFromHistoryTask);
 };
 
 }  // namespace
 
 TopSites::TopSites(Profile* profile)
-    : backend_(new TopSitesBackend()),
+    : backend_(NULL),
       cache_(new TopSitesCache()),
       thread_safe_cache_(new TopSitesCache()),
       profile_(profile),
       last_num_urls_changed_(0),
       blacklist_(NULL),
       pinned_urls_(NULL),
       history_state_(HISTORY_LOADING),
       top_sites_state_(TOP_SITES_LOADING),
       loaded_(false) {
   if (!profile_)
     return;
 
   if (NotificationService::current()) {
     registrar_.Add(this, NotificationType::HISTORY_URLS_DELETED,
                    Source<Profile>(profile_));
     registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                    NotificationService::AllSources());
   }
 
   blacklist_ = profile_->GetPrefs()->
       GetMutableDictionary(prefs::kNTPMostVisitedURLsBlacklist);
   pinned_urls_ = profile_->GetPrefs()->
       GetMutableDictionary(prefs::kNTPMostVisitedPinnedURLs);
 }
 
 void TopSites::Init(const 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(
       &cancelable_consumer_,
       NewCallback(this, &TopSites::OnGotMostVisitedThumbnails));
 
   // History may have already finished loading by the time we're created.
   HistoryService* history = profile_->GetHistoryServiceWithoutCreating();
   if (history && history->backend_loaded()) {
     if (history->needs_top_sites_migration())
       MigrateFromHistory();
     else
       history_state_ = HISTORY_LOADED;
   }
 }
 
 bool TopSites::SetPageThumbnail(const GURL& url,
                                 const SkBitmap& thumbnail,
                                 const ThumbnailScore& score) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!loaded_) {
     // TODO(sky): I need to cache these and apply them after the load
     // completes.
     return false;
   }
 
   bool add_temp_thumbnail = false;
-  if (!cache_->IsKnownURL(url)) {
-    if (cache_->top_sites().size() < kTopSitesNumber) {
+  if (!IsKnownURL(url)) {
+    if (!IsFull()) {
       add_temp_thumbnail = true;
     } else {
       return false;  // This URL is not known to us.
     }
   }
 
   if (!HistoryService::CanAddURL(url))
     return false;  // It's not a real webpage.
 
   scoped_refptr<RefCountedBytes> thumbnail_data;
@@ skipping 34 matching lines @@
   request->ForwardResult(GetTopSitesCallback::TupleType(filtered_urls));
 }
 
 bool TopSites::GetPageThumbnail(const GURL& url,
                                 scoped_refptr<RefCountedBytes>* bytes) {
   // WARNING: this may be invoked on any thread.
   base::AutoLock lock(lock_);
   return thread_safe_cache_->GetPageThumbnail(url, bytes);
 }
 
+bool TopSites::GetPageThumbnailScore(const GURL& url,
+                                     ThumbnailScore* score) {
+  // WARNING: this may be invoked on any thread.
+  base::AutoLock lock(lock_);
+  return thread_safe_cache_->GetPageThumbnailScore(url, score);
+}
+
 // 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 TopSites::MigrateFromHistory() {
@@ skipping 192 matching lines @@
   if (hs) {
     return hs->QueryMostVisitedURLs(
         num_results_to_request_from_history(),
         kDaysOfHistory,
         &cancelable_consumer_,
         NewCallback(this, &TopSites::OnTopSitesAvailableFromHistory));
   }
   return 0;
 }
 
+bool TopSites::IsKnownURL(const GURL& url) {
+  return loaded_ && cache_->IsKnownURL(url);
+}
+
+bool TopSites::IsFull() {
+  return loaded_ && cache_->top_sites().size() >= kTopSitesNumber;
+}
+
 TopSites::~TopSites() {
 }
 
 bool TopSites::SetPageThumbnailNoDB(const GURL& url,
                                     const RefCountedBytes* thumbnail_data,
                                     const ThumbnailScore& score) {
   // This should only be invoked when we know about the url.
   DCHECK(cache_->IsKnownURL(url));
 
   const MostVisitedURL& most_visited =
@@ skipping 255 matching lines @@
       for (std::set<size_t>::reverse_iterator i = indices_to_delete.rbegin();
            i != indices_to_delete.rend(); i++) {
         size_t index = *i;
         RemovePinnedURL(new_top_sites[index].url);
         new_top_sites.erase(new_top_sites.begin() + index);
       }
       SetTopSites(new_top_sites);
     }
     StartQueryForMostVisited();
   } else if (type == NotificationType::NAV_ENTRY_COMMITTED) {
-    if (cache_->top_sites().size() < kTopSitesNumber) {
+    if (!IsFull()) {
       NavigationController::LoadCommittedDetails* load_details =
           Details<NavigationController::LoadCommittedDetails>(details).ptr();
       if (!load_details)
         return;
       const GURL& url = load_details->entry->url();
       if (!cache_->IsKnownURL(url) && HistoryService::CanAddURL(url)) {
         // To avoid slamming history we throttle requests when the url updates.
         // To do otherwise negatively impacts perf tests.
         RestartQueryForTopSitesTimer(GetUpdateDelay());
       }
@@ skipping 164 matching lines @@
   SetTopSites(pages);
 
   // Used only in testing.
   NotificationService::current()->Notify(
       NotificationType::TOP_SITES_UPDATED,
       Source<TopSites>(this),
       Details<CancelableRequestProvider::Handle>(&handle));
 }
 
 }  // namespace history