Create a --disable-top-sites flag for use by telemetry tests

components/ntp_tiles/most_visited_sites.cc

 // Copyright 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/ntp_tiles/most_visited_sites.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 180 matching lines @@
       num_sites_(0),
       received_most_visited_sites_(false),
       received_popular_sites_(false),
       recorded_uma_(false),
       scoped_observer_(this),
       mv_source_(SUGGESTIONS_SERVICE),
       blocking_pool_(std::move(blocking_pool)),
       blocking_runner_(blocking_pool_->GetTaskRunnerWithShutdownBehavior(
           base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)),
       weak_ptr_factory_(this) {
-  DCHECK(top_sites_);
   DCHECK(suggestions_service_);
   supervisor_->SetObserver(this);
 }
 
 MostVisitedSites::~MostVisitedSites() {
   supervisor_->SetObserver(nullptr);
 }
 
 void MostVisitedSites::SetMostVisitedURLsObserver(Observer* observer,
                                                   int num_sites) {
   DCHECK(observer);
   observer_ = observer;
   num_sites_ = num_sites;
 
   if (ShouldShowPopularSites() &&
       NeedPopularSites(prefs_, num_sites_)) {
     popular_sites_.reset(new PopularSites(
         blocking_pool_, prefs_, template_url_service_, variations_service_,
         download_context_, popular_sites_directory_, GetPopularSitesCountry(),
         GetPopularSitesVersion(), false,
         base::Bind(&MostVisitedSites::OnPopularSitesAvailable,
                    base::Unretained(this))));
   } else {
     received_popular_sites_ = true;
   }
 
-  // TopSites updates itself after a delay. To ensure up-to-date results,
-  // force an update now.
-  top_sites_->SyncWithHistory();
+  if (top_sites_) {
+    // TopSites updates itself after a delay. To ensure up-to-date results,
+    // force an update now.
+    top_sites_->SyncWithHistory();
 
-  // Register as TopSitesObserver so that we can update ourselves when the
-  // TopSites changes.
-  scoped_observer_.Add(top_sites_.get());
+    // Register as TopSitesObserver so that we can update ourselves when the
+    // TopSites changes.
+    scoped_observer_.Add(top_sites_.get());
+  }
 
   suggestions_subscription_ = suggestions_service_->AddCallback(
       base::Bind(&MostVisitedSites::OnSuggestionsProfileAvailable,
                  base::Unretained(this)));
 
   // Immediately build the current suggestions, getting personal suggestions
   // from the SuggestionsService's cache or, if that is empty, from TopSites.
   BuildCurrentSuggestions();
   // Also start a request for fresh suggestions.
   suggestions_service_->FetchSuggestionsData();
 }
 
 void MostVisitedSites::AddOrRemoveBlacklistedUrl(const GURL& url,
                                                  bool add_url) {
-  // Always blacklist in the local TopSites.
-  if (add_url)
-    top_sites_->AddBlacklistedURL(url);
-  else
-    top_sites_->RemoveBlacklistedURL(url);
+  if (top_sites_) {
+    // Always blacklist in the local TopSites.
+    if (add_url)
+      top_sites_->AddBlacklistedURL(url);
+    else
+      top_sites_->RemoveBlacklistedURL(url);
+  }
 
   // Only blacklist in the server-side suggestions service if it's active.
   if (mv_source_ == SUGGESTIONS_SERVICE) {
     if (add_url)
       suggestions_service_->BlacklistURL(url);
     else
       suggestions_service_->UndoBlacklistURL(url);
   }
 }
 
@@ skipping 49 matching lines @@
 }
 
 void MostVisitedSites::BuildCurrentSuggestions() {
   // Get the current suggestions from cache. If the cache is empty, this will
   // fall back to TopSites.
   OnSuggestionsProfileAvailable(
       suggestions_service_->GetSuggestionsDataFromCache());
 }
 
 void MostVisitedSites::InitiateTopSitesQuery() {
+  if (!top_sites_)
+    return;
   top_sites_->GetMostVisitedURLs(
       base::Bind(&MostVisitedSites::OnMostVisitedURLsAvailable,
                  weak_ptr_factory_.GetWeakPtr()),
       false);
 }
 
 base::FilePath MostVisitedSites::GetWhitelistLargeIconPath(const GURL& url) {
   for (const auto& whitelist : supervisor_->whitelists()) {
     if (AreURLsEquivalent(whitelist.entry_point, url))
       return whitelist.large_icon_path;
@@ skipping 74 matching lines @@
 
   size_t num_whitelist_suggestions = num_sites_ - num_personal_suggestions;
   SuggestionsVector whitelist_suggestions;
 
   std::set<std::string> personal_hosts;
   for (const auto& suggestion : personal_suggestions)
     personal_hosts.insert(suggestion.url.host());
 
   for (const auto& whitelist : supervisor_->whitelists()) {
     // Skip blacklisted sites.
-    if (top_sites_->IsBlacklisted(whitelist.entry_point))
+    if (top_sites_ && top_sites_->IsBlacklisted(whitelist.entry_point))
       continue;
 
     // Skip suggestions already present.
     if (personal_hosts.find(whitelist.entry_point.host()) !=
         personal_hosts.end())
       continue;
 
     // Skip whitelist entry points that are manually blocked.
     if (supervisor_->IsBlocked(whitelist.entry_point))
       continue;
@@ skipping 30 matching lines @@
   SuggestionsVector popular_sites_suggestions;
 
   if (num_popular_sites_suggestions > 0 && popular_sites_) {
     std::set<std::string> hosts;
     for (const auto& suggestion : personal_suggestions)
       hosts.insert(suggestion.url.host());
     for (const auto& suggestion : whitelist_suggestions)
       hosts.insert(suggestion.url.host());
     for (const PopularSites::Site& popular_site : popular_sites_->sites()) {
       // Skip blacklisted sites.
-      if (top_sites_->IsBlacklisted(popular_site.url))
+      if (top_sites_ && top_sites_->IsBlacklisted(popular_site.url))
         continue;
       std::string host = popular_site.url.host();
       // Skip suggestions already present in personal or whitelists.
       if (hosts.find(host) != hosts.end())
         continue;
 
       Suggestion suggestion;
       suggestion.title = popular_site.title;
       suggestion.url = GURL(popular_site.url);
       suggestion.source = POPULAR;
@@ skipping 95 matching lines @@
 
 void MostVisitedSites::TopSitesChanged(TopSites* top_sites,
                                        ChangeReason change_reason) {
   if (mv_source_ == TOP_SITES) {
     // The displayed suggestions are invalidated.
     InitiateTopSitesQuery();
   }
 }
 
 }  // namespace ntp_tiles