Rebuild test history databases when starting up performance_ui_tests.

chrome/browser/history/top_sites.cc

 // Copyright (c) 2012 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/bind.h"
@@ skipping 235 matching lines @@
     // 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);
 }
 
+bool TopSites::SetPageThumbnailToJPEGBytes(
+    const GURL& url,
+    const base::RefCountedMemory* memory,
+    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 (!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.
+
+  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, memory, score);
+    return true;
+  }
+
+  return SetPageThumbnailEncoded(url, memory, score);
+}
+
 // WARNING: this function may be invoked on any thread.
 void TopSites::GetMostVisitedURLs(const GetMostVisitedURLsCallback& callback) {
   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,
@@ skipping 263 matching lines @@
   return loaded_ && cache_->IsKnownURL(url);
 }
 
 bool TopSites::IsFull() {
   return loaded_ && cache_->top_sites().size() >= kTopSitesNumber;
 }
 
 TopSites::~TopSites() {
 }
 
-bool TopSites::SetPageThumbnailNoDB(const GURL& url,
-                                    const base::RefCountedBytes* thumbnail_data,
-                                    const ThumbnailScore& score) {
+bool TopSites::SetPageThumbnailNoDB(
+    const GURL& url,
+    const base::RefCountedMemory* thumbnail_data,
+    const ThumbnailScore& score) {
   // This should only be invoked when we know about the url.
   DCHECK(cache_->IsKnownURL(url));
 
   const MostVisitedURL& most_visited =
       cache_->top_sites()[cache_->GetURLIndex(url)];
   Images* image = cache_->GetImage(url);
 
   // When comparing the thumbnail scores, we need to take into account the
   // redirect hops, which are not generated when the thumbnail is because the
   // redirects weren't known. We fill that in here since we know the redirects.
   ThumbnailScore new_score_with_redirects(score);
   new_score_with_redirects.redirect_hops_from_dest =
       GetRedirectDistanceForURL(most_visited, url);
 
   if (!ShouldReplaceThumbnailWith(image->thumbnail_score,
                                   new_score_with_redirects) &&
       image->thumbnail.get())
     return false;  // The one we already have is better.
 
-  image->thumbnail = const_cast<base::RefCountedBytes*>(thumbnail_data);
+  image->thumbnail = const_cast<base::RefCountedMemory*>(thumbnail_data);
   image->thumbnail_score = new_score_with_redirects;
 
   ResetThreadSafeImageCache();
   return true;
 }
 
 bool TopSites::SetPageThumbnailEncoded(const GURL& url,
-                                       const base::RefCountedBytes* thumbnail,
+                                       const base::RefCountedMemory* thumbnail,
                                        const ThumbnailScore& score) {
   if (!SetPageThumbnailNoDB(url, thumbnail, score))
     return false;
 
   // Update the database.
   if (!cache_->IsKnownURL(url))
     return false;
 
   size_t index = cache_->GetURLIndex(url);
   const MostVisitedURL& most_visited = cache_->top_sites()[index];
@@ skipping 24 matching lines @@
   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 base::RefCountedBytes* thumbnail,
+                                     const base::RefCountedMemory* thumbnail,
                                      const ThumbnailScore& score) {
   if (temp_images_.size() == kMaxTempTopImages)
     temp_images_.erase(temp_images_.begin());
 
   TempImage image;
   image.first = url;
-  image.second.thumbnail = const_cast<base::RefCountedBytes*>(thumbnail);
+  image.second.thumbnail = const_cast<base::RefCountedMemory*>(thumbnail);
   image.second.thumbnail_score = score;
   temp_images_.push_back(image);
 }
 
 void TopSites::TimerFired() {
   StartQueryForMostVisited();
 }
 
 // static
 int TopSites::GetRedirectDistanceForURL(const MostVisitedURL& most_visited,
@@ skipping 283 matching lines @@
   SetTopSites(pages);
 
   // Used only in testing.
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOP_SITES_UPDATED,
       content::Source<TopSites>(this),
       content::Details<CancelableRequestProvider::Handle>(&handle));
 }
 
 }  // namespace history