ntp_tiles: Migrate to multi-observer model

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 <string>
 #include <utility>
@@ skipping 12 matching lines @@
 
 using history::TopSites;
 using suggestions::ChromeSuggestion;
 using suggestions::SuggestionsProfile;
 using suggestions::SuggestionsService;
 
 namespace ntp_tiles {
 
 namespace {
 
+constexpr int kNumTilesForObservers = 12;
+
 const base::Feature kDisplaySuggestionsServiceTiles{
     "DisplaySuggestionsServiceTiles", base::FEATURE_ENABLED_BY_DEFAULT};
 
 // Determine whether we need any tiles from PopularSites to fill up a grid of
 // |num_tiles| tiles.
 bool NeedPopularSites(const PrefService* prefs, int num_tiles) {
   return prefs->GetInteger(prefs::kNumPersonalTiles) < num_tiles;
 }
 
 bool AreURLsEquivalent(const GURL& url1, const GURL& url2) {
   return url1.host_piece() == url2.host_piece() &&
          url1.path_piece() == url2.path_piece();
 }
 
 }  // namespace
 
 MostVisitedSites::MostVisitedSites(
     PrefService* prefs,
     scoped_refptr<history::TopSites> top_sites,
     SuggestionsService* suggestions,
     std::unique_ptr<PopularSites> popular_sites,
     std::unique_ptr<IconCacher> icon_cacher,
     std::unique_ptr<MostVisitedSitesSupervisor> supervisor)
     : prefs_(prefs),
       top_sites_(top_sites),
       suggestions_service_(suggestions),
       popular_sites_(std::move(popular_sites)),
       icon_cacher_(std::move(icon_cacher)),
       supervisor_(std::move(supervisor)),
-      observer_(nullptr),
-      num_sites_(0),
       top_sites_observer_(this),
       mv_source_(NTPTileSource::TOP_SITES),
       top_sites_weak_ptr_factory_(this) {
   DCHECK(prefs_);
   // top_sites_ can be null in tests.
   // TODO(sfiera): have iOS use a dummy TopSites in its tests.
   DCHECK(suggestions_service_);
   if (supervisor_)
     supervisor_->SetObserver(this);
-}
-
-MostVisitedSites::~MostVisitedSites() {
-  if (supervisor_)
-    supervisor_->SetObserver(nullptr);
-}
-
-void MostVisitedSites::SetMostVisitedURLsObserver(Observer* observer,
-                                                  int num_sites) {
-  DCHECK(observer);
-  observer_ = observer;
-  num_sites_ = num_sites;
 
   // The order for this condition is important, ShouldShowPopularSites() should
   // always be called last to keep metrics as relevant as possible.
-  if (popular_sites_ && NeedPopularSites(prefs_, num_sites_) &&
+  if (popular_sites_ && NeedPopularSites(prefs_, kNumTilesForObservers) &&
       ShouldShowPopularSites()) {
     popular_sites_->StartFetch(
         false, base::Bind(&MostVisitedSites::OnPopularSitesAvailable,
                           base::Unretained(this)));
   }
 
   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.
     top_sites_observer_.Add(top_sites_.get());
   }
 
   suggestions_subscription_ = suggestions_service_->AddCallback(
       base::Bind(&MostVisitedSites::OnSuggestionsProfileAvailable,
                  base::Unretained(this)));
+}
+
+MostVisitedSites::~MostVisitedSites() {
+  if (supervisor_)
+    supervisor_->SetObserver(nullptr);
+}
+
+void MostVisitedSites::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void MostVisitedSites::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+void MostVisitedSites::Refresh() {
+  // TODO(mastiz): Refresh PopularSites too if enabled.
+
+  // TopSites updates itself after a delay. To ensure up-to-date results, force
+  // an update now.
+  if (top_sites_)
+    top_sites_->SyncWithHistory();
 
   // Immediately build the current set of tiles, getting suggestions from the
   // SuggestionsService's cache or, if that is empty, sites from TopSites.
   BuildCurrentTiles();
   // Also start a request for fresh suggestions.
-  Refresh();
-}
-
-void MostVisitedSites::Refresh() {
   suggestions_service_->FetchSuggestionsData();
 }
 
 void MostVisitedSites::AddOrRemoveBlacklistedUrl(const GURL& url,
                                                  bool add_url) {
   if (top_sites_) {
     // Always blacklist in the local TopSites.
     if (add_url)
       top_sites_->AddBlacklistedURL(url);
     else
@@ skipping 63 matching lines @@
 void MostVisitedSites::OnMostVisitedURLsAvailable(
     const history::MostVisitedURLList& visited_list) {
   // Ignore the event if tiles provided by the Suggestions Service, which take
   // precedence.
   if (mv_source_ == NTPTileSource::SUGGESTIONS_SERVICE) {
     return;
   }
 
   NTPTilesVector tiles;
   size_t num_tiles =
-      std::min(visited_list.size(), static_cast<size_t>(num_sites_));
+      std::min(visited_list.size(), static_cast<size_t>(kNumTilesForObservers));
   for (size_t i = 0; i < num_tiles; ++i) {
     const history::MostVisitedURL& visited = visited_list[i];
     if (visited.url.is_empty()) {
       num_tiles = i;
       break;  // This is the signal that there are no more real visited sites.
     }
     if (supervisor_ && supervisor_->IsBlocked(visited.url))
       continue;
 
     NTPTile tile;
     tile.title = visited.title;
     tile.url = visited.url;
     tile.source = NTPTileSource::TOP_SITES;
     tile.whitelist_icon_path = GetWhitelistLargeIconPath(visited.url);
 
     tiles.push_back(std::move(tile));
   }
 
   mv_source_ = NTPTileSource::TOP_SITES;
   SaveNewTiles(std::move(tiles));
-  NotifyMostVisitedURLsObserver();
+  NotifyMostVisitedURLsObservers();
 }
 
 void MostVisitedSites::OnSuggestionsProfileAvailable(
     const SuggestionsProfile& suggestions_profile) {
   int num_tiles = suggestions_profile.suggestions_size();
   // With no server suggestions, fall back to local TopSites.
   if (num_tiles == 0 ||
       !base::FeatureList::IsEnabled(kDisplaySuggestionsServiceTiles)) {
     mv_source_ = NTPTileSource::TOP_SITES;
     InitiateTopSitesQuery();
     return;
   }
-  if (num_sites_ < num_tiles)
-    num_tiles = num_sites_;
+  if (kNumTilesForObservers < num_tiles)
+    num_tiles = kNumTilesForObservers;
 
   NTPTilesVector tiles;
   for (int i = 0; i < num_tiles; ++i) {
     const ChromeSuggestion& suggestion_pb = suggestions_profile.suggestions(i);
     GURL url(suggestion_pb.url());
     if (supervisor_ && supervisor_->IsBlocked(url))
       continue;
 
     NTPTile tile;
     tile.title = base::UTF8ToUTF16(suggestion_pb.title());
     tile.url = url;
     tile.source = NTPTileSource::SUGGESTIONS_SERVICE;
     tile.whitelist_icon_path = GetWhitelistLargeIconPath(url);
     tile.thumbnail_url = GURL(suggestion_pb.thumbnail());
     tile.favicon_url = GURL(suggestion_pb.favicon_url());
 
     tiles.push_back(std::move(tile));
   }
 
   mv_source_ = NTPTileSource::SUGGESTIONS_SERVICE;
   SaveNewTiles(std::move(tiles));
-  NotifyMostVisitedURLsObserver();
+  NotifyMostVisitedURLsObservers();
 }
 
 NTPTilesVector MostVisitedSites::CreateWhitelistEntryPointTiles(
     const NTPTilesVector& personal_tiles) {
   if (!supervisor_) {
     return NTPTilesVector();
   }
 
   size_t num_personal_tiles = personal_tiles.size();
-  DCHECK_LE(num_personal_tiles, static_cast<size_t>(num_sites_));
+  DCHECK_LE(num_personal_tiles, static_cast<size_t>(kNumTilesForObservers));
 
-  size_t num_whitelist_tiles = num_sites_ - num_personal_tiles;
+  size_t num_whitelist_tiles = kNumTilesForObservers - num_personal_tiles;
   NTPTilesVector whitelist_tiles;
 
   std::set<std::string> personal_hosts;
   for (const auto& tile : personal_tiles)
     personal_hosts.insert(tile.url.host());
 
   for (const auto& whitelist : supervisor_->whitelists()) {
     // Skip blacklisted sites.
     if (top_sites_ && top_sites_->IsBlacklisted(whitelist.entry_point))
       continue;
@@ skipping 22 matching lines @@
 }
 
 NTPTilesVector MostVisitedSites::CreatePopularSitesTiles(
     const NTPTilesVector& personal_tiles,
     const NTPTilesVector& whitelist_tiles) {
   // For child accounts popular sites tiles will not be added.
   if (supervisor_ && supervisor_->IsChildProfile())
     return NTPTilesVector();
 
   size_t num_tiles = personal_tiles.size() + whitelist_tiles.size();
-  DCHECK_LE(num_tiles, static_cast<size_t>(num_sites_));
+  DCHECK_LE(num_tiles, static_cast<size_t>(kNumTilesForObservers));
 
   // Collect non-blacklisted popular suggestions, skipping those already present
   // in the personal suggestions.
-  size_t num_popular_sites_tiles = num_sites_ - num_tiles;
+  size_t num_popular_sites_tiles = kNumTilesForObservers - num_tiles;
   NTPTilesVector popular_sites_tiles;
 
   if (num_popular_sites_tiles > 0 && popular_sites_) {
     std::set<std::string> hosts;
     for (const auto& tile : personal_tiles)
       hosts.insert(tile.url.host());
     for (const auto& tile : whitelist_tiles)
       hosts.insert(tile.url.host());
     for (const PopularSites::Site& popular_site : popular_sites_->sites()) {
       // Skip blacklisted sites.
@@ skipping 21 matching lines @@
 }
 
 void MostVisitedSites::SaveNewTiles(NTPTilesVector personal_tiles) {
   NTPTilesVector whitelist_tiles =
       CreateWhitelistEntryPointTiles(personal_tiles);
   NTPTilesVector popular_sites_tiles =
       CreatePopularSitesTiles(personal_tiles, whitelist_tiles);
 
   size_t num_actual_tiles = personal_tiles.size() + whitelist_tiles.size() +
                             popular_sites_tiles.size();
-  DCHECK_LE(num_actual_tiles, static_cast<size_t>(num_sites_));
+  DCHECK_LE(num_actual_tiles, static_cast<size_t>(kNumTilesForObservers));
 
   current_tiles_ =
       MergeTiles(std::move(personal_tiles), std::move(whitelist_tiles),
                  std::move(popular_sites_tiles));
   DCHECK_EQ(num_actual_tiles, current_tiles_.size());
 
   int num_personal_tiles = 0;
   for (const auto& tile : current_tiles_) {
     if (tile.source != NTPTileSource::POPULAR)
       num_personal_tiles++;
   }
   prefs_->SetInteger(prefs::kNumPersonalTiles, num_personal_tiles);
 }
 
 // static
 NTPTilesVector MostVisitedSites::MergeTiles(NTPTilesVector personal_tiles,
                                             NTPTilesVector whitelist_tiles,
                                             NTPTilesVector popular_tiles) {
   NTPTilesVector merged_tiles;
   std::move(personal_tiles.begin(), personal_tiles.end(),
             std::back_inserter(merged_tiles));
   std::move(whitelist_tiles.begin(), whitelist_tiles.end(),
             std::back_inserter(merged_tiles));
   std::move(popular_tiles.begin(), popular_tiles.end(),
             std::back_inserter(merged_tiles));
   return merged_tiles;
 }
 
-void MostVisitedSites::NotifyMostVisitedURLsObserver() {
-  if (!observer_)
-    return;
-
-  observer_->OnMostVisitedURLsAvailable(current_tiles_);
+void MostVisitedSites::NotifyMostVisitedURLsObservers() {
+  for (Observer& observer : observer_list_)
+    observer.OnMostVisitedURLsAvailable(current_tiles_);
 }
 
 void MostVisitedSites::OnPopularSitesAvailable(bool success) {
   if (!success) {
     LOG(WARNING) << "Download of popular sites failed";
     return;
   }
 
   // Re-build the tile list. Once done, this will notify the observer.
   BuildCurrentTiles();
 }
 
 void MostVisitedSites::OnIconMadeAvailable(const GURL& site_url,
                                            bool newly_available) {
-  if (newly_available)
-    observer_->OnIconMadeAvailable(site_url);
+  for (Observer& observer : observer_list_)
+    observer.OnIconMadeAvailable(site_url);
 }
 
 void MostVisitedSites::TopSitesLoaded(TopSites* top_sites) {}
 
 void MostVisitedSites::TopSitesChanged(TopSites* top_sites,
                                        ChangeReason change_reason) {
   if (mv_source_ == NTPTileSource::TOP_SITES) {
     // The displayed tiles are invalidated.
     InitiateTopSitesQuery();
   }
 }
 
 }  // namespace ntp_tiles