Add UMA Precache.Freshness.Prefetch

components/precache/core/precache_database_unittest.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 <stdint.h>
 
 #include <map>
 #include <memory>
 
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_base.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_constants.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 using ::testing::ContainerEq;
 using ::testing::ElementsAre;
 using base::Bucket;
+using net::HttpResponseInfo;
 
 const GURL kURL("http://url.com");
 const base::TimeDelta kLatency = base::TimeDelta::FromMilliseconds(5);
 const base::Time kFetchTime = base::Time() + base::TimeDelta::FromHours(1000);
 const base::Time kOldFetchTime = kFetchTime - base::TimeDelta::FromDays(1);
 const int64_t kSize = 5000;
+const int64_t kFreshnessBucket10K = 9089;
 
 std::map<GURL, base::Time> BuildURLTableMap(const GURL& url,
                                             const base::Time& precache_time) {
   std::map<GURL, base::Time> url_table_map;
   url_table_map[url] = precache_time;
   return url_table_map;
 }
 
+HttpResponseInfo CreateHttpResponseInfo(bool was_cached,
+                                        bool network_accessed) {
+  HttpResponseInfo result;

[bengr, 2016/07/26 17:29:10]

#include "net/http/http_response_info.h"

[jamartin, 2016/07/26 19:56:22]

Done.

+  result.was_cached = was_cached;
+  result.network_accessed = network_accessed;
+  std::string header(
+      "HTTP/1.1 200 OK\n"
+      "cache-control: max-age=10000\n\n");
+  result.headers = new net::HttpResponseHeaders(
+      net::HttpUtil::AssembleRawHeaders(header.c_str(), header.size()));
+  DCHECK_EQ(
+      10000,
+      result.headers->GetFreshnessLifetimes(base::Time()).freshness.InSeconds())
+      << "Error parsing the test headers: " << header;
+  return result;
+}
+
 }  // namespace
 
 namespace precache {
 
 class PrecacheDatabaseTest : public testing::Test {
  public:
   PrecacheDatabaseTest() {}
   ~PrecacheDatabaseTest() override {}
 
  protected:
@@ skipping 69 matching lines @@
     EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
                 ContainerEq(expected_histogram_counts_));
   }
 };
 
 void PrecacheDatabaseTest::RecordPrecacheFromNetwork(
     const GURL& url,
     base::TimeDelta latency,
     const base::Time& fetch_time,
     int64_t size) {
-  precache_database_->RecordURLPrefetch(url, latency, fetch_time, size,
-                                        false /* was_cached */);
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      false /* was_cached */, false /* network_accessed */);
+  precache_database_->RecordURLPrefetch(url, latency, fetch_time, info, size);
 }
 
 void PrecacheDatabaseTest::RecordPrecacheFromCache(const GURL& url,
                                                    const base::Time& fetch_time,
                                                    int64_t size) {
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      true /* was_cached */, false /* network_accessed */);
   precache_database_->RecordURLPrefetch(url, base::TimeDelta() /* latency */,
-                                        fetch_time, size,
-                                        true /* was_cached */);
+                                        fetch_time, info, size);
 }
 
 void PrecacheDatabaseTest::RecordFetchFromNetwork(const GURL& url,
                                                   base::TimeDelta latency,
                                                   const base::Time& fetch_time,
                                                   int64_t size) {
-  precache_database_->RecordURLNonPrefetch(
-      url, latency, fetch_time, size, false /* was_cached */,
-      history::kMaxTopHosts, false /* is_connection_cellular */);
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      false /* was_cached */, false /* network_accessed */);
+  precache_database_->RecordURLNonPrefetch(url, latency, fetch_time, info, size,
+                                           history::kMaxTopHosts,
+                                           false /* is_connection_cellular */);
 }
 
 void PrecacheDatabaseTest::RecordFetchFromNetwork(const GURL& url,
                                                   base::TimeDelta latency,
                                                   const base::Time& fetch_time,
                                                   int64_t size,
                                                   int host_rank) {
-  precache_database_->RecordURLNonPrefetch(url, latency, fetch_time, size,
-                                           false /* was_cached */, host_rank,
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      false /* was_cached */, false /* network_accessed */);
+  precache_database_->RecordURLNonPrefetch(url, latency, fetch_time, info, size,
+                                           host_rank,
                                            false /* is_connection_cellular */);
 }
 
 void PrecacheDatabaseTest::RecordFetchFromNetworkCellular(
     const GURL& url,
     base::TimeDelta latency,
     const base::Time& fetch_time,
     int64_t size) {
-  precache_database_->RecordURLNonPrefetch(
-      url, latency, fetch_time, size, false /* was_cached */,
-      history::kMaxTopHosts, true /* is_connection_cellular */);
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      false /* was_cached */, false /* network_accessed */);
+  precache_database_->RecordURLNonPrefetch(url, latency, fetch_time, info, size,
+                                           history::kMaxTopHosts,
+                                           true /* is_connection_cellular */);
 }
 
 void PrecacheDatabaseTest::RecordFetchFromCache(const GURL& url,
                                                 const base::Time& fetch_time,
                                                 int64_t size) {
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      true /* was_cached */, false /* network_accessed */);
   precache_database_->RecordURLNonPrefetch(
-      url, base::TimeDelta() /* latency */, fetch_time, size,
-      true /* was_cached */, history::kMaxTopHosts,
-      false /* is_connection_cellular */);
+      url, base::TimeDelta() /* latency */, fetch_time, info, size,
+      history::kMaxTopHosts, false /* is_connection_cellular */);
 }
 
 void PrecacheDatabaseTest::RecordFetchFromCacheCellular(
     const GURL& url,
     const base::Time& fetch_time,
     int64_t size) {
+  const HttpResponseInfo info = CreateHttpResponseInfo(
+      true /* was_cached */, false /* network_accessed */);
   precache_database_->RecordURLNonPrefetch(
-      url, base::TimeDelta() /* latency */, fetch_time, size,
-      true /* was_cached */, history::kMaxTopHosts,
-      true /* is_connection_cellular */);
+      url, base::TimeDelta() /* latency */, fetch_time, info, size,
+      history::kMaxTopHosts, true /* is_connection_cellular */);
 }
 
 namespace {
 
 TEST_F(PrecacheDatabaseTest, PrecacheOverNetwork) {
   RecordPrecacheFromNetwork(kURL, kLatency, kFetchTime, kSize);
 
   EXPECT_EQ(BuildURLTableMap(kURL, kFetchTime), GetActualURLTableMap());
 
   ExpectNewSample("Precache.DownloadedPrecacheMotivated", kSize);
   ExpectNewSample("Precache.Latency.Prefetch", kLatency.InMilliseconds());
+  ExpectNewSample("Precache.Freshness.Prefetch", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, PrecacheFromCacheWithURLTableEntry) {
   precache_url_table()->AddURL(kURL, kOldFetchTime);
   RecordPrecacheFromCache(kURL, kFetchTime, kSize);
 
   // The URL table entry should have been updated to have |kFetchTime| as the
   // timestamp.
   EXPECT_EQ(BuildURLTableMap(kURL, kFetchTime), GetActualURLTableMap());
 
   ExpectNewSample("Precache.Latency.Prefetch", 0);
+  ExpectNewSample("Precache.Freshness.Prefetch", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, PrecacheFromCacheWithoutURLTableEntry) {
   RecordPrecacheFromCache(kURL, kFetchTime, kSize);
 
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.Latency.Prefetch", 0);
+  ExpectNewSample("Precache.Freshness.Prefetch", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchOverNetwork_NonCellular) {
   RecordFetchFromNetwork(kURL, kLatency, kFetchTime, kSize);
 
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.DownloadedNonPrecache", kSize);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
@@ skipping 44 matching lines @@
 TEST_F(PrecacheDatabaseTest, FetchFromCacheWithURLTableEntry_NonCellular) {
   precache_url_table()->AddURL(kURL, kOldFetchTime);
   RecordFetchFromCache(kURL, kFetchTime, kSize);
 
   // The URL table entry should have been deleted.
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.Latency.NonPrefetch", 0);
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts", 0);
   ExpectNewSample("Precache.Saved", kSize);
+  ExpectNewSample("Precache.Saved.Freshness", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchFromCacheWithURLTableEntry_Cellular) {
   precache_url_table()->AddURL(kURL, kOldFetchTime);
   RecordFetchFromCacheCellular(kURL, kFetchTime, kSize);
 
   // The URL table entry should have been deleted.
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.Latency.NonPrefetch", 0);
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts", 0);
   ExpectNewSample("Precache.Saved", kSize);
   ExpectNewSample("Precache.Saved.Cellular", kSize);
+  ExpectNewSample("Precache.Saved.Freshness", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchFromCacheWithoutURLTableEntry) {
   RecordFetchFromCache(kURL, kFetchTime, kSize);
 
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.Latency.NonPrefetch", 0);
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts", 0);
@@ skipping 93 matching lines @@
   RecordFetchFromCacheCellular(kURL, kTimeA, kSize);
   RecordFetchFromNetworkCellular(kURL, kLatency, kTimeB, kSize);
   RecordFetchFromNetworkCellular(kURL, kLatency, kTimeB, kSize);
   RecordFetchFromCacheCellular(kURL, kTimeB, kSize);
   RecordFetchFromCacheCellular(kURL, kTimeC, kSize);
 
   EXPECT_THAT(histograms_.GetAllSamples("Precache.TimeSinceLastPrecache"),
               ElementsAre(Bucket(0, 2), Bucket(2406, 3), Bucket(69347, 1)));
 }
 
+TEST_F(PrecacheDatabaseTest, PrecacheFreshnessPrefetch) {
+  auto info = CreateHttpResponseInfo(false /* was_cached */,
+                                     false /* network_accessed */);
+  RecordPrecacheFromNetwork(kURL, kLatency, kFetchTime, kSize);
+
+  EXPECT_THAT(histograms_.GetAllSamples("Precache.Freshness.Prefetch"),
+              ElementsAre(Bucket(kFreshnessBucket10K, 1)));
+}
+
 }  // namespace
 
 }  // namespace precache