Tweaks to improve memory consumption by TopSites. The biggest culprit

chrome/browser/history/top_sites.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
@@ skipping 21 matching lines @@
 #include "gfx/codec/jpeg_codec.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace history {
 
 // How many top sites to store in the cache.
 static const size_t kTopSitesNumber = 20;
+
+// Max number of temporary images we'll cache. See comment above
+// temp_images_ for details.
+static const size_t kMaxTempTopImages = 8;
+
 static const size_t kTopSitesShown = 8;
 static const int kDaysOfHistory = 90;
 // Time from startup to first HistoryService query.
 static const int64 kUpdateIntervalSecs = 15;
 // Intervals between requests to HistoryService.
 static const int64 kMinUpdateIntervalMinutes = 1;
 static const int64 kMaxUpdateIntervalMinutes = 60;
 
 // IDs of the sites we force into top sites.
 static const int kPrepopulatePageIDs[] =
@@ skipping 141 matching lines @@
   }
 
   if (!HistoryService::CanAddURL(url))
     return false;  // It's not a real webpage.
 
   scoped_refptr<RefCountedBytes> thumbnail_data;
   if (!EncodeBitmap(thumbnail, &thumbnail_data))
     return false;
 
   if (add_temp_thumbnail) {
+    // Always remove the existing entry and then add it back. That way if we end
+    // up with too many temp thumbnails we'll prune the oldest first.
+    RemoveTemporaryThumbnailByURL(url);
     AddTemporaryThumbnail(url, thumbnail_data, score);
     return true;
   }
 
   return SetPageThumbnailEncoded(url, thumbnail_data, score);
 }
 
 void TopSites::GetMostVisitedURLs(CancelableRequestConsumer* consumer,
                                   GetTopSitesCallback* callback) {
   // WARNING: this may be invoked on any thread.
@@ skipping 267 matching lines @@
                              index,
                              *(cache_->GetImage(most_visited.url)));
   return true;
 }
 
 // static
 bool TopSites::EncodeBitmap(const SkBitmap& bitmap,
                             scoped_refptr<RefCountedBytes>* bytes) {
   *bytes = new RefCountedBytes();
   SkAutoLockPixels bitmap_lock(bitmap);
-  return gfx::JPEGCodec::Encode(
-      reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
-      gfx::JPEGCodec::FORMAT_BGRA, bitmap.width(),
-      bitmap.height(),
-      static_cast<int>(bitmap.rowBytes()), 90,
-      &((*bytes)->data));
+  std::vector<unsigned char> data;
+  if (!gfx::JPEGCodec::Encode(
+          reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
+          gfx::JPEGCodec::FORMAT_BGRA, bitmap.width(),
+          bitmap.height(),
+          static_cast<int>(bitmap.rowBytes()), 90,
+          &data)) {
+    return false;
+  }
+  // As we're going to cache this data, make sure the vector is only as big as
+  // it needs to be.
+  (*bytes)->data = data;
+  return true;
+}
+
+void TopSites::RemoveTemporaryThumbnailByURL(const GURL& url) {
+  for (TempImages::iterator i = temp_images_.begin(); i != temp_images_.end();
+       ++i) {
+    if (i->first == url) {
+      temp_images_.erase(i);
+      return;
+    }
+  }
 }
 
 void TopSites::AddTemporaryThumbnail(const GURL& url,
                                      const RefCountedBytes* thumbnail,
                                      const ThumbnailScore& score) {
-  Images& img = temp_thumbnails_map_[url];
-  img.thumbnail = const_cast<RefCountedBytes*>(thumbnail);
-  img.thumbnail_score = score;
+  if (temp_images_.size() == kMaxTempTopImages)
+    temp_images_.erase(temp_images_.begin());
+
+  TempImage image;
+  image.first = url;
+  image.second.thumbnail = const_cast<RefCountedBytes*>(thumbnail);
+  image.second.thumbnail_score = score;
+  temp_images_.push_back(image);
 }
 
 void TopSites::StartQueryForMostVisited() {
   if (!profile_)
     return;
 
   HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   // |hs| may be null during unit tests.
   if (hs) {
     hs->QueryMostVisitedURLs(
@@ skipping 182 matching lines @@
     }
     StartQueryForMostVisited();
   } else if (type == NotificationType::NAV_ENTRY_COMMITTED) {
     if (cache_->top_sites().size() < kTopSitesNumber) {
       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)) {
-        // Ideally we would just invoke StartQueryForMostVisited, but at the
-        // time this is invoked history hasn't been updated, which means if we
-        // invoked StartQueryForMostVisited now we could get stale data.
-        RestartQueryForTopSitesTimer(base::TimeDelta::FromMilliseconds(1));
+        // To avoid slamming history we throttle requests when the url updates.
+        // To do otherwise negatively impacts perf tests.
+        RestartQueryForTopSitesTimer(GetUpdateDelay());
       }
     }
   }
 }
 
 void TopSites::SetTopSites(const MostVisitedURLList& new_top_sites) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MostVisitedURLList top_sites(new_top_sites);
   AddPrepopulatedPages(&top_sites);
 
   TopSitesDelta delta;
   DiffMostVisited(cache_->top_sites(), top_sites, &delta);
   if (!delta.deleted.empty() || !delta.added.empty() || !delta.moved.empty())
     backend_->UpdateTopSites(delta);
 
   last_num_urls_changed_ = delta.added.size() + delta.moved.size();
 
   // We always do the following steps (setting top sites in cache, and resetting
   // thread safe cache ...) as this method is invoked during startup at which
   // point the caches haven't been updated yet.
   cache_->SetTopSites(top_sites);
 
   // See if we have any tmp thumbnails for the new sites.
-  if (!temp_thumbnails_map_.empty()) {
+  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);
-      for (std::map<GURL, Images>::iterator it = temp_thumbnails_map_.begin();
-           it != temp_thumbnails_map_.end(); ++it) {
-        // Must map all temp URLs to canonical ones.
-        // temp_thumbnails_map_ contains non-canonical URLs, because
-        // when we add a temp thumbnail, redirect chain is not known.
-        // This is slow, but temp_thumbnails_map_ should have very few URLs.
+      // 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,
                                   it->second.thumbnail_score);
-          temp_thumbnails_map_.erase(it);
+          temp_images_.erase(it);
           break;
         }
       }
     }
   }
 
   if (top_sites.size() >= kTopSitesNumber)
-    temp_thumbnails_map_.clear();
+    temp_images_.clear();
 
   ResetThreadSafeCache();
   ResetThreadSafeImageCache();
 
   // Restart the timer that queries history for top sites. This is done to
   // ensure we stay in sync with history.
   RestartQueryForTopSitesTimer(GetUpdateDelay());
 }
 
 int TopSites::num_results_to_request_from_history() const {
@@ skipping 36 matching lines @@
   thread_safe_cache_->SetTopSites(cached);
 }
 
 void TopSites::ResetThreadSafeImageCache() {
   AutoLock lock(lock_);
   thread_safe_cache_->SetThumbnails(cache_->images());
   thread_safe_cache_->RemoveUnreferencedThumbnails();
 }
 
 void TopSites::RestartQueryForTopSitesTimer(base::TimeDelta delta) {
+  if (timer_.IsRunning() && ((timer_start_time_ + timer_.GetCurrentDelay()) <
+                             (base::TimeTicks::Now() + delta))) {
+    return;
+  }
+
+  timer_start_time_ = base::TimeTicks::Now();
   timer_.Stop();
   timer_.Start(delta, this, &TopSites::StartQueryForMostVisited);
 }
 
 void TopSites::OnHistoryMigrationWrittenToDisk(TopSitesBackend::Handle handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!profile_)
     return;
 
@@ skipping 28 matching lines @@
         base::TimeDelta::FromSeconds(kUpdateIntervalSecs));
   } else {
     // The top sites file didn't exist or is the wrong version. We need to wait
     // for history to finish loading to know if we really needed to migrate.
     if (history_state_ == HISTORY_LOADED) {
       top_sites_state_ = TOP_SITES_LOADED;
       SetTopSites(MostVisitedURLList());
       MoveStateToLoaded();
     } else {
       top_sites_state_ = TOP_SITES_LOADED_WAITING_FOR_HISTORY;
-      // Ask for history just in case it hasn't been load yet. When history
+      // Ask for history just in case it hasn't been loaded yet. When history
       // finishes loading we'll do migration and/or move to loaded.
       profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     }
   }
 }
 
 void TopSites::OnTopSitesAvailableFromHistory(
     CancelableRequestProvider::Handle handle,
     MostVisitedURLList pages) {
   SetTopSites(pages);
 }
 
 }  // namespace history