Start PopularSites fetch from separate function.

components/ntp_tiles/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 "components/ntp_tiles/popular_sites.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 158 matching lines @@
 PopularSites::Site::Site(const Site& other) = default;
 
 PopularSites::Site::~Site() {}
 
 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,
-    bool force_download,
-    const FinishedCallback& callback)
-    : callback_(callback),
-      is_fallback_(false),
+    const base::FilePath& directory)
+    : blocking_runner_(blocking_pool->GetTaskRunnerWithShutdownBehavior(
+          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)),
+      prefs_(prefs),
+      template_url_service_(template_url_service),
+      variations_(variations_service),
+      download_context_(download_context),
       local_path_(directory.empty()
                       ? base::FilePath()
                       : directory.AppendASCII(kPopularSitesLocalFilename)),
-      prefs_(prefs),
-      download_context_(download_context),
-      blocking_runner_(blocking_pool->GetTaskRunnerWithShutdownBehavior(
-          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN)),
-      weak_ptr_factory_(this) {
+      is_fallback_(false),
+      weak_ptr_factory_(this) {}
+
+PopularSites::~PopularSites() {}
+
+void PopularSites::StartFetch(bool force_download,
+                              const FinishedCallback& callback) {
+  DCHECK(!callback_);
+  callback_ = callback;
+
   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 std::string country =
-      GetCountryToUse(prefs, template_url_service, variations_service);
-  const std::string version = GetVersionToUse(prefs);
+      GetCountryToUse(prefs_, template_url_service_, variations_);
+  const std::string version = GetVersionToUse(prefs_);
 
   const GURL override_url =
-      GURL(prefs->GetString(ntp_tiles::prefs::kPopularSitesOverrideURL));
+      GURL(prefs_->GetString(ntp_tiles::prefs::kPopularSitesOverrideURL));
   pending_url_ = override_url.is_valid() ? override_url
                                          : GetPopularSitesURL(country, version);
   const bool url_changed =
       pending_url_.spec() != prefs_->GetString(kPopularSitesURLPref);
 
   // No valid path to save to. Immediately post failure.
   if (local_path_.empty()) {
     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) || url_changed) {
     FetchPopularSites();
     return;
   }
 
   std::unique_ptr<std::string> file_data(new std::string);
   std::string* file_data_ptr = file_data.get();
   base::PostTaskAndReplyWithResult(
       blocking_runner_.get(), FROM_HERE,
       base::Bind(&base::ReadFileToString, local_path_, file_data_ptr),
       base::Bind(&PopularSites::OnReadFileDone, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(file_data))));
 }
 
-PopularSites::~PopularSites() {}
-
 GURL PopularSites::LastURL() const {
   return GURL(prefs_->GetString(kPopularSitesURLPref));
 }
 
 // static
 void PopularSites::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* user_prefs) {
   user_prefs->RegisterStringPref(ntp_tiles::prefs::kPopularSitesOverrideURL,
                                  std::string());
   user_prefs->RegisterStringPref(ntp_tiles::prefs::kPopularSitesOverrideCountry,
@@ skipping 121 matching lines @@
     pending_url_ = GetPopularSitesURL(kPopularSitesDefaultCountryCode,
                                       kPopularSitesDefaultVersion);
     FetchPopularSites();
   } else {
     DLOG(WARNING) << "Download fallback site list failed";
     callback_.Run(false);
   }
 }
 
 }  // namespace ntp_tiles