Report downloaded resources at most once

components/precache/core/precache_fetcher.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/core/precache_fetcher.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 177 matching lines @@
 std::deque<ManifestHostInfo> RetrieveManifestInfo(
     const base::WeakPtr<PrecacheDatabase>& precache_database,
     std::vector<std::pair<std::string, int64_t>> hosts_to_fetch) {
   std::deque<ManifestHostInfo> hosts_info;
   if (!precache_database)
     return hosts_info;
 
   for (const auto& host : hosts_to_fetch) {
     auto referrer_host_info = precache_database->GetReferrerHost(host.first);
     if (referrer_host_info.id != PrecacheReferrerHostEntry::kInvalidId) {
-      std::vector<GURL> used_urls, unused_urls;
-      precache_database->GetURLListForReferrerHost(referrer_host_info.id,
-                                                   &used_urls, &unused_urls);
+      std::vector<GURL> used_urls, downloaded_urls;
+      precache_database->GetURLListForReferrerHost(
+          referrer_host_info.id, &used_urls, &downloaded_urls);
       hosts_info.push_back(
           ManifestHostInfo(referrer_host_info.manifest_id, host.first,
                            host.second, GetResourceURLBase64Hash(used_urls),
-                           GetResourceURLBase64Hash(unused_urls)));
+                           GetResourceURLBase64Hash(downloaded_urls)));
     } else {
       hosts_info.push_back(
           ManifestHostInfo(PrecacheReferrerHostEntry::kInvalidId, host.first,
                            host.second, std::string(), std::string()));
     }
   }
   return hosts_info;
 }
 
 PrecacheQuota RetrieveQuotaInfo(
@@ skipping 419 matching lines @@
         GURL(prefix +
              net::EscapeQueryParamValue(
                  net::EscapeQueryParamValue(manifest.hostname, false), false));
     if (manifest.manifest_id != PrecacheReferrerHostEntry::kInvalidId) {
       manifest.manifest_url = net::AppendOrReplaceQueryParameter(
           manifest.manifest_url, "manifest",
           std::to_string(manifest.manifest_id));
       manifest.manifest_url = net::AppendOrReplaceQueryParameter(
           manifest.manifest_url, "used_resources", manifest.used_url_hash);
       manifest.manifest_url = net::AppendOrReplaceQueryParameter(
-          manifest.manifest_url, "unused_resources", manifest.unused_url_hash);
+          manifest.manifest_url, "d", manifest.downloaded_url_hash);
       DCHECK(manifest.manifest_url.is_valid());
     }
   }
   unfinished_work_->set_num_manifest_urls(top_hosts_to_fetch_.size());
 
   PostTaskAndReplyWithResult(
       db_task_runner_.get(), FROM_HERE,
       base::Bind(&RetrieveQuotaInfo, precache_database_),
       base::Bind(&PrecacheFetcher::OnQuotaInfoRetrieved, AsWeakPtr()));
 }
@@ skipping 11 matching lines @@
         FROM_HERE,
         base::Bind(&PrecacheDatabase::SaveQuota, precache_database_, quota_));
   }
   StartNextFetch();
 }
 
 ManifestHostInfo::ManifestHostInfo(int64_t manifest_id,
                                    const std::string& hostname,
                                    int64_t visits,
                                    const std::string& used_url_hash,
-                                   const std::string& unused_url_hash)
+                                   const std::string& downloaded_url_hash)
     : manifest_id(manifest_id),
       hostname(hostname),
       visits(visits),
       used_url_hash(used_url_hash),
-      unused_url_hash(unused_url_hash) {}
+      downloaded_url_hash(downloaded_url_hash) {}
 
 ManifestHostInfo::~ManifestHostInfo() {}
 
 ManifestHostInfo::ManifestHostInfo(ManifestHostInfo&&) = default;
 
 ManifestHostInfo& ManifestHostInfo::operator=(ManifestHostInfo&&) = default;
 
 ResourceInfo::ResourceInfo(const GURL& url,
                            const std::string& referrer,
                            double weight)
@@ skipping 113 matching lines @@
       remaining = 0;
     quota_.set_remaining(
         used_bytes > quota_.remaining() ? 0U : quota_.remaining() - used_bytes);
     db_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PrecacheDatabase::SaveQuota, precache_database_, quota_));
   }
 }
 
 }  // namespace precache