Add UMA Precache.Freshness.Prefetch

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"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/precache/core/proto/unfinished_work.pb.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_response_info.h"
 #include "sql/connection.h"
 #include "sql/transaction.h"
 #include "url/gurl.h"
 
 namespace {
 
 // The number of days old that an entry in the precache URL table can be before
 // it is considered "old" and is removed from the table.
 const int kPrecacheHistoryExpiryPeriodDays = 60;
 
@@ skipping 85 matching lines @@
   if (last_precache_timestamp_.is_null() && IsDatabaseAccessible()) {
     last_precache_timestamp_ =
         precache_session_table_.GetLastPrecacheTimestamp();
   }
   return last_precache_timestamp_;
 }
 
 void PrecacheDatabase::RecordURLPrefetch(const GURL& url,
                                          const base::TimeDelta& latency,
                                          const base::Time& fetch_time,
-                                         int64_t size,
-                                         bool was_cached) {
+                                         const net::HttpResponseInfo& info,
+                                         int64_t size) {
   UMA_HISTOGRAM_TIMES("Precache.Latency.Prefetch", latency);
 
   if (!IsDatabaseAccessible()) {
     // Don't track anything if unable to access the database.
     return;
   }
 
   if (buffered_urls_.find(url.spec()) != buffered_urls_.end()) {
     // If the URL for this fetch is in the write buffer, then flush the write
     // buffer.
     Flush();
   }
 
-  if (was_cached && !precache_url_table_.HasURL(url)) {
+  DCHECK(info.headers) << "The headers are required to get the freshness.";
+  if (info.headers) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "Precache.Freshness.Prefetch",
+        info.headers->GetFreshnessLifetimes(info.response_time)
+            .freshness.InSeconds(),
+        base::TimeDelta::FromMinutes(5).InSeconds() /* min */,
+        base::TimeDelta::FromDays(356).InSeconds() /* max */,
+        100 /* bucket_count */);
+  }
+
+  if (info.was_cached && !precache_url_table_.HasURL(url)) {
     // Since the precache came from the cache, and there's no entry in the URL
     // table for the URL, this means that the resource was already in the cache
-    // because of user browsing. Thus, this precache had no effect, so ignore
-    // it.
+    // because of user browsing. Therefore, this precache won't be considered as
+    // precache-motivated since it had no significant effect (besides a possible
+    // revalidation and a change in the cache LRU priority).
     return;
   }
 
-  if (!was_cached) {
+  if (!info.was_cached) {
     // The precache only counts as overhead if it was downloaded over the
     // network.
     UMA_HISTOGRAM_COUNTS("Precache.DownloadedPrecacheMotivated",
                          static_cast<base::HistogramBase::Sample>(size));
   }
 
   // Use the URL table to keep track of URLs that are in the cache thanks to
   // precaching. If a row for the URL already exists, than update the timestamp
   // to |fetch_time|.
   buffered_writes_.push_back(
       base::Bind(&PrecacheURLTable::AddURL,
                  base::Unretained(&precache_url_table_), url, fetch_time));
   buffered_urls_.insert(url.spec());
   MaybePostFlush();
 }
 
 void PrecacheDatabase::RecordURLNonPrefetch(const GURL& url,
                                             const base::TimeDelta& latency,
                                             const base::Time& fetch_time,
+                                            const net::HttpResponseInfo& info,
                                             int64_t size,
-                                            bool was_cached,
                                             int host_rank,
                                             bool is_connection_cellular) {
   UMA_HISTOGRAM_TIMES("Precache.Latency.NonPrefetch", latency);
 
   if (host_rank != history::kMaxTopHosts) {
     // The resource was loaded on a page that could have been affected by
     // precaching.
     UMA_HISTOGRAM_TIMES("Precache.Latency.NonPrefetch.TopHosts", latency);
   } else {
     // The resource was loaded on a page that could NOT have been affected by
     // precaching.
     UMA_HISTOGRAM_TIMES("Precache.Latency.NonPrefetch.NonTopHosts", latency);
   }
 
   if (!IsDatabaseAccessible()) {
     // Don't track anything if unable to access the database.
     return;
   }
 
   RecordTimeSinceLastPrecache(fetch_time);
 
   if (buffered_urls_.find(url.spec()) != buffered_urls_.end()) {
     // If the URL for this fetch is in the write buffer, then flush the write
     // buffer.
     Flush();
   }
 
-  if (was_cached && !precache_url_table_.HasURL(url)) {
+  if (info.was_cached && !precache_url_table_.HasURL(url)) {
     // Ignore cache hits that precache can't take credit for.
     return;
   }
 
   base::HistogramBase::Sample size_sample =
       static_cast<base::HistogramBase::Sample>(size);
-  if (!was_cached) {
+  if (!info.was_cached) {
     // The fetch was served over the network during user browsing, so count it
     // as downloaded non-precache bytes.
     UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache", size_sample);
     if (is_connection_cellular) {
       UMA_HISTOGRAM_COUNTS("Precache.DownloadedNonPrecache.Cellular",
                            size_sample);
     }
-  } else {
+  } else {  // info.was_cached.
     // The fetch was served from the cache, and since there's an entry for this
     // URL in the URL table, this means that the resource was served from the
     // cache only because precaching put it there. Thus, precaching was helpful,
     // so count the fetch as saved bytes.
     UMA_HISTOGRAM_COUNTS("Precache.Saved", size_sample);
     if (is_connection_cellular) {
       UMA_HISTOGRAM_COUNTS("Precache.Saved.Cellular", size_sample);
     }
+
+    DCHECK(info.headers) << "The headers are required to get the freshness.";
+    if (info.headers) {
+      // TODO(jamartin): Maybe report stale_while_validate as well.
+      UMA_HISTOGRAM_CUSTOM_COUNTS(
+          "Precache.Saved.Freshness",
+          info.headers->GetFreshnessLifetimes(info.response_time)
+              .freshness.InSeconds(),
+          base::TimeDelta::FromMinutes(5).InSeconds() /* min */,
+          base::TimeDelta::FromDays(356).InSeconds() /* max */,
+          100 /* bucket_count */);
+    }
   }
 
   // Since the resource has been fetched during user browsing, remove any record
   // of that URL having been precached from the URL table, if any exists.
   // The current fetch would have put this resource in the cache regardless of
   // whether or not it was previously precached, so delete any record of that
   // URL having been precached from the URL table.
   buffered_writes_.push_back(
       base::Bind(&PrecacheURLTable::DeleteURL,
                  base::Unretained(&precache_url_table_), url));
@@ skipping 96 matching lines @@
 
 void PrecacheDatabase::DeleteUnfinishedWork() {
   precache_session_table_.DeleteUnfinishedWork();
 }
 
 base::WeakPtr<PrecacheDatabase> PrecacheDatabase::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 }  // namespace precache