TopSites: various small cleanups

components/history/core/browser/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 "components/history/core/browser/top_sites_impl.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/history_db_task.h"
+#include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/page_usage_data.h"
 #include "components/history/core/browser/top_sites_cache.h"
 #include "components/history/core/browser/top_sites_observer.h"
 #include "components/history/core/browser/url_utils.h"
 #include "components/history/core/common/thumbnail_score.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
-#include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_util.h"
 
-using base::DictionaryValue;
-
 namespace history {
 namespace {
 
 void RunOrPostGetMostVisitedURLsCallback(
     base::TaskRunner* task_runner,
     bool include_forced_urls,
     const TopSitesImpl::GetMostVisitedURLsCallback& callback,
     const MostVisitedURLList& all_urls,
     const MostVisitedURLList& nonforced_urls) {
-  const MostVisitedURLList* urls =
-      include_forced_urls ? &all_urls : &nonforced_urls;
+  const MostVisitedURLList& urls =
+      include_forced_urls ? all_urls : nonforced_urls;
   if (task_runner->RunsTasksOnCurrentThread())
-    callback.Run(*urls);
+    callback.Run(urls);
   else
-    task_runner->PostTask(FROM_HERE, base::Bind(callback, *urls));
+    task_runner->PostTask(FROM_HERE, base::Bind(callback, urls));
 }
 
 // Compares two MostVisitedURL having a non-null |last_forced_time|.
 bool ForcedURLComparator(const MostVisitedURL& first,
                          const MostVisitedURL& second) {
   DCHECK(!first.last_forced_time.is_null() &&
          !second.last_forced_time.is_null());
   return first.last_forced_time < second.last_forced_time;
 }
 
@@ skipping 32 matching lines @@
 }  // namespace
 
 // Initially, histogram is not recorded.
 bool TopSitesImpl::histogram_recorded_ = false;
 
 TopSitesImpl::TopSitesImpl(PrefService* pref_service,
                            HistoryService* history_service,
                            const PrepopulatedPageList& prepopulated_pages,
                            const CanAddURLToHistoryFn& can_add_url_to_history)
     : backend_(nullptr),
-      cache_(new TopSitesCache()),
-      thread_safe_cache_(new TopSitesCache()),
+      cache_(base::MakeUnique<TopSitesCache>()),
+      thread_safe_cache_(base::MakeUnique<TopSitesCache>()),
       last_num_urls_changed_(0),
       prepopulated_pages_(prepopulated_pages),
       pref_service_(pref_service),
       history_service_(history_service),
       can_add_url_to_history_(can_add_url_to_history),
       loaded_(false),
       history_service_observer_(this) {
   DCHECK(pref_service_);
   DCHECK(!can_add_url_to_history_.is_null());
 }
@@ skipping 17 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   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 (!IsNonForcedFull()) {
-      add_temp_thumbnail = true;
-    } else {
-      return false;  // This URL is not known to us.
-    }
+    if (IsNonForcedFull())
+      return false;  // We're full, and this URL is not known to us.
+
+    add_temp_thumbnail = true;
   }
 
   if (!can_add_url_to_history_.Run(url))
     return false;  // It's not a real webpage.
 
   scoped_refptr<base::RefCountedBytes> thumbnail_data;
   if (!EncodeBitmap(thumbnail, &thumbnail_data))
     return false;
 
   if (add_temp_thumbnail) {
@@ skipping 56 matching lines @@
     }
   }
 
   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));
 
-    for (std::vector<GURL>::iterator it = url_list.begin();
-         it != url_list.end(); ++it) {
+    for (const GURL& url : url_list) {
       base::AutoLock lock(lock_);
 
-      GURL canonical_url;
       // Test whether any stored URL is a prefix of |url|.
-      canonical_url = thread_safe_cache_->GetGeneralizedCanonicalURL(*it);
+      GURL canonical_url = thread_safe_cache_->GetGeneralizedCanonicalURL(url);
       if (!canonical_url.is_empty() &&
           thread_safe_cache_->GetPageThumbnail(canonical_url, bytes)) {
         return true;
       }
     }
   }
 
   return false;
 }
 
 bool TopSitesImpl::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);
 }
 
 bool TopSitesImpl::GetTemporaryPageThumbnailScore(const GURL& url,
                                                   ThumbnailScore* score) {
-  for (TempImages::iterator i = temp_images_.begin(); i != temp_images_.end();
-       ++i) {
-    if (i->first == url) {
-      *score = i->second.thumbnail_score;
+  for (const TempImage& temp_image : temp_images_) {
+    if (temp_image.first == url) {
+      *score = temp_image.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++) {
@@ skipping 107 matching lines @@
     num_forced--;
   } else {
     new_url.url = url;
     new_url.redirects.push_back(url);
   }
   new_url.last_forced_time = time;
   // Add forced URLs and sort. Added to the end of the list of forced URLs
   // 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.
+  mid = new_list.insert(mid, new_url);
   std::inplace_merge(new_list.begin(), mid, mid + 1, ForcedURLComparator);
   SetTopSites(new_list, CALL_LOCATION_FROM_FORCED_URLS);
   return true;
 }
 
 void TopSitesImpl::OnNavigationCommitted(const GURL& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!loaded_ || IsNonForcedFull())
     return;
 
@@ skipping 82 matching lines @@
         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]);
+  for (const std::pair<GURL, size_t>& old_url : all_old_urls) {
+    if (old_url.second != kAlreadyFoundMarker)
+      delta->deleted.push_back(old_list[old_url.second]);
   }
 }
 
 bool TopSitesImpl::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())
+  if (image->thumbnail.get() &&
+      !ShouldReplaceThumbnailWith(image->thumbnail_score,
+                                  new_score_with_redirects)) {
     return false;  // The one we already have is better.
+  }
 
   image->thumbnail = const_cast<base::RefCountedMemory*>(thumbnail_data);
   image->thumbnail_score = new_score_with_redirects;
 
   ResetThreadSafeImageCache();
   return true;
 }
 
 bool TopSitesImpl::SetPageThumbnailEncoded(
     const GURL& url,
@@ skipping 14 matching lines @@
                              *(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();
-  std::vector<unsigned char> data;
-  if (!gfx::JPEG1xEncodedDataFromImage(bitmap, kTopSitesImageQuality, &data))
+  if (!gfx::JPEG1xEncodedDataFromImage(bitmap, kTopSitesImageQuality,
+                                       &(*bytes)->data())) {
     return false;
+  }
 
   // As we're going to cache this data, make sure the vector is only as big as
   // it needs to be, as JPEGCodec::Encode() over-allocates data.capacity().
-  // (In a C++0x future, we can just call shrink_to_fit() in Encode())
-  (*bytes)->data() = data;
+  (*bytes)->data().shrink_to_fit();
   return true;
 }
 
 void TopSitesImpl::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 TopSitesImpl::AddTemporaryThumbnail(
-    const GURL& url,
-    const base::RefCountedMemory* thumbnail,
-    const ThumbnailScore& score) {
+void TopSitesImpl::AddTemporaryThumbnail(const GURL& url,
+                                         base::RefCountedMemory* thumbnail,
+                                         const ThumbnailScore& score) {
   if (temp_images_.size() == kMaxTempTopImages)
-    temp_images_.erase(temp_images_.begin());
+    temp_images_.pop_front();
 
   TempImage image;
   image.first = url;
-  image.second.thumbnail = const_cast<base::RefCountedMemory*>(thumbnail);
+  image.second.thumbnail = thumbnail;
   image.second.thumbnail_score = score;
   temp_images_.push_back(image);
 }
 
 void TopSitesImpl::TimerFired() {
   StartQueryForMostVisited();
 }
 
 // static
 int TopSitesImpl::GetRedirectDistanceForURL(const MostVisitedURL& most_visited,
                                             const GURL& url) {
   for (size_t i = 0; i < most_visited.redirects.size(); i++) {
     if (most_visited.redirects[i] == url)
       return static_cast<int>(most_visited.redirects.size() - i - 1);
   }
   NOTREACHED() << "URL should always be found.";
   return 0;
 }
 
 bool TopSitesImpl::AddPrepopulatedPages(MostVisitedURLList* urls,
-                                        size_t num_forced_urls) {
+                                        size_t num_forced_urls) const {
   bool added = false;
   for (const auto& prepopulated_page : prepopulated_pages_) {
     if (urls->size() - num_forced_urls < kNonForcedTopSitesNumber &&
         IndexOf(*urls, prepopulated_page.most_visited.url) == -1) {
       urls->push_back(prepopulated_page.most_visited);
       added = true;
     }
   }
   return added;
 }
 
-size_t TopSitesImpl::MergeCachedForcedURLs(MostVisitedURLList* new_list) {
+size_t TopSitesImpl::MergeCachedForcedURLs(MostVisitedURLList* new_list) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Add all the new URLs for quick lookup. Take that opportunity to count the
   // number of forced URLs in |new_list|.
   std::set<GURL> all_new_urls;
   size_t num_forced = 0;
   for (size_t i = 0; i < new_list->size(); ++i) {
     for (size_t j = 0; j < (*new_list)[i].redirects.size(); j++) {
       all_new_urls.insert((*new_list)[i].redirects[j]);
     }
     if (!(*new_list)[i].last_forced_time.is_null())
@@ skipping 48 matching lines @@
         // Forced URL.
         if (num_forced_urls >= kForcedTopSitesNumber)
           continue;
         num_forced_urls++;
       }
       out->push_back(urls[i]);
     }
   }
 }
 
+// static
 std::string TopSitesImpl::GetURLHash(const GURL& url) {
   // We don't use canonical URLs here to be able to blacklist only one of
   // the two 'duplicate' sites, e.g. 'gmail.com' and 'mail.google.com'.
   return base::MD5String(url.spec());
 }
 
-base::TimeDelta TopSitesImpl::GetUpdateDelay() {
+base::TimeDelta TopSitesImpl::GetUpdateDelay() const {
   if (cache_->top_sites().size() <= prepopulated_pages_.size())
     return base::TimeDelta::FromSeconds(30);
 
   int64_t range = kMaxUpdateIntervalMinutes - kMinUpdateIntervalMinutes;
   int64_t minutes = kMaxUpdateIntervalMinutes -
                     last_num_urls_changed_ * range / cache_->top_sites().size();
   return base::TimeDelta::FromMinutes(minutes);
 }
 
 void TopSitesImpl::SetTopSites(const MostVisitedURLList& new_top_sites,
@@ skipping 28 matching lines @@
     backend_->UpdateTopSites(delta, record_or_not);
   }
 
   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.
+  // See if we have any temp thumbnails for the new sites, and promote them to
+  // proper thumbnails.
   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 (const MostVisitedURL& mv : top_sites) {
+      const 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);
           temp_images_.erase(it);
           break;
         }
@@ skipping 133 matching lines @@
     for (std::set<size_t>::reverse_iterator i = indices_to_delete.rbegin();
          i != indices_to_delete.rend(); i++) {
       new_top_sites.erase(new_top_sites.begin() + *i);
     }
     SetTopSites(new_top_sites, CALL_LOCATION_FROM_OTHER_PLACES);
   }
   StartQueryForMostVisited();
 }
 
 }  // namespace history