Report downloaded resources at most once

components/precache/core/precache_database.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_database.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 115 matching lines @@
 
 PrecacheReferrerHostEntry PrecacheDatabase::GetReferrerHost(
     const std::string& referrer_host) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return precache_referrer_host_table_.GetReferrerHost(referrer_host);
 }
 
 void PrecacheDatabase::GetURLListForReferrerHost(
     int64_t referrer_host_id,
     std::vector<GURL>* used_urls,
-    std::vector<GURL>* unused_urls) {
+    std::vector<GURL>* downloaded_urls) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(PrecacheReferrerHostEntry::kInvalidId, referrer_host_id);
 
   // Flush any pending writes to the URL and referrer host tables.
   Flush();
 
   precache_url_table_.GetURLListForReferrerHost(referrer_host_id, used_urls,
-                                                unused_urls);
+                                                downloaded_urls);
+  precache_url_table_.SetDownloadReported(referrer_host_id);
 }
 
 void PrecacheDatabase::RecordURLPrefetchMetrics(
     const net::HttpResponseInfo& info,
     const base::TimeDelta& latency) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   UMA_HISTOGRAM_TIMES("Precache.Latency.Prefetch", latency);
 
   DCHECK(info.headers) << "The headers are required to get the freshness.";
@@ skipping 34 matching lines @@
   }
 
   // Use the URL table to keep track of URLs. URLs that are fetched via network
   // or already in the cache due to prior precaching are recorded as
   // precache-motivated. URLs that came from the cache and not recorded as
   // precached previously, were already in the cache because of user browsing.
   // Therefore, this precache will not be considered as precache-motivated,
   // since it had no significant effect (besides a possible revalidation and a
   // change in the cache LRU priority). If a row for the URL already exists,
   // then the timestamp is updated.
+  const PrecacheURLInfo info = precache_url_table_.GetURLInfo(url);
   buffered_writes_.push_back(base::Bind(
       &PrecacheDatabase::RecordURLPrefetchInternal, GetWeakPtr(), url,
-      referrer_host,
-      !was_cached || precache_url_table_.GetURLInfo(url).is_precached,
-      fetch_time));
+      referrer_host, !was_cached || info.is_precached, fetch_time,
+      // Reset to 0 only if is_precached && !was_cached.
+      (!info.is_precached || was_cached) && info.is_download_reported));

[twifkak, 2016/12/20 22:48:09]

Perhaps extract this logic to be more readable:

bool is_download_reported = info.is_download_reported;
// Reset to false if a new prefetch occurred:
if (info.is_precached && !was_cached)
  is_download_reported = false;

[jamartin, 2016/12/20 23:14:07]

Done.

   buffered_urls_.insert(url.spec());
   MaybePostFlush();
 }
 
 void PrecacheDatabase::RecordURLPrefetchInternal(
     const GURL& url,
     const std::string& referrer_host,
     bool is_precached,
-    const base::Time& fetch_time) {
+    const base::Time& fetch_time,
+    bool is_download_reported) {
   int64_t referrer_host_id =
       precache_referrer_host_table_.GetReferrerHost(referrer_host).id;
   if (referrer_host_id == PrecacheReferrerHostEntry::kInvalidId) {
     referrer_host_id = precache_referrer_host_table_.UpdateReferrerHost(
         referrer_host, 0, fetch_time);
   }
   DCHECK_NE(referrer_host_id, PrecacheReferrerHostEntry::kInvalidId);
-  precache_url_table_.AddURL(url, referrer_host_id, is_precached, fetch_time);
+  precache_url_table_.AddURL(url, referrer_host_id, is_precached, fetch_time,
+                             is_download_reported);
 }
 
 void PrecacheDatabase::RecordURLNonPrefetch(const GURL& url,
                                             const base::TimeDelta& latency,
                                             const base::Time& fetch_time,
                                             const net::HttpResponseInfo& info,
                                             int64_t size,
                                             int host_rank,
                                             bool is_connection_cellular) {
   UMA_HISTOGRAM_TIMES("Precache.Latency.NonPrefetch", latency);
@@ skipping 99 matching lines @@
                  GetWeakPtr(), hostname, manifest_id, fetch_time));
   MaybePostFlush();
 }
 
 void PrecacheDatabase::UpdatePrecacheReferrerHostInternal(
     const std::string& hostname,
     int64_t manifest_id,
     const base::Time& fetch_time) {
   int64_t referrer_host_id = precache_referrer_host_table_.UpdateReferrerHost(
       hostname, manifest_id, fetch_time);
+
   if (referrer_host_id != PrecacheReferrerHostEntry::kInvalidId) {
     precache_url_table_.ClearAllForReferrerHost(referrer_host_id);
   }
 }
 
 void PrecacheDatabase::RecordTimeSinceLastPrecache(
     const base::Time& fetch_time) {
   const base::Time& last_precache_timestamp = GetLastPrecacheTimestamp();
   // It could still be null if the DB was not accessible.
   if (!last_precache_timestamp.is_null()) {
@@ skipping 95 matching lines @@
 
 PrecacheQuota PrecacheDatabase::GetQuota() {
   return precache_session_table_.GetQuota();
 }
 
 base::WeakPtr<PrecacheDatabase> PrecacheDatabase::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace precache