Precache: Optionally rank resources-to-precache globally.

components/precache/content/precache_manager.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 "components/precache/content/precache_manager.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 18 matching lines @@
 
 using content::BrowserThread;
 
 namespace {
 
 const char kPrecacheFieldTrialName[] = "Precache";
 const char kPrecacheFieldTrialEnabledGroup[] = "Enabled";
 const char kPrecacheFieldTrialControlGroup[] = "Control";
 const char kConfigURLParam[] = "config_url";
 const char kManifestURLPrefixParam[] = "manifest_url_prefix";
+const char kGlobalRankingParam[] = "global_ranking";
 const size_t kNumTopHosts = 100;
 
 }  // namespace
 
 namespace precache {
 
 size_t NumTopHosts() {
   return kNumTopHosts;
 }
 
@@ skipping 82 matching lines @@
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::DB,
       FROM_HERE,
       base::Bind(&PrecacheDatabase::GetUnfinishedWork,
                  base::Unretained(precache_database_.get())),
       base::Bind(&PrecacheManager::OnGetUnfinishedWorkDone, AsWeakPtr()));
 }
 
 void PrecacheManager::OnGetUnfinishedWorkDone(
     std::unique_ptr<PrecacheUnfinishedWork> unfinished_work) {
-  if (!unfinished_work->has_start_time() ||
-      base::Time::Now() - base::Time::FromInternalValue(
-      unfinished_work->start_time()) > base::TimeDelta::FromHours(6)) {
+  if (!unfinished_work->has_start_time())
+    unfinished_work->set_start_time(base::Time::Now().ToInternalValue());
+  if (base::Time::Now() -
+          base::Time::FromInternalValue(unfinished_work->start_time()) >
+      base::TimeDelta::FromHours(6)) {
     PrecacheFetcher::RecordCompletionStatistics(
         *unfinished_work, unfinished_work->top_host_size(),
         unfinished_work->resource_size());
-    unfinished_work.reset(new PrecacheUnfinishedWork());
+    unfinished_work.reset(new PrecacheUnfinishedWork);
     unfinished_work->set_start_time(base::Time::Now().ToInternalValue());

[bengr, 2016/10/14 21:52:19]

Why is start time being set here too?

[twifkak, 2016/10/14 22:41:45]

The first one is what happens on a fresh precache run -- i.e. the previous one
succeeded and there is no unfinished work.

The second one is what happens if a precache takes longer than 6 hours to
complete (via pause/resume), and essentially gives up and starts over.

I've simplified the code to eliminate the duplication.

   }
   unfinished_work_ = std::move(unfinished_work);
   bool needs_top_hosts = unfinished_work_->top_host_size() == 0;
 
   if (IsInExperimentGroup()) {
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&PrecacheDatabase::DeleteExpiredPrecacheHistory,
                    base::Unretained(precache_database_.get()),
                    base::Time::Now()));
@@ skipping 154 matching lines @@
     precache_completion_callback_.Reset();
   }
 
   is_precaching_ = false;
 }
 
 void PrecacheManager::OnHostsReceived(
     const history::TopHostsList& host_counts) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  std::vector<std::string> hosts;
-  for (const auto& host_count : host_counts)
-    unfinished_work_->add_top_host()->set_hostname(host_count.first);
+  for (const auto& host_count : host_counts) {
+    TopHost* top_host = unfinished_work_->add_top_host();
+    top_host->set_hostname(host_count.first);
+    top_host->set_visits(host_count.second);
+  }
   InitializeAndStartFetcher();
 }
 
 void PrecacheManager::InitializeAndStartFetcher() {
   if (!is_precaching_) {
     // Don't start precaching if it was canceled while waiting for the list of
     // hosts.
     return;
   }
   // Start precaching.
   precache_fetcher_.reset(new PrecacheFetcher(
       content::BrowserContext::GetDefaultStoragePartition(browser_context_)
           ->GetURLRequestContext(),
       GURL(variations::GetVariationParamValue(kPrecacheFieldTrialName,
                                               kConfigURLParam)),
       variations::GetVariationParamValue(kPrecacheFieldTrialName,
                                          kManifestURLPrefixParam),
+      !variations::GetVariationParamValue(kPrecacheFieldTrialName,
+                                          kGlobalRankingParam)
+           .empty(),
       std::move(unfinished_work_),
       metrics::HashName(
           base::FieldTrialList::FindFullName(kPrecacheFieldTrialName)),
       precache_database_->GetWeakPtr(),
       content::BrowserThread::GetTaskRunnerForThread(
           content::BrowserThread::DB),
       this));
   precache_fetcher_->Start();
 }
 
 void PrecacheManager::OnHostsReceivedThenDone(
     const history::TopHostsList& host_counts) {
   OnDone();
 }
 
 }  // namespace precache