Remove most of the dependencies on //chrome/...

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/history/top_sites_factory.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/search/suggestions/suggestions_service_factory.h"
-#include "chrome/browser/search_engines/template_url_service_factory.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 "chrome/browser/thumbnails/thumbnail_list_source.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 "content/public/browser/url_data_source.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "url/gurl.h"
 
 using content::BrowserThread;
 using history::TopSites;
 using suggestions::ChromeSuggestion;
 using suggestions::SuggestionsProfile;
-using suggestions::SuggestionsServiceFactory;
+using suggestions::SuggestionsService;
 
 namespace {
 
 // Identifiers for the various tile sources.
 const char kHistogramClientName[] = "client";
 const char kHistogramServerName[] = "server";
 const char kHistogramServerFormat[] = "server%d";
 const char kHistogramPopularName[] = "popular";
 const char kHistogramWhitelistName[] = "whitelist";
 
@@ skipping 117 matching lines @@
 
 MostVisitedSites::Suggestion::Suggestion() : provider_index(-1) {}
 
 MostVisitedSites::Suggestion::~Suggestion() {}
 
 MostVisitedSites::Suggestion::Suggestion(Suggestion&&) = default;
 MostVisitedSites::Suggestion&
 MostVisitedSites::Suggestion::operator=(Suggestion&&) = default;
 
 MostVisitedSites::MostVisitedSites(
-    Profile* profile,
-    variations::VariationsService* variations_service)
-    : profile_(profile), variations_service_(variations_service),
-      top_sites_(TopSitesFactory::GetForProfile(profile)),
-      suggestions_service_(SuggestionsServiceFactory::GetForProfile(profile_)),
-      observer_(nullptr), num_sites_(0),
+    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), download_context_(download_context),
+      top_sites_(top_sites), suggestions_service_(suggestions),
+      is_child_(is_child), 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) {
-  // Register the thumbnails debugging page.
-  content::URLDataSource::Add(profile_, new ThumbnailListSource(profile_));
-
+      recorded_uma_(false),
+      scoped_observer_(this), mv_source_(SUGGESTIONS_SERVICE),

[Marc Treib, 2016/05/02 11:30:40]

nit: I think we can save a line here.

[sfiera, 2016/05/03 13:26:12]

Done.

+      weak_ptr_factory_(this) {
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile_);
   supervised_user_service->AddObserver(this);
 }
 
 MostVisitedSites::~MostVisitedSites() {
   SupervisedUserService* supervised_user_service =
       SupervisedUserServiceFactory::GetForProfile(profile_);
   supervised_user_service->RemoveObserver(this);
 }
 
 void MostVisitedSites::SetMostVisitedURLsObserver(
       MostVisitedSites::Observer* observer, int num_sites) {
   DCHECK(observer);
   observer_ = observer;
   num_sites_ = num_sites;
 
   if (ShouldShowPopularSites() &&
-      NeedPopularSites(profile_->GetPrefs(), num_sites_)) {
+      NeedPopularSites(prefs_, num_sites_)) {
     popular_sites_.reset(new PopularSites(
-        profile_->GetPrefs(),
-        TemplateURLServiceFactory::GetForProfile(profile_),
+        prefs_,
+        template_url_service_,
         variations_service_,
-        profile_->GetRequestContext(),
+        download_context_,
         GetPopularSitesCountry(),
         GetPopularSitesVersion(),
         false,
         base::Bind(&MostVisitedSites::OnPopularSitesAvailable,
                    base::Unretained(this))));
   } else {
     received_popular_sites_ = true;
   }
 
   if (top_sites_) {
@@ skipping 285 matching lines @@
   }
 
   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 (profile_->IsChild())
+  if (is_child_)
     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 102 matching lines @@
   // Insert leftover popular suggestions.
   InsertAllSuggestions(filled_so_far, new_popular_suggestions,
                        popular_suggestions, &merged_suggestions);
   return merged_suggestions;
 }
 
 void MostVisitedSites::GetPreviousNTPSites(
     size_t num_tiles,
     std::vector<std::string>* old_sites_url,
     std::vector<bool>* old_sites_is_personal) const {
-  const PrefService* prefs = profile_->GetPrefs();
-  const base::ListValue* url_list = prefs->GetList(
+  const base::ListValue* url_list = prefs_->GetList(
       ntp_tiles::prefs::kNTPSuggestionsURL);
   const base::ListValue* source_list =
-      prefs->GetList(ntp_tiles::prefs::kNTPSuggestionsIsPersonal);
+      prefs_->GetList(ntp_tiles::prefs::kNTPSuggestionsIsPersonal);
   DCHECK_EQ(url_list->GetSize(), source_list->GetSize());
   if (url_list->GetSize() < num_tiles)
     num_tiles = url_list->GetSize();
   if (num_tiles == 0) {
     // No fallback required as Personal suggestions take precedence anyway.
     return;
   }
   old_sites_url->reserve(num_tiles);
   old_sites_is_personal->reserve(num_tiles);
   for (size_t i = 0; i < num_tiles; ++i) {
     std::string url_string;
     bool success = url_list->GetString(i, &url_string);
     DCHECK(success);
     old_sites_url->push_back(url_string);
     bool is_personal;
     success = source_list->GetBoolean(i, &is_personal);
     DCHECK(success);
     old_sites_is_personal->push_back(is_personal);
   }
 }
 
 void MostVisitedSites::SaveCurrentNTPSites() {
   base::ListValue url_list;
   base::ListValue source_list;
   for (const auto& suggestion : current_suggestions_) {
     url_list.AppendString(suggestion.url.spec());
     source_list.AppendBoolean(suggestion.source != MostVisitedSites::POPULAR);
   }
-  PrefService* prefs = profile_->GetPrefs();
-  prefs->Set(ntp_tiles::prefs::kNTPSuggestionsIsPersonal, source_list);
-  prefs->Set(ntp_tiles::prefs::kNTPSuggestionsURL, url_list);
+  prefs_->Set(ntp_tiles::prefs::kNTPSuggestionsIsPersonal, source_list);
+  prefs_->Set(ntp_tiles::prefs::kNTPSuggestionsURL, url_list);
 }
 
 // static
 std::vector<size_t> MostVisitedSites::InsertMatchingSuggestions(
     MostVisitedSites::SuggestionsPtrVector* src_suggestions,
     MostVisitedSites::SuggestionsPtrVector* dst_suggestions,
     const std::vector<std::string>& match_urls,
     const std::vector<std::string>& match_hosts) {
   std::vector<size_t> unmatched_suggestions;
   size_t num_src_suggestions = src_suggestions->size();
@@ skipping 85 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();
   }
 }