predictors: Add prefetching hit/miss histograms.

chrome/browser/predictors/resource_prefetcher.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetcher.h"
 
+#include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/url_request/url_request_context.h"
 #include "url/origin.h"
 
 namespace {
 
 // The size of the buffer used to read the resource.
 static const size_t kResourceBufferSizeBytes = 50000;
 
 }  // namespace
 
 namespace predictors {
 
+ResourcePrefetcher::PrefetchedRequestStats::PrefetchedRequestStats(
+    const GURL& resource_url,
+    bool was_cached,
+    size_t total_received_bytes)
+    : resource_url(resource_url),
+      was_cached(was_cached),
+      total_received_bytes(total_received_bytes) {}  //

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

What is "//" for?

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

Oops.
Done.

+
+ResourcePrefetcher::PrefetchedRequestStats::~PrefetchedRequestStats() {}
+
+ResourcePrefetcher::PrefetcherStats::PrefetcherStats(const GURL& url)
+    : url(url) {}
+
+ResourcePrefetcher::PrefetcherStats::~PrefetcherStats() {}
+
+ResourcePrefetcher::PrefetcherStats::PrefetcherStats(
+    const PrefetcherStats& other)
+    : url(other.url),
+      start_time(other.start_time),
+      requests_stats(other.requests_stats) {}
+
 ResourcePrefetcher::ResourcePrefetcher(
     Delegate* delegate,
     const ResourcePrefetchPredictorConfig& config,
     const GURL& main_frame_url,
     const std::vector<GURL>& urls)
     : state_(INITIALIZED),
       delegate_(delegate),
       config_(config),
       main_frame_url_(main_frame_url),
       prefetched_count_(0),
-      prefetched_bytes_(0) {
+      prefetched_bytes_(0),
+      stats_(main_frame_url) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   std::copy(urls.begin(), urls.end(), std::back_inserter(request_queue_));
 }
 
 ResourcePrefetcher::~ResourcePrefetcher() {}
 
 void ResourcePrefetcher::Start() {
   TRACE_EVENT_ASYNC_BEGIN0("browser", "ResourcePrefetcher::Prefetch", this);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CHECK_EQ(state_, INITIALIZED);
   state_ = RUNNING;
 
+  stats_.start_time = base::TimeTicks::Now();
   TryToLaunchPrefetchRequests();
 }
 
 void ResourcePrefetcher::Stop() {
   TRACE_EVENT_ASYNC_END0("browser", "ResourcePrefetcher::Prefetch", this);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ == FINISHED)
     return;
 
@@ skipping 40 matching lines @@
     CHECK(request_queue_.empty() || state_ == STOPPED);
 
     UMA_HISTOGRAM_COUNTS_100(
         internal::kResourcePrefetchPredictorPrefetchedCountHistogram,
         prefetched_count_);
     UMA_HISTOGRAM_COUNTS_10000(
         internal::kResourcePrefetchPredictorPrefetchedSizeHistogram,
         prefetched_bytes_ / 1024);
 
     state_ = FINISHED;
-    delegate_->ResourcePrefetcherFinished(this);
+    delegate_->ResourcePrefetcherFinished(this, stats_);
   }
 }
 
 void ResourcePrefetcher::SendRequest(const GURL& url) {
   std::unique_ptr<net::URLRequest> url_request =
       delegate_->GetURLRequestContext()->CreateRequest(url, net::LOW, this);
   host_inflight_counts_[url.host()] += 1;
 
   url_request->set_method("GET");
   url_request->set_first_party_for_cookies(main_frame_url_);
@@ skipping 33 matching lines @@
         kResourceBufferSizeBytes));
     bytes_read = request->Read(buffer.get(), kResourceBufferSizeBytes);
     if (bytes_read == net::ERR_IO_PENDING) {
       return;
     } else if (bytes_read <= 0) {
       if (bytes_read == 0)
         RequestComplete(request);
       FinishRequest(request);
       return;
     }
-
   } while (bytes_read > 0);
 }
 
 void ResourcePrefetcher::RequestComplete(net::URLRequest* request) {
   ++prefetched_count_;
-  prefetched_bytes_ += request->GetTotalReceivedBytes();
+  size_t total_received_bytes = request->GetTotalReceivedBytes();

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

request->GetTotalReceivedBytes() returns int64_t
I doubt that we will prefetch something more than 4GB but let's make this code
more consistent.
Please, change either prefetched_bytes type or type of this local variable.

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

Done.

+  prefetched_bytes_ += total_received_bytes;
 
   UMA_HISTOGRAM_ENUMERATION(
       internal::kResourcePrefetchPredictorCachePatternHistogram,
       request->response_info().cache_entry_status,
       net::HttpResponseInfo::CacheEntryStatus::ENTRY_MAX);
+
+  stats_.requests_stats.emplace_back(request->url(), request->was_cached(),
+                                     total_received_bytes);
 }
 
 void ResourcePrefetcher::OnReceivedRedirect(
     net::URLRequest* request,
     const net::RedirectInfo& redirect_info,
     bool* defer_redirect) {
   FinishRequest(request);
 }
 
 void ResourcePrefetcher::OnAuthRequired(net::URLRequest* request,
@@ skipping 33 matching lines @@
   if (bytes_read <= 0) {
     FinishRequest(request);
     return;
   }
 
   if (bytes_read > 0)
     ReadFullResponse(request);
 }
 
 }  // namespace predictors