Add UMA Precache.CacheStatus.NonPrefetch

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 29 matching lines @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace precache {
 
 namespace {
 
 using ::testing::_;
 using ::testing::ContainerEq;
-using ::testing::ElementsAre;
 using ::testing::UnorderedElementsAre;
 using ::testing::Invoke;
 using ::testing::IsEmpty;
 using ::testing::Pair;
 using ::testing::SaveArg;
 
 const char kConfigURL[] = "http://config-url.com";
 const char kManifestURLPrefix[] = "http://manifest-url-prefix.com/";
 const char kGoodManifestURL[] =
     "http://manifest-url-prefix.com/good-manifest.com";
@@ skipping 343 matching lines @@
                            Pair("Precache.Freshness.Prefetch", 1)));
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchHTTP) {
   precache_manager_->RecordStatsForFetch(GURL("http://http-url.com"), GURL(),
                                          base::TimeDelta(), base::Time(), info_,
                                          1000);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
-              ElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
-                          Pair("Precache.Latency.NonPrefetch", 1),
-                          Pair("Precache.Latency.NonPrefetch.NonTopHosts", 1)));
+              UnorderedElementsAre(
+                  Pair("Precache.DownloadedNonPrecache", 1),
+                  Pair("Precache.CacheStatus.NonPrefetch", 1),
+                  Pair("Precache.Latency.NonPrefetch", 1),
+                  Pair("Precache.Latency.NonPrefetch.NonTopHosts", 1)));
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchHTTPS) {
   precache_manager_->RecordStatsForFetch(GURL("https://https-url.com"), GURL(),
                                          base::TimeDelta(), base::Time(), info_,
                                          1000);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
-              ElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
-                          Pair("Precache.Latency.NonPrefetch", 1),
-                          Pair("Precache.Latency.NonPrefetch.NonTopHosts", 1)));
+              UnorderedElementsAre(
+                  Pair("Precache.DownloadedNonPrecache", 1),
+                  Pair("Precache.CacheStatus.NonPrefetch", 1),
+                  Pair("Precache.Latency.NonPrefetch", 1),
+                  Pair("Precache.Latency.NonPrefetch.NonTopHosts", 1)));
 }
 
 TEST_F(PrecacheManagerTest, RecordStatsForFetchInTopHosts) {
   EXPECT_CALL(history_service_,
               HostRankIfAvailable(GURL("http://referrer.com"), _))
       .WillOnce(Invoke(
           [](const GURL& url, const base::Callback<void(int)>& callback) {
             callback.Run(0);
           }));
   precache_manager_->RecordStatsForFetch(
       GURL("http://http-url.com"), GURL("http://referrer.com"),
       base::TimeDelta(), base::Time(), info_, 1000);
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
-              ElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
-                          Pair("Precache.Latency.NonPrefetch", 1),
-                          Pair("Precache.Latency.NonPrefetch.TopHosts", 1)));
+  EXPECT_THAT(
+      histograms_.GetTotalCountsForPrefix("Precache."),
+      UnorderedElementsAre(Pair("Precache.DownloadedNonPrecache", 1),
+                           Pair("Precache.CacheStatus.NonPrefetch", 1),
+                           Pair("Precache.Latency.NonPrefetch", 1),
+                           Pair("Precache.Latency.NonPrefetch.TopHosts", 1)));
 }
 
 TEST_F(PrecacheManagerTest, DeleteExpiredPrecacheHistory) {
   // TODO(twifkak): Split this into multiple tests.
   base::HistogramTester::CountsMap expected_histogram_count_map;
 
   // 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)
@@ skipping 49 matching lines @@
   EXPECT_FALSE(precache_manager_->IsPrecaching());
 
   // A fetch for the same URL as the expired precache was served from the cache,
   // but it isn't reported as saved bytes because it had expired in the precache
   // history.
   info_.was_cached = true;  // From now on all fetches are cached.
   precache_manager_->RecordStatsForFetch(GURL("http://old-fetch.com"), GURL(),
                                          base::TimeDelta(), kCurrentTime, info_,
                                          1000);
   expected_histogram_count_map["Precache.Fetch.TimeToComplete"]++;
+  expected_histogram_count_map["Precache.CacheStatus.NonPrefetch"]++;
   expected_histogram_count_map["Precache.Latency.NonPrefetch"]++;
   expected_histogram_count_map["Precache.Latency.NonPrefetch.NonTopHosts"]++;
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 
   // The other precaches should not have expired, so the following fetches from
   // the cache should count as saved bytes.
   precache_manager_->RecordStatsForFetch(GURL("http://recent-fetch.com"),
                                          GURL(), base::TimeDelta(),
                                          kCurrentTime, info_, 1000);
   precache_manager_->RecordStatsForFetch(GURL("http://yesterday-fetch.com"),
                                          GURL(), base::TimeDelta(),
                                          kCurrentTime, info_, 1000);
+  expected_histogram_count_map["Precache.CacheStatus.NonPrefetch"] += 2;
   expected_histogram_count_map["Precache.Latency.NonPrefetch"] += 2;
   expected_histogram_count_map["Precache.Latency.NonPrefetch.NonTopHosts"] += 2;
   expected_histogram_count_map["Precache.Saved"] += 2;
   expected_histogram_count_map["Precache.Saved.Freshness"] = 2;
 
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(histograms_.GetTotalCountsForPrefix("Precache."),
               ContainerEq(expected_histogram_count_map));
 }
 
 }  // namespace precache