Cleanup: Remove unused SearchTabHelper::GetOpenUrls

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>
@@ skipping 154 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.get(), score);
     return true;
   }
 
   return SetPageThumbnailEncoded(url, thumbnail_data.get(), score);
 }
 
-bool TopSitesImpl::SetPageThumbnailToJPEGBytes(
-    const GURL& url,
-    const base::RefCountedMemory* memory,
-    const ThumbnailScore& score) {
-  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 (!can_add_url_to_history_.Run(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 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.
@@ skipping 139 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   {
     DictionaryPrefUpdate update(pref_service_, kMostVisitedURLsBlacklist);
     base::DictionaryValue* blacklist = update.Get();
     blacklist->Clear();
   }
   ResetThreadSafeCache();
   NotifyTopSitesChanged(TopSitesObserver::ChangeReason::BLACKLIST);
 }
 
+bool TopSitesImpl::IsKnownURL(const GURL& url) {

[sdefresne, 2016/12/21 12:57:09]

I assume you are just reordering function to match header file here, correct?

[Marc Treib, 2016/12/26 19:56:51]

Yup, exactly. The only change apart from the reordering is that
StartQueryForMostVisited now returns void (previously it returned a
CancelableTaskTracker which was never used).

+  return loaded_ && cache_->IsKnownURL(url);
+}
+
+bool TopSitesImpl::IsNonForcedFull() {
+  return loaded_ && cache_->GetNumNonForcedURLs() >= kNonForcedTopSitesNumber;
+}
+
+bool TopSitesImpl::IsForcedFull() {
+  return loaded_ && cache_->GetNumForcedURLs() >= kForcedTopSitesNumber;
+}
+
+PrepopulatedPageList TopSitesImpl::GetPrepopulatedPages() {
+  return prepopulated_pages_;
+}
+
+bool TopSitesImpl::loaded() const {
+  return loaded_;
+}
+
+bool TopSitesImpl::AddForcedURL(const GURL& url, const base::Time& time) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!loaded_) {
+    // Optimally we could cache this and apply it after the load completes, but
+    // in practice it's not an issue since AddForcedURL will be called again
+    // next time the user hits the NTP.
+    return false;
+  }
+
+  size_t num_forced = cache_->GetNumForcedURLs();
+  MostVisitedURLList new_list(cache_->top_sites());
+  MostVisitedURL new_url;
+
+  if (cache_->IsKnownURL(url)) {
+    size_t index = cache_->GetURLIndex(url);
+    // Do nothing if we currently have that URL as non-forced.
+    if (new_list[index].last_forced_time.is_null())
+      return false;
+
+    // Update the |last_forced_time| of the already existing URL. Delete it and
+    // reinsert it at the right location.
+    new_url = new_list[index];
+    new_list.erase(new_list.begin() + index);
+    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.
+  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;
+
+  if (!cache_->IsKnownURL(url) && can_add_url_to_history_.Run(url)) {
+    // To avoid slamming history we throttle requests when the url updates. To
+    // do otherwise negatively impacts perf tests.
+    RestartQueryForTopSitesTimer(GetUpdateDelay());
+  }
+}
+
 void TopSitesImpl::ShutdownOnUIThread() {
   history_service_ = nullptr;
   history_service_observer_.RemoveAll();
   // Cancel all requests so that the service doesn't callback to us after we've
   // invoked Shutdown (this could happen if we have a pending request and
   // Shutdown is invoked).
   cancelable_task_tracker_.TryCancelAll();
   if (backend_)
     backend_->Shutdown();
 }
 
 // static
 void TopSitesImpl::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(kMostVisitedURLsBlacklist);
 }
 
+TopSitesImpl::~TopSitesImpl() = default;
+
+void TopSitesImpl::StartQueryForMostVisited() {
+  DCHECK(loaded_);
+  if (!history_service_)
+    return;
+
+  history_service_->QueryMostVisitedURLs(
+      num_results_to_request_from_history(), kDaysOfHistory,
+      base::Bind(&TopSitesImpl::OnTopSitesAvailableFromHistory,
+                 base::Unretained(this)),
+      &cancelable_task_tracker_);
+}
+
 // 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++) {
@@ skipping 42 matching lines @@
 
   // 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 (!history_service_)
-    return base::CancelableTaskTracker::kBadTaskId;
-
-  return history_service_->QueryMostVisitedURLs(
-      num_results_to_request_from_history(), kDaysOfHistory,
-      base::Bind(&TopSitesImpl::OnTopSitesAvailableFromHistory,
-                 base::Unretained(this)),
-      &cancelable_task_tracker_);
-}
-
-bool TopSitesImpl::IsKnownURL(const GURL& url) {
-  return loaded_ && cache_->IsKnownURL(url);
-}
-
-const std::string& TopSitesImpl::GetCanonicalURLString(const GURL& url) const {
-  return cache_->GetCanonicalURL(url).spec();
-}
-
-bool TopSitesImpl::IsNonForcedFull() {
-  return loaded_ && cache_->GetNumNonForcedURLs() >= kNonForcedTopSitesNumber;
-}
-
-bool TopSitesImpl::IsForcedFull() {
-  return loaded_ && cache_->GetNumForcedURLs() >= kForcedTopSitesNumber;
-}
-
-TopSitesImpl::~TopSitesImpl() {
-}
-
 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);
@@ skipping 86 matching lines @@
 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;
 }
 
-PrepopulatedPageList TopSitesImpl::GetPrepopulatedPages() {
-  return prepopulated_pages_;
-}
-
-bool TopSitesImpl::loaded() const {
-  return loaded_;
-}
-
-bool TopSitesImpl::AddForcedURL(const GURL& url, const base::Time& time) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  if (!loaded_) {
-    // Optimally we could cache this and apply it after the load completes, but
-    // in practice it's not an issue since AddForcedURL will be called again
-    // next time the user hits the NTP.
-    return false;
-  }
-
-  size_t num_forced = cache_->GetNumForcedURLs();
-  MostVisitedURLList new_list(cache_->top_sites());
-  MostVisitedURL new_url;
-
-  if (cache_->IsKnownURL(url)) {
-    size_t index = cache_->GetURLIndex(url);
-    // Do nothing if we currently have that URL as non-forced.
-    if (new_list[index].last_forced_time.is_null())
-      return false;
-
-    // Update the |last_forced_time| of the already existing URL. Delete it and
-    // reinsert it at the right location.
-    new_url = new_list[index];
-    new_list.erase(new_list.begin() + index);
-    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.
-  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;
-
-  if (!cache_->IsKnownURL(url) && can_add_url_to_history_.Run(url)) {
-    // To avoid slamming history we throttle requests when the url updates. To
-    // do otherwise negatively impacts perf tests.
-    RestartQueryForTopSitesTimer(GetUpdateDelay());
-  }
-}
-
 bool TopSitesImpl::AddPrepopulatedPages(MostVisitedURLList* urls,
                                         size_t num_forced_urls) {
   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;
     }
   }
@@ skipping 275 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