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(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_thread,
+    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(std::move(ui_thread),
+                   std::move(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(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_thread,
+    scoped_refptr<base::SequencedWorkerPool> blocking_pool,
+    PrefService* prefs,
+    net::URLRequestContextGetter* download_context,
+    const base::FilePath& directory,
+    const GURL& url,
+    const FinishedCallback& callback)
+    : PopularSites(std::move(ui_thread),
+                   std::move(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(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_thread,
+    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)),
+      ui_thread_(std::move(ui_thread)),
+      blocking_pool_(std::move(blocking_pool)),
       weak_ptr_factory_(this) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(ui_thread_->BelongsToCurrentThread());
   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));
+    ui_thread_->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_pool_
+          ->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
+          .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,
-      base::Bind(&base::ImportantFileWriter::WriteFileAtomically, local_path_,
-                 valid_minified_json),
+      blocking_pool_
+          ->GetTaskRunnerWithShutdownBehavior(
+              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
+          .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_pool_
+          ->GetTaskRunnerWithShutdownBehavior(

[blundell, 2016/05/24 18:01:45]

This is a behavioral change, as you're no longer supplying the same task runner
in all of these calls (this call just returns *a* TaskRunner from the pool). I
would just preserve the |runner_| variable.

[sfiera, 2016/05/24 18:18:59]

Done.

(In practice I think it should end up the same, since we never run more than one
task from this file at once, but there's no reason to change it to use different
runners either)

+              base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)
+          .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);
   }
 }