Remove MostVisitedSites => SupervisedUserService dep.

chrome/browser/android/ntp/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 "chrome/browser/android/ntp/most_visited_sites.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 145 matching lines @@
                  ? base::StringPrintf(kHistogramServerFormat,
                                       suggestion.provider_index)
                  : kHistogramServerName;
   }
   NOTREACHED();
   return std::string();
 }
 
 }  // namespace
 
+SupervisedUserServiceSupervisor::SupervisedUserServiceSupervisor(Profile* profile)
+    : profile_(profile) {}
+
+void SupervisedUserServiceSupervisor::AddObserver(Observer* observer) {
+  DCHECK(observers_.find(observer) == observers_.end());
+  SupervisedUserService* supervised_user_service =
+    SupervisedUserServiceFactory::GetForProfile(profile_);
+  std::unique_ptr<SUSObserver> ptr(
+      new SUSObserver(supervised_user_service, observer));
+  observers_.emplace(observer, std::move(ptr));
+}
+
+void SupervisedUserServiceSupervisor::RemoveObserver(Observer* observer) {
+  auto it = observers_.find(observer);
+  DCHECK(it != observers_.end());
+  observers_.erase(it);
+}
+
+SupervisedUserURLFilter* SupervisedUserServiceSupervisor::GetURLFilterForUIThread() {
+  SupervisedUserService* supervised_user_service =
+    SupervisedUserServiceFactory::GetForProfile(profile_);
+  return supervised_user_service->GetURLFilterForUIThread();
+}
+
+std::vector<Supervisor::Whitelist>
+SupervisedUserServiceSupervisor::whitelists() const {
+  std::vector<Supervisor::Whitelist> results;
+  SupervisedUserService* supervised_user_service =
+    SupervisedUserServiceFactory::GetForProfile(profile_);
+  for (const auto& whitelist : supervised_user_service->whitelists()) {
+    results.emplace_back(Whitelist{
+        whitelist->title(),
+        whitelist->entry_point(),
+        whitelist->large_icon_path(),
+    });
+  }
+  return results;
+}
+
 MostVisitedSites::Suggestion::Suggestion() : provider_index(-1) {}
 
 MostVisitedSites::Suggestion::~Suggestion() {}
 
 MostVisitedSites::Suggestion::Suggestion(Suggestion&&) = default;
 MostVisitedSites::Suggestion&
 MostVisitedSites::Suggestion::operator=(Suggestion&&) = default;
 
 MostVisitedSites::MostVisitedSites(
     PrefService* prefs,
     const TemplateURLService* template_url_service,
     variations::VariationsService* variations_service,
     net::URLRequestContextGetter* download_context,
     scoped_refptr<history::TopSites> top_sites,
     SuggestionsService* suggestions,
     bool is_child_profile,
-    Profile* profile)
-    : profile_(profile), prefs_(prefs),
-      template_url_service_(template_url_service),
+    Supervisor* supervisor)
+    : prefs_(prefs), template_url_service_(template_url_service),
       variations_service_(variations_service),
       download_context_(download_context), top_sites_(top_sites),
-      suggestions_service_(suggestions), is_child_profile_(is_child_profile),
-      observer_(nullptr), num_sites_(0), received_most_visited_sites_(false),
-      received_popular_sites_(false), recorded_uma_(false),
-      scoped_observer_(this), mv_source_(SUGGESTIONS_SERVICE),
-      weak_ptr_factory_(this) {
-  SupervisedUserService* supervised_user_service =
-      SupervisedUserServiceFactory::GetForProfile(profile_);
-  supervised_user_service->AddObserver(this);
+      suggestions_service_(suggestions), supervisor_(supervisor),
+      is_child_profile_(is_child_profile), observer_(nullptr), num_sites_(0),
+      received_most_visited_sites_(false), received_popular_sites_(false),
+      recorded_uma_(false), scoped_observer_(this),
+      mv_source_(SUGGESTIONS_SERVICE), weak_ptr_factory_(this) {
+  supervisor_->AddObserver(this);
 }
 
 MostVisitedSites::~MostVisitedSites() {
-  SupervisedUserService* supervised_user_service =
-      SupervisedUserServiceFactory::GetForProfile(profile_);
-  supervised_user_service->RemoveObserver(this);
+  supervisor_->RemoveObserver(this);
 }
 
 void MostVisitedSites::SetMostVisitedURLsObserver(
       MostVisitedSites::Observer* observer, int num_sites) {
   DCHECK(observer);
   observer_ = observer;
   num_sites_ = num_sites;
 
   if (ShouldShowPopularSites() &&
       NeedPopularSites(prefs_, num_sites_)) {
@@ skipping 162 matching lines @@
   if (!top_sites_)
     return;
 
   top_sites_->GetMostVisitedURLs(
       base::Bind(&MostVisitedSites::OnMostVisitedURLsAvailable,
                  weak_ptr_factory_.GetWeakPtr()),
       false);
 }
 
 base::FilePath MostVisitedSites::GetWhitelistLargeIconPath(const GURL& url) {
-  SupervisedUserService* supervised_user_service =
-      SupervisedUserServiceFactory::GetForProfile(profile_);
-
-  for (const auto& whitelist : supervised_user_service->whitelists()) {
-    if (AreURLsEquivalent(whitelist->entry_point(), url))
-      return whitelist->large_icon_path();
+  for (const auto& whitelist : supervisor_->whitelists()) {
+    if (AreURLsEquivalent(whitelist.entry_point, url))
+      return whitelist.large_icon_path;
   }
   return base::FilePath();
 }
 
 void MostVisitedSites::OnMostVisitedURLsAvailable(
     const history::MostVisitedURLList& visited_list) {
-  SupervisedUserURLFilter* url_filter =
-      SupervisedUserServiceFactory::GetForProfile(profile_)
-          ->GetURLFilterForUIThread();
+  SupervisedUserURLFilter* url_filter = supervisor_->GetURLFilterForUIThread();
 
   MostVisitedSites::SuggestionsPtrVector suggestions;
   size_t num_tiles =
       std::min(visited_list.size(), static_cast<size_t>(num_sites_));
   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.
     }
@@ skipping 21 matching lines @@
     const SuggestionsProfile& suggestions_profile) {
   int num_tiles = suggestions_profile.suggestions_size();
   // With no server suggestions, fall back to local TopSites.
   if (num_tiles == 0) {
     InitiateTopSitesQuery();
     return;
   }
   if (num_sites_ < num_tiles)
     num_tiles = num_sites_;
 
-  SupervisedUserURLFilter* url_filter =
-      SupervisedUserServiceFactory::GetForProfile(profile_)
-          ->GetURLFilterForUIThread();
+  SupervisedUserURLFilter* url_filter = supervisor_->GetURLFilterForUIThread();
   MostVisitedSites::SuggestionsPtrVector suggestions;
   for (int i = 0; i < num_tiles; ++i) {
     const ChromeSuggestion& suggestion = suggestions_profile.suggestions(i);
     if (url_filter->GetFilteringBehaviorForURL(GURL(suggestion.url())) ==
         SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
       continue;
     }
 
     std::unique_ptr<Suggestion> generated_suggestion(new Suggestion());
     generated_suggestion->title = base::UTF8ToUTF16(suggestion.title());
@@ skipping 15 matching lines @@
 
 MostVisitedSites::SuggestionsPtrVector
 MostVisitedSites::CreateWhitelistEntryPointSuggestions(
     const MostVisitedSites::SuggestionsPtrVector& personal_suggestions) {
   size_t num_personal_suggestions = personal_suggestions.size();
   DCHECK_LE(num_personal_suggestions, static_cast<size_t>(num_sites_));
 
   size_t num_whitelist_suggestions = num_sites_ - num_personal_suggestions;
   MostVisitedSites::SuggestionsPtrVector whitelist_suggestions;
 
-  SupervisedUserService* supervised_user_service =
-      SupervisedUserServiceFactory::GetForProfile(profile_);
   SupervisedUserURLFilter* url_filter =
-      supervised_user_service->GetURLFilterForUIThread();
+      supervisor_->GetURLFilterForUIThread();
 
   std::set<std::string> personal_hosts;
   for (const auto& suggestion : personal_suggestions)
     personal_hosts.insert(suggestion->url.host());
 
-  for (const auto& whitelist : supervised_user_service->whitelists()) {
+  for (const auto& whitelist : supervisor_->whitelists()) {
     // Skip blacklisted sites.
-    if (top_sites_ && 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()) !=
+    if (personal_hosts.find(whitelist.entry_point.host()) !=
         personal_hosts.end())
       continue;
 
     // Skip whitelist entry points that are manually blocked.
-    if (url_filter->GetFilteringBehaviorForURL(whitelist->entry_point()) ==
+    if (url_filter->GetFilteringBehaviorForURL(whitelist.entry_point) ==
         SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
       continue;
     }
 
     std::unique_ptr<Suggestion> suggestion(new Suggestion());
-    suggestion->title = whitelist->title();
-    suggestion->url = whitelist->entry_point();
+    suggestion->title = whitelist.title;
+    suggestion->url = whitelist.entry_point;
     suggestion->source = WHITELIST;
-    suggestion->whitelist_icon_path = whitelist->large_icon_path();
+    suggestion->whitelist_icon_path = whitelist.large_icon_path;
 
     whitelist_suggestions.push_back(std::move(suggestion));
     if (whitelist_suggestions.size() >= num_whitelist_suggestions)
       break;
   }
 
   return whitelist_suggestions;
 }
 
 MostVisitedSites::SuggestionsPtrVector
@@ skipping 256 matching lines @@
 
 void MostVisitedSites::TopSitesLoaded(TopSites* top_sites) {}
 
 void MostVisitedSites::TopSitesChanged(TopSites* top_sites,
                                        ChangeReason change_reason) {
   if (mv_source_ == TOP_SITES) {
     // The displayed suggestions are invalidated.
     InitiateTopSitesQuery();
   }
 }