Remove NTP dependency on //content/...

chrome/browser/android/ntp/popular_sites.cc

 // Copyright 2015 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/popular_sites.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 11 matching lines @@
 #include "components/google/core/browser/google_util.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/safe_json/json_sanitizer.h"
 #include "components/search_engines/search_engine_type.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/variations/service/variations_service.h"
-#include "content/public/browser/browser_thread.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 
-using content::BrowserThread;
 using net::URLFetcher;
 using variations::VariationsService;
 
 namespace {
 
 const char kPopularSitesURLFormat[] =
     "https://www.gstatic.com/chrome/ntp/suggested_sites_%s_%s.json";
 const char kPopularSitesDefaultCountryCode[] = "DEFAULT";
 const char kPopularSitesDefaultVersion[] = "5";
 const char kPopularSitesLocalFilename[] = "suggested_sites.json";
@@ skipping 132 matching lines @@
     : title(title),
       url(url),
       favicon_url(favicon_url),
       large_icon_url(large_icon_url),
       thumbnail_url(thumbnail_url) {}
 
 PopularSites::Site::Site(const Site& other) = default;
 
 PopularSites::Site::~Site() {}
 
-PopularSites::PopularSites(PrefService* prefs,
-                           const TemplateURLService* template_url_service,
-                           VariationsService* variations_service,
-                           net::URLRequestContextGetter* download_context,
-                           const base::FilePath& directory,
-                           const std::string& variation_param_country,
-                           const std::string& variation_param_version,
-                           bool force_download,
-                           const FinishedCallback& callback)
-    : PopularSites(prefs,
+PopularSites::PopularSites(
+    const scoped_refptr<base::SequencedWorkerPool>& blocking_pool,
+    PrefService* prefs,
+    const TemplateURLService* template_url_service,
+    VariationsService* variations_service,
+    net::URLRequestContextGetter* download_context,
+    const base::FilePath& directory,
+    const std::string& variation_param_country,
+    const std::string& variation_param_version,
+    bool force_download,
+    const FinishedCallback& callback)
+    : PopularSites(blocking_pool,
+                   prefs,
                    download_context,
                    directory,
                    GetCountryToUse(prefs,
                                    template_url_service,
                                    variations_service,
                                    variation_param_country),
                    GetVersionToUse(prefs, variation_param_version),
                    GURL(),
                    force_download,
                    callback) {}
 
-PopularSites::PopularSites(PrefService* prefs,
-                           net::URLRequestContextGetter* download_context,
-                           const base::FilePath& directory,
-                           const GURL& url,
-                           const FinishedCallback& callback)
-    : PopularSites(prefs,
+PopularSites::PopularSites(
+    const scoped_refptr<base::SequencedWorkerPool>& blocking_pool,
+    PrefService* prefs,
+    net::URLRequestContextGetter* download_context,
+    const base::FilePath& directory,
+    const GURL& url,
+    const FinishedCallback& callback)
+    : PopularSites(blocking_pool,
+                   prefs,
                    download_context,
                    directory,
                    std::string(),
                    std::string(),
                    url,
                    true,
                    callback) {}
 
 PopularSites::~PopularSites() {}
 
@@ skipping 11 matching lines @@
   user_prefs->RegisterStringPref(ntp_tiles::prefs::kPopularSitesOverrideCountry,
                                  std::string());
   user_prefs->RegisterStringPref(ntp_tiles::prefs::kPopularSitesOverrideVersion,
                                  std::string());
 
   user_prefs->RegisterInt64Pref(kPopularSitesLastDownloadPref, 0);
   user_prefs->RegisterStringPref(kPopularSitesCountryPref, std::string());
   user_prefs->RegisterStringPref(kPopularSitesVersionPref, std::string());
 }
 
-PopularSites::PopularSites(PrefService* prefs,
-                           net::URLRequestContextGetter* download_context,
-                           const base::FilePath& directory,
-                           const std::string& country,
-                           const std::string& version,
-                           const GURL& override_url,
-                           bool force_download,
-                           const FinishedCallback& callback)
+PopularSites::PopularSites(
+    const scoped_refptr<base::SequencedWorkerPool>& blocking_pool,
+    PrefService* prefs,
+    net::URLRequestContextGetter* download_context,
+    const base::FilePath& directory,
+    const std::string& country,
+    const std::string& version,
+    const GURL& override_url,
+    bool force_download,
+    const FinishedCallback& callback)
     : callback_(callback),
       is_fallback_(false),
       pending_country_(country),
       pending_version_(version),
       local_path_(directory.empty()
                       ? base::FilePath()
                       : directory.AppendASCII(kPopularSitesLocalFilename)),
       prefs_(prefs),
       download_context_(download_context),
-      runner_(
-          BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
-              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)),
+      blocking_runner_(blocking_pool->GetTaskRunnerWithShutdownBehavior(
+          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)),
       weak_ptr_factory_(this) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const base::Time last_download_time = base::Time::FromInternalValue(
       prefs_->GetInt64(kPopularSitesLastDownloadPref));
   const base::TimeDelta time_since_last_download =
       base::Time::Now() - last_download_time;
   const base::TimeDelta redownload_interval =
       base::TimeDelta::FromHours(kPopularSitesRedownloadIntervalHours);
   const bool download_time_is_future = base::Time::Now() < last_download_time;
   const bool country_changed = GetCountry() != pending_country_;
   const bool version_changed = GetVersion() != pending_version_;
 
   const GURL url =
       override_url.is_valid() ? override_url : GetPopularSitesURL();
 
   // No valid path to save to. Immediately post failure.
   if (local_path_.empty()) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(callback_, false));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                  base::Bind(callback_, false));
     return;
   }
 
   // Download forced, or we need to download a new file.
   if (force_download || download_time_is_future ||
       (time_since_last_download > redownload_interval) || country_changed ||
       version_changed) {
     FetchPopularSites(url);
     return;
   }
 
   std::unique_ptr<std::string> file_data(new std::string);
   std::string* file_data_ptr = file_data.get();
   base::PostTaskAndReplyWithResult(
-      runner_.get(), FROM_HERE,
+      blocking_runner_.get(), FROM_HERE,
       base::Bind(&base::ReadFileToString, local_path_, file_data_ptr),
       base::Bind(&PopularSites::OnReadFileDone, weak_ptr_factory_.GetWeakPtr(),
                  url, base::Passed(std::move(file_data))));
 }
 
 GURL PopularSites::GetPopularSitesURL() const {
   return GURL(base::StringPrintf(kPopularSitesURLFormat,
                                  pending_country_.c_str(),
                                  pending_version_.c_str()));
 }
@@ skipping 32 matching lines @@
 
   safe_json::JsonSanitizer::Sanitize(
       sketchy_json, base::Bind(&PopularSites::OnJsonSanitized,
                                weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&PopularSites::OnJsonSanitizationFailed,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PopularSites::OnJsonSanitized(const std::string& valid_minified_json) {
   base::PostTaskAndReplyWithResult(
-      runner_.get(), FROM_HERE,
+      blocking_runner_.get(), FROM_HERE,
       base::Bind(&base::ImportantFileWriter::WriteFileAtomically, local_path_,
                  valid_minified_json),
       base::Bind(&PopularSites::OnFileWriteDone, weak_ptr_factory_.GetWeakPtr(),
                  valid_minified_json));
 }
 
 void PopularSites::OnJsonSanitizationFailed(const std::string& error_message) {
   DLOG(WARNING) << "JSON sanitization failed: " << error_message;
   OnDownloadFailed();
 }
 
 void PopularSites::OnFileWriteDone(const std::string& json, bool success) {
   if (success) {
     prefs_->SetInt64(kPopularSitesLastDownloadPref,
                      base::Time::Now().ToInternalValue());
     prefs_->SetString(kPopularSitesCountryPref, pending_country_);
     prefs_->SetString(kPopularSitesVersionPref, pending_version_);
     ParseSiteList(json);
   } else {
     DLOG(WARNING) << "Could not write file to "
                   << local_path_.LossyDisplayName();
     OnDownloadFailed();
   }
 }
 
 void PopularSites::ParseSiteList(const std::string& json) {
   base::PostTaskAndReplyWithResult(
-      runner_.get(), FROM_HERE, base::Bind(&ParseJson, json),
+      blocking_runner_.get(), FROM_HERE, base::Bind(&ParseJson, json),
       base::Bind(&PopularSites::OnJsonParsed, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void PopularSites::OnJsonParsed(std::unique_ptr<std::vector<Site>> sites) {
   if (sites)
     sites_.swap(*sites);
   else
     sites_.clear();
   callback_.Run(!!sites);
 }
 
 void PopularSites::OnDownloadFailed() {
   if (!is_fallback_) {
     DLOG(WARNING) << "Download country site list failed";
     is_fallback_ = true;
     pending_country_ = kPopularSitesDefaultCountryCode;
     pending_version_ = kPopularSitesDefaultVersion;
     FetchPopularSites(GetPopularSitesURL());
   } else {
     DLOG(WARNING) << "Download fallback site list failed";
     callback_.Run(false);
   }
 }