predictors: Add prefetching hit/miss histograms.

chrome/browser/predictors/resource_prefetch_predictor_browsertest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
+#include "base/test/histogram_tester.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_factory.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_test_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 47 matching lines @@
 
 struct ResourceSummary {
   ResourceSummary()
       : version(0),
         is_no_store(false),
         is_external(false),
         is_observable(true),
         is_prohibited(false) {}
 
   ResourcePrefetchPredictor::URLRequestSummary request;
-  std::string content;
   // Allows to update HTTP ETag.
   size_t version;
   // True iff "Cache-control: no-store" header is present.
   bool is_no_store;
   // True iff a request for this resource must be ignored by the custom handler.
   bool is_external;
   // True iff the LearningObserver must observe this resource.
   bool is_observable;
   // A request with |is_prohibited| set to true makes the test that originates
   // the request fail.
@@ skipping 220 matching lines @@
         base::Bind(&ResourcePrefetchPredictorBrowserTest::HandleResourceRequest,
                    base::Unretained(this)));
     embedded_test_server()->RegisterRequestMonitor(base::Bind(
         &ResourcePrefetchPredictorBrowserTest::MonitorResourceRequest,
         base::Unretained(this)));
     ASSERT_TRUE(embedded_test_server()->Start());
     predictor_ =
         ResourcePrefetchPredictorFactory::GetForProfile(browser()->profile());
     ASSERT_TRUE(predictor_);
     EnsurePredictorInitialized();
+    histogram_tester_.reset(new base::HistogramTester());
   }
 
   void TestLearningAndPrefetching(const GURL& main_frame_url) {
     // Navigate to |main_frame_url| and check all the expectations.
     NavigateToURLAndCheckSubresources(main_frame_url);
     ClearCache();
     // It is needed to have at least two resource hits to trigger prefetch.
     NavigateToURLAndCheckSubresources(main_frame_url);
     ClearCache();
     // Prefetch all needed resources and change expectations so that all
@@ skipping 150 matching lines @@
   const net::EmbeddedTestServer* https_server() const {
     return https_server_.get();
   }
 
   net::EmbeddedTestServer* https_server() { return https_server_.get(); }
 
   size_t navigation_ids_history_size() const {
     return navigation_id_history_.size();
   }
 
+  std::unique_ptr<base::HistogramTester> histogram_tester_;
+
  private:
   // ResourcePrefetchPredictor needs to be initialized before the navigation
   // happens otherwise this navigation will be ignored by predictor.
   void EnsurePredictorInitialized() {
     if (predictor_->initialization_state_ ==
         ResourcePrefetchPredictor::INITIALIZED) {
       return;
     }
 
     InitializationObserver observer(predictor_);
@@ skipping 79 matching lines @@
     if (request.headers.find("If-None-Match") != request.headers.end() &&
         request.headers.at("If-None-Match") ==
             CreateVersionedETag(summary.version, request.relative_url)) {
       http_response->set_code(net::HTTP_NOT_MODIFIED);
     } else {
       http_response->set_code(net::HTTP_OK);
     }
 
     if (!summary.request.mime_type.empty())
       http_response->set_content_type(summary.request.mime_type);
-    if (!summary.content.empty())
-      http_response->set_content(summary.content);
     if (summary.is_no_store)
       http_response->AddCustomHeader("Cache-Control", "no-store");
     if (summary.request.has_validators) {
       http_response->AddCustomHeader(
           "ETag", CreateVersionedETag(summary.version, request.relative_url));
     }
     if (summary.request.always_revalidate)
       http_response->AddCustomHeader("Cache-Control", "no-cache");
     else
       http_response->AddCustomHeader("Cache-Control", "max-age=2147483648");
 
+    // Add some content, otherwise the prefetch size histogram rounds down to
+    // 0kB.
+    http_response->set_content(std::string(1024, ' '));
+
     return std::move(http_response);
   }
 
   // The custom handler for redirect requests from the browser to an
   // EmbeddedTestServer. Running on the EmbeddedTestServer IO thread.
   // Finds the data to serve requests in |redirects_| map keyed by a request
   // URL.
   std::unique_ptr<net::test_server::HttpResponse> HandleRedirectRequest(
       const net::test_server::HttpRequest& request) const {
     std::map<GURL, RedirectEdge>::const_iterator redirect_it =
@@ skipping 23 matching lines @@
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, Simple) {
   // These resources have default priorities that correspond to
   // blink::typeToPriority function.
   AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
   AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
               net::HIGHEST);
   AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
   AddResource(GetURL(kFontPath), content::RESOURCE_TYPE_FONT_RESOURCE,
               net::HIGHEST);
   TestLearningAndPrefetching(GetURL(kHtmlSubresourcesPath));
+
+  // The local cache is cleared.
+  histogram_tester_->ExpectBucketCount(
+      internal::kResourcePrefetchPredictorPrefetchMissesCountCached, 0, 1);
+  histogram_tester_->ExpectBucketCount(
+      internal::kResourcePrefetchPredictorPrefetchMissesCountNotCached, 0, 1);
+  histogram_tester_->ExpectBucketCount(
+      internal::kResourcePrefetchPredictorPrefetchHitsCountCached, 0, 1);
+  histogram_tester_->ExpectBucketCount(
+      internal::kResourcePrefetchPredictorPrefetchHitsCountNotCached, 4, 1);
+
+  histogram_tester_->ExpectBucketCount(
+      internal::kResourcePrefetchPredictorPrefetchMissesSize, 0, 1);
+  // Each request is ~1k, see HandleResourceRequest() above.
+  histogram_tester_->ExpectBucketCount(
+      internal::kResourcePrefetchPredictorPrefetchHitsSize, 4, 1);
 }
 
 IN_PROC_BROWSER_TEST_F(ResourcePrefetchPredictorBrowserTest, Redirect) {
   GURL initial_url = embedded_test_server()->GetURL(kFooHost, kRedirectPath);
   AddRedirectChain(initial_url, {{net::HTTP_MOVED_PERMANENTLY,
                                   GetURL(kHtmlSubresourcesPath)}});
   AddResource(GetURL(kImagePath), content::RESOURCE_TYPE_IMAGE, net::LOWEST);
   AddResource(GetURL(kStylePath), content::RESOURCE_TYPE_STYLESHEET,
               net::HIGHEST);
   AddResource(GetURL(kScriptPath), content::RESOURCE_TYPE_SCRIPT, net::MEDIUM);
@@ skipping 217 matching lines @@
   TryToPrefetchURL(initial_url);
   NavigateToURLAndCheckSubresources(initial_url);
   ClearCache();
   // But the predictor database contains all subresources for the endpoint url
   // so this prefetch works.
   PrefetchURL(GetURL(kHtmlSubresourcesPath));
   NavigateToURLAndCheckSubresourcesAllCached(GetURL(kHtmlSubresourcesPath));
 }
 
 }  // namespace predictors