Send the list of used and unused resources for precache

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 14 matching lines @@
 #include "url/gurl.h"
 
 namespace {
 
 using ::testing::ContainerEq;
 using ::testing::ElementsAre;
 using base::Bucket;
 using net::HttpResponseInfo;
 
 const GURL kURL("http://url.com");
+const int kReferrerID = 1;
 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;
 
@@ skipping 116 matching lines @@
   }
 };
 
 void PrecacheDatabaseTest::RecordPrecacheFromNetwork(
     const GURL& url,
     base::TimeDelta latency,
     const base::Time& fetch_time,
     int64_t size) {
   const HttpResponseInfo info = CreateHttpResponseInfo(
       false /* was_cached */, false /* network_accessed */);
-  precache_database_->RecordURLPrefetch(url, latency, fetch_time, info, size);
+  precache_database_->RecordURLPrefetchMetrics(info, latency);
+  precache_database_->RecordURLPrefetch(url, std::string(), fetch_time,
+                                        info.was_cached, 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, info, size);
+  precache_database_->RecordURLPrefetchMetrics(info,
+                                               base::TimeDelta() /* latency */);
+  precache_database_->RecordURLPrefetch(url, std::string(), fetch_time,
+                                        info.was_cached, size);
 }
 
 void PrecacheDatabaseTest::RecordFetchFromNetwork(const GURL& url,
                                                   base::TimeDelta latency,
                                                   const base::Time& fetch_time,
                                                   int64_t size) {
   const HttpResponseInfo info = CreateHttpResponseInfo(
       false /* was_cached */, false /* network_accessed */);
   precache_database_->RecordURLNonPrefetch(url, latency, fetch_time, info, size,
                                            history::kMaxTopHosts,
@@ skipping 52 matching lines @@
 
   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);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, 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();
 }
@@ skipping 42 matching lines @@
   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);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, 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);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, 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);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, 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);
@@ skipping 12 matching lines @@
   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);
+  precache_url_table()->AddURL(GURL("http://expired-precache.com"), kReferrerID,
+                               true, k61DaysAgo);
+  precache_url_table()->AddURL(GURL("http://old-precache.com"), kReferrerID,
+                               true, k59DaysAgo);
 
   precache_database_->DeleteExpiredPrecacheHistory(kToday);
 
   EXPECT_EQ(BuildURLTableMap(GURL("http://old-precache.com"), k59DaysAgo),
             GetActualURLTableMap());
 }
 
 TEST_F(PrecacheDatabaseTest, SampleInteraction) {
   const GURL kURL1("http://url1.com");
   const int64_t kSize1 = 1;
@@ skipping 85 matching lines @@
                                      false /* network_accessed */);
   RecordPrecacheFromNetwork(kURL, kLatency, kFetchTime, kSize);
 
   EXPECT_THAT(histograms_.GetAllSamples("Precache.Freshness.Prefetch"),
               ElementsAre(Bucket(kFreshnessBucket10K, 1)));
 }
 
 }  // namespace
 
 }  // namespace precache