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"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "chrome/browser/supervised_user/supervised_user_service.h"
-#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
-#include "chrome/browser/supervised_user/supervised_user_url_filter.h"
 #include "components/history/core/browser/top_sites.h"
 #include "components/ntp_tiles/pref_names.h"
 #include "components/ntp_tiles/switches.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "url/gurl.h"
@@ skipping 139 matching lines @@
 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),
+    MostVisitedSitesSupervisor* 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),
+      suggestions_service_(suggestions), supervisor_(supervisor),
       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);
+  supervisor_->SetObserver(this);
 }
 
 MostVisitedSites::~MostVisitedSites() {
-  SupervisedUserService* supervised_user_service =
-      SupervisedUserServiceFactory::GetForProfile(profile_);
-  supervised_user_service->RemoveObserver(this);
+  supervisor_->SetObserver(nullptr);
 }
 
 void MostVisitedSites::SetMostVisitedURLsObserver(
       MostVisitedSites::Observer* observer, int num_sites) {
   DCHECK(observer);
   observer_ = observer;
   num_sites_ = num_sites;
 
   if (ShouldShowPopularSites() &&
       NeedPopularSites(prefs_, num_sites_)) {
@@ skipping 133 matching lines @@
       "NewTabPage.MostVisited.%s",
       GetSourceHistogramName(current_suggestions_[index]).c_str());
   LogHistogramEvent(histogram, index, num_sites_);
 
   histogram = base::StringPrintf(
       "NewTabPage.TileTypeClicked.%s",
       GetSourceHistogramName(current_suggestions_[index]).c_str());
   LogHistogramEvent(histogram, tile_type, NUM_TILE_TYPES);
 }
 
-void MostVisitedSites::OnURLFilterChanged() {
+void MostVisitedSites::OnBlockedSitesChanged() {
   BuildCurrentSuggestions();
 }
 
 // static
 void MostVisitedSites::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(ntp_tiles::prefs::kNTPSuggestionsURL);
   registry->RegisterListPref(ntp_tiles::prefs::kNTPSuggestionsIsPersonal);
 }
 
 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) {
-  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();
-
   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.
     }
-    if (url_filter->GetFilteringBehaviorForURL(visited.url) ==
-        SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
+    if (supervisor_->IsBlocked(visited.url)) {

[Marc Treib, 2016/05/09 08:22:48]

nit: no braces required

[sfiera, 2016/05/09 09:33:35]

Done, but the braces weren't mine.

[Marc Treib, 2016/05/09 09:55:12]

Your change made the condition fit on one line, so made the braces unnecessary
:)
(The rule is roughly: No braces if both the condition and the body fit on one
line each. To be fair, it's not followed everywhere in Chromium, and the more
general rule is "do what the code around you does".)

[sfiera, 2016/05/09 10:26:17]

I guess I should have been running git cl format anyway, but I've done so now
and will try to do so in the future because I don't want to remember rules like
that :)

[Marc Treib, 2016/05/09 10:30:24]

That's generally a good idea. It won't add or remove braces though.

       continue;
     }
 
     std::unique_ptr<Suggestion> suggestion(new Suggestion());
     suggestion->title = visited.title;
     suggestion->url = visited.url;
     suggestion->source = TOP_SITES;
     suggestion->whitelist_icon_path = GetWhitelistLargeIconPath(visited.url);
 
     suggestions.push_back(std::move(suggestion));
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = TOP_SITES;
   SaveNewNTPSuggestions(&suggestions);
   NotifyMostVisitedURLsObserver();
 }
 
 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) {
     InitiateTopSitesQuery();
     return;
   }
   if (num_sites_ < num_tiles)
     num_tiles = num_sites_;
 
-  SupervisedUserURLFilter* url_filter =
-      SupervisedUserServiceFactory::GetForProfile(profile_)
-          ->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) {
+    if (supervisor_->IsBlocked(GURL(suggestion.url()))) {

[Marc Treib, 2016/05/09 08:22:48]

Also here

[sfiera, 2016/05/09 09:33:35]

Also here.

       continue;
     }
 
     std::unique_ptr<Suggestion> generated_suggestion(new Suggestion());
     generated_suggestion->title = base::UTF8ToUTF16(suggestion.title());
     generated_suggestion->url = GURL(suggestion.url());
     generated_suggestion->source = SUGGESTIONS_SERVICE;
     generated_suggestion->whitelist_icon_path = GetWhitelistLargeIconPath(
         GURL(suggestion.url()));
     if (suggestion.providers_size() > 0)
@@ skipping 10 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();
-
   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()) ==
-        SupervisedUserURLFilter::FilteringBehavior::BLOCK) {
+    if (supervisor_->IsBlocked(whitelist.entry_point)) {

[Marc Treib, 2016/05/09 08:22:48]

Aaand again :)

[sfiera, 2016/05/09 09:33:35]

Not mine either.

       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
 MostVisitedSites::CreatePopularSitesSuggestions(
     const MostVisitedSites::SuggestionsPtrVector& personal_suggestions,
     const MostVisitedSites::SuggestionsPtrVector& whitelist_suggestions) {
   // For child accounts popular sites suggestions will not be added.
-  if (is_child_profile_)
+  if (supervisor_->IsChildProfile())
     return MostVisitedSites::SuggestionsPtrVector();
 
   size_t num_suggestions =
       personal_suggestions.size() + whitelist_suggestions.size();
   DCHECK_LE(num_suggestions, static_cast<size_t>(num_sites_));
 
   // Collect non-blacklisted popular suggestions, skipping those already present
   // in the personal suggestions.
   size_t num_popular_sites_suggestions = num_sites_ - num_suggestions;
   MostVisitedSites::SuggestionsPtrVector popular_sites_suggestions;
@@ skipping 241 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();
   }
 }