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 242 matching lines @@
   PrefetchingObserver(ResourcePrefetchPredictor* predictor,
                       const GURL& expected_main_frame_url)
       : TestObserver(predictor), main_frame_url_(expected_main_frame_url) {}
 
   // TestObserver:
   void OnNavigationLearned(size_t url_visit_count,
                            const PageRequestSummary& summary) override {
     ADD_FAILURE() << "Prefetching shouldn't activate learning";
   }
 
-  void OnPrefetchingFinished(const GURL& main_frame_url) override {
+  void OnPrefetchingFinished(
+      const GURL& main_frame_url,
+      const ResourcePrefetcher::PrefetcherStats& stats) override {
     EXPECT_EQ(main_frame_url_, main_frame_url);
     run_loop_.Quit();
   }
 
   void Wait() { run_loop_.Run(); }
 
  private:
   base::RunLoop run_loop_;
   GURL main_frame_url_;
 
@@ skipping 25 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 250 matching lines @@
         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);

[alexilin, 2017/02/09 15:24:17]

There already is http_response->set_content() call.
This one is unused, feel free to delete together with content field in
ResourceSummary.

[Benoit L, 2017/02/13 16:13:15]

Oops... was myopic.
Done.

     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, static_cast<char>(42)));

[alexilin, 2017/02/09 15:24:17]

It will cause additional parsing errors in tests. But whatever...

[Benoit L, 2017/02/13 16:13:15]

Changed to a space, which should be fine for the various text resources.
Done.

+
     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 =
         redirects_.find(GetRequestURL(request));
     if (redirect_it == redirects_.end() || redirect_it->second.is_client_side)
       return nullptr;
 
     auto http_response =
         base::MakeUnique<net::test_server::BasicHttpResponse>();
     http_response->set_code(redirect_it->second.code);
     http_response->AddCustomHeader("Location", redirect_it->second.url.spec());
     return std::move(http_response);
   }
 
   size_t UpdateAndGetVisitCount(const GURL& main_frame_url) {
     return ++visit_count_[main_frame_url];
   }
 
+ protected:
+  std::unique_ptr<base::HistogramTester> histogram_tester_;

[alexilin, 2017/02/09 15:24:18]

Could you put it at the end of (first) protected section?
https://google.github.io/styleguide/cppguide.html#Declaration_Order

[Benoit L, 2017/02/13 16:13:15]

Done.

+
+ private:
   ResourcePrefetchPredictor* predictor_;
   std::unique_ptr<net::EmbeddedTestServer> https_server_;
   std::map<GURL, ResourceSummary> resources_;
   std::map<GURL, RedirectEdge> redirects_;
   std::map<GURL, size_t> visit_count_;
   std::set<NavigationID> navigation_id_history_;
 };
 
 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