Send the list of used and unused resources for precache

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 124 matching lines @@
                  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)) {
     PrecacheFetcher::RecordCompletionStatistics(
-        *unfinished_work,
-        unfinished_work->manifest_size(),
+        *unfinished_work, unfinished_work->top_host_size(),
         unfinished_work->resource_size());
     unfinished_work.reset(new PrecacheUnfinishedWork());
     unfinished_work->set_start_time(base::Time::Now().ToInternalValue());
   }
   unfinished_work_ = std::move(unfinished_work);
   bool needs_top_hosts = unfinished_work_->top_host_size() == 0;
 
   if (IsInExperimentGroup()) {
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
@@ skipping 87 matching lines @@
 
   if (size == 0 || url.is_empty() || !url.SchemeIsHTTPOrHTTPS()) {
     // Ignore empty responses, empty URLs, or URLs that aren't HTTP or HTTPS.
     return;
   }
 
   if (!history_service_)
     return;
 
   history_service_->HostRankIfAvailable(
-      referrer, base::Bind(&PrecacheManager::RecordStatsForFetchInternal,
-                           AsWeakPtr(), url, latency, fetch_time, info, size));
+      referrer,
+      base::Bind(&PrecacheManager::RecordStatsForFetchInternal, AsWeakPtr(),
+                 url, referrer.host(), latency, fetch_time, info, size));
 }
 
 void PrecacheManager::RecordStatsForFetchInternal(
     const GURL& url,
+    const std::string& referrer_host,
     const base::TimeDelta& latency,
     const base::Time& fetch_time,
     const net::HttpResponseInfo& info,
     int64_t size,
     int host_rank) {
   if (is_precaching_) {
     // Assume that precache is responsible for all requests made while
     // precaching is currently in progress.
     // TODO(sclittle): Make PrecacheFetcher explicitly mark precache-motivated
     // fetches, and use that to determine whether or not a fetch was motivated
     // by precaching.
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&PrecacheDatabase::RecordURLPrefetch,
-                   base::Unretained(precache_database_.get()), url, latency,
-                   fetch_time, info, size));
+                   base::Unretained(precache_database_.get()), url,
+                   referrer_host, fetch_time, info.was_cached, size));
   } else {
     bool is_connection_cellular =
         net::NetworkChangeNotifier::IsConnectionCellular(
             net::NetworkChangeNotifier::GetConnectionType());
 
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&PrecacheDatabase::RecordURLNonPrefetch,
                    base::Unretained(precache_database_.get()), url, latency,
                    fetch_time, info, size, host_rank, is_connection_cellular));
@@ skipping 50 matching lines @@
   precache_fetcher_.reset(new PrecacheFetcher(
       content::BrowserContext::GetDefaultStoragePartition(browser_context_)
           ->GetURLRequestContext(),
       GURL(variations::GetVariationParamValue(kPrecacheFieldTrialName,
                                               kConfigURLParam)),
       variations::GetVariationParamValue(kPrecacheFieldTrialName,
                                          kManifestURLPrefixParam),
       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