Send the list of used and unused resources for precache

components/precache/content/precache_manager_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/content/precache_manager.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 177 matching lines @@
                              net::URLRequestStatus::FAILED);
     precache_manager_.reset(
         new PrecacheManagerUnderTest(
             &browser_context_, nullptr /* sync_service */,
             &history_service_, db_path, std::move(precache_database)));
     base::RunLoop().RunUntilIdle();
 
     info_.headers = new net::HttpResponseHeaders("");
   }
 
+  void RecordStatsForPrecacheFetch(const GURL& url,
+                                   const std::string& referrer_host,
+                                   const base::TimeDelta& latency,
+                                   const base::Time& fetch_time,
+                                   const net::HttpResponseInfo& info,
+                                   int64_t size) {
+    precache_manager_->RecordStatsForFetch(url, GURL(referrer_host), latency,
+                                           fetch_time, info, size);
+    precache_manager_->precache_database_->RecordURLPrefetch(
+        url, referrer_host, fetch_time, info.was_cached, size);
+  }
+
   // Must be declared first so that it is destroyed last.
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
   base::ScopedTempDir scoped_temp_dir_;
   PrecacheDatabase* precache_database_;
   content::TestBrowserContext browser_context_;
   std::unique_ptr<PrecacheManagerUnderTest> precache_manager_;
   TestURLFetcherCallback url_callback_;
   net::FakeURLFetcherFactory factory_;
   TestPrecacheCompletionCallback precache_callback_;
   testing::NiceMock<MockHistoryService> history_service_;
   base::HistogramTester histograms_;
   net::HttpResponseInfo info_;
 };
 
 TEST_F(PrecacheManagerTest, StartAndFinishPrecaching) {
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   MockHistoryService::TopHostsCallback top_hosts_callback;
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(SaveArg<1>(&top_hosts_callback));
 
+  factory_.SetFakeResponse(GURL(kConfigURL), "", net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodManifestURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
   top_hosts_callback.Run(
       history::TopHostsList(1, std::make_pair("good-manifest.com", 1)));
   base::RunLoop().RunUntilIdle();  // For PrecacheFetcher.
   EXPECT_FALSE(precache_manager_->IsPrecaching());
   EXPECT_TRUE(precache_callback_.was_on_done_called());
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 }
 
 TEST_F(PrecacheManagerTest, StartAndFinishPrecachingWithUnfinishedHosts) {
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("evil-manifest.com");
   unfinished_work->set_start_time(base::Time::Now().ToInternalValue());
   precache_database_->SaveUnfinishedWork(std::move(unfinished_work));
 
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
+  factory_.SetFakeResponse(GURL(kConfigURL), "", net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(
       GURL(kEvilManifestURL), "",
       net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   ASSERT_TRUE(precache_database_->GetLastPrecacheTimestamp().is_null());
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
   base::RunLoop().RunUntilIdle();  // For PrecacheFetcher.
@@ skipping 125 matching lines @@
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."), IsEmpty());
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchDuringPrecaching) {
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .WillOnce(ReturnHosts(history::TopHostsList()));
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
 
   EXPECT_TRUE(precache_manager_->IsPrecaching());
-  precache_manager_->RecordStatsForFetch(GURL("http://url.com"), GURL(),
-                                         base::TimeDelta(), base::Time(), info_,
-                                         1000);
+  RecordStatsForPrecacheFetch(GURL("http://url.com"), std::string(),
+                              base::TimeDelta(), base::Time(), info_, 1000);
   base::RunLoop().RunUntilIdle();
   precache_manager_->CancelPrecaching();
 
   // For PrecacheFetcher and RecordURLPrecached.
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(
       histograms_.GetTotalCountsForPrefix("Precache."),
       UnorderedElementsAre(Pair("Precache.DownloadedPrecacheMotivated", 1),
                            Pair("Precache.Fetch.PercentCompleted", 1),
                            Pair("Precache.Fetch.ResponseBytes.Network", 1),
@@ skipping 58 matching lines @@
   // This test has to use Time::Now() because StartPrecaching uses Time::Now().
   const base::Time kCurrentTime = base::Time::Now();
   EXPECT_CALL(history_service_, TopHosts(NumTopHosts(), _))
       .Times(2)
       .WillRepeatedly(ReturnHosts(history::TopHostsList()));
 
   precache_manager_->StartPrecaching(precache_callback_.GetCallback());
   EXPECT_TRUE(precache_manager_->IsPrecaching());
 
   // Precache a bunch of URLs, with different fetch times.
-  precache_manager_->RecordStatsForFetch(
-      GURL("http://old-fetch.com"), GURL(), base::TimeDelta(),
+  RecordStatsForPrecacheFetch(
+      GURL("http://old-fetch.com"), std::string(), base::TimeDelta(),
       kCurrentTime - base::TimeDelta::FromDays(61), info_, 1000);
-  precache_manager_->RecordStatsForFetch(
-      GURL("http://recent-fetch.com"), GURL(), base::TimeDelta(),
+  RecordStatsForPrecacheFetch(
+      GURL("http://recent-fetch.com"), std::string(), base::TimeDelta(),
       kCurrentTime - base::TimeDelta::FromDays(59), info_, 1000);
-  precache_manager_->RecordStatsForFetch(
-      GURL("http://yesterday-fetch.com"), GURL(), base::TimeDelta(),
+  RecordStatsForPrecacheFetch(
+      GURL("http://yesterday-fetch.com"), std::string(), base::TimeDelta(),
       kCurrentTime - base::TimeDelta::FromDays(1), info_, 1000);
   expected_histogram_count_map["Precache.DownloadedPrecacheMotivated"] += 3;
   expected_histogram_count_map["Precache.Fetch.PercentCompleted"]++;
   expected_histogram_count_map["Precache.Fetch.ResponseBytes.Network"]++;
   expected_histogram_count_map["Precache.Fetch.ResponseBytes.Total"]++;
   expected_histogram_count_map["Precache.Fetch.TimeToComplete"]++;
   expected_histogram_count_map["Precache.Latency.Prefetch"] += 3;
   expected_histogram_count_map["Precache.Freshness.Prefetch"] += 3;
   base::RunLoop().RunUntilIdle();
 
@@ skipping 55 matching lines @@
   expected_histogram_count_map["Precache.Saved"] += 2;
   expected_histogram_count_map["Precache.TimeSinceLastPrecache"] += 2;
   expected_histogram_count_map["Precache.Saved.Freshness"] = 2;
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 }
 
 }  // namespace precache