Add UMA Precache.CacheStatus.NonPrefetch

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>
@@ skipping 19 matching lines @@
 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;
+// One of the possible CacheEntryStatus for when the fetch was served from the
+// network.
+const HttpResponseInfo::CacheEntryStatus kFromNetwork =
+    HttpResponseInfo::CacheEntryStatus::ENTRY_UPDATED;
 
 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;
   result.was_cached = was_cached;
   result.network_accessed = network_accessed;
+  if (was_cached) {
+    if (network_accessed) {
+      result.cache_entry_status =
+          HttpResponseInfo::CacheEntryStatus::ENTRY_VALIDATED;
+    } else {
+      result.cache_entry_status =
+          HttpResponseInfo::CacheEntryStatus::ENTRY_USED;
+    }
+  } else {  // !was_cached.
+    result.cache_entry_status = kFromNetwork;
+  }
   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;
@@ skipping 193 matching lines @@
   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.CacheStatus.NonPrefetch", kFromNetwork);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts",
                   kLatency.InMilliseconds());
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchOverNetwork_NonCellular_TopHosts) {
   RecordFetchFromNetwork(kURL, kLatency, kFetchTime, kSize, 0 /* host_rank */);
 
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.DownloadedNonPrecache", kSize);
+  ExpectNewSample("Precache.CacheStatus.NonPrefetch", kFromNetwork);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Latency.NonPrefetch.TopHosts",
                   kLatency.InMilliseconds());
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchOverNetwork_Cellular) {
   RecordFetchFromNetworkCellular(kURL, kLatency, kFetchTime, kSize);
 
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.DownloadedNonPrecache", kSize);
   ExpectNewSample("Precache.DownloadedNonPrecache.Cellular", kSize);
+  ExpectNewSample("Precache.CacheStatus.NonPrefetch", kFromNetwork);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts",
                   kLatency.InMilliseconds());
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchOverNetworkWithURLTableEntry) {
   precache_url_table()->AddURL(kURL, kOldFetchTime);
   RecordFetchFromNetwork(kURL, kLatency, kFetchTime, kSize);
 
   // The URL table entry should have been deleted.
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.DownloadedNonPrecache", kSize);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts",
                   kLatency.InMilliseconds());
+  ExpectNewSample("Precache.CacheStatus.NonPrefetch", kFromNetwork);
   ExpectNoOtherSamples();
 }
 
 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.CacheStatus.NonPrefetch",
+                  HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   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.CacheStatus.NonPrefetch",
+                  HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   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);
+  ExpectNewSample("Precache.CacheStatus.NonPrefetch",
+                  HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, DeleteExpiredPrecacheHistory) {
   const base::Time kToday = base::Time() + base::TimeDelta::FromDays(1000);
   const base::Time k59DaysAgo = kToday - base::TimeDelta::FromDays(59);
   const base::Time k61DaysAgo = kToday - base::TimeDelta::FromDays(61);
 
   precache_url_table()->AddURL(GURL("http://expired-precache.com"), k61DaysAgo);
   precache_url_table()->AddURL(GURL("http://old-precache.com"), k59DaysAgo);
@@ skipping 95 matching lines @@
                                      false /* network_accessed */);
   RecordPrecacheFromNetwork(kURL, kLatency, kFetchTime, kSize);
 
   EXPECT_THAT(histograms_.GetAllSamples("Precache.Freshness.Prefetch"),
               ElementsAre(Bucket(kFreshnessBucket10K, 1)));
 }
 
 }  // namespace
 
 }  // namespace precache