Add prefetch UMA metrics.

components/precache/core/precache_fetcher.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/core/precache_fetcher.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
+#include "base/metrics/histogram_macros.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/precache.pb.h"
 #include "net/base/completion_callback.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_fetcher_response_writer.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using net::URLFetcher;
 
 namespace precache {
 
 namespace {
 
+// The maximum for the Precache.Fetch.ResponseBytes histogram. We set this to a
+// number we expect to be in the 99th percentile for the histogram, give or
+// take.
+const int kMaxResponseBytes = 100 * 1024 * 1024;
+
 GURL GetConfigURL() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kPrecacheConfigSettingsURL)) {
     return GURL(
         command_line.GetSwitchValueASCII(switches::kPrecacheConfigSettingsURL));
   }
 
 #if defined(PRECACHE_CONFIG_SETTINGS_URL)
   return GURL(PRECACHE_CONFIG_SETTINGS_URL);
@@ skipping 84 matching lines @@
 // is fetched, etc.
 class PrecacheFetcher::Fetcher : public net::URLFetcherDelegate {
  public:
   // Construct a new Fetcher. This will create and start a new URLFetcher for
   // the specified URL using the specified request context.
   Fetcher(net::URLRequestContextGetter* request_context,
           const GURL& url,
           const base::Callback<void(const URLFetcher&)>& callback,
           bool ignore_response_body);
   ~Fetcher() override {}
+  void OnURLFetchDownloadProgress(const URLFetcher* source,
+                                  int64 current,

[bengr, 2015/07/08 19:52:40]

I think you want to use int64_t. See
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Integer_Types

[twifkak, 2015/07/08 19:59:03]

I'm implementing the net::URLFetcherDelegate interface. I think relying on the
fact that int64 is a typedef for int64_t in order for it to compile is worse
than using a deprecated type. When they change the interface, they can change
all implementors.

+                                  int64 total) override;
   void OnURLFetchComplete(const URLFetcher* source) override;
+  int response_bytes() { return response_bytes_; }
 
  private:
   const base::Callback<void(const URLFetcher&)> callback_;
   scoped_ptr<URLFetcher> url_fetcher_;
+  int response_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(Fetcher);
 };
 
 PrecacheFetcher::Fetcher::Fetcher(
     net::URLRequestContextGetter* request_context,
     const GURL& url,
     const base::Callback<void(const URLFetcher&)>& callback,
     bool ignore_response_body)
-    : callback_(callback) {
+    : callback_(callback), response_bytes_(0) {
   url_fetcher_ = URLFetcher::Create(url, URLFetcher::GET, this);
   url_fetcher_->SetRequestContext(request_context);
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES |
                              net::LOAD_DO_NOT_SEND_COOKIES);
   if (ignore_response_body) {
     scoped_ptr<URLFetcherNullWriter> null_writer(new URLFetcherNullWriter);
     url_fetcher_->SaveResponseWithWriter(null_writer.Pass());
   }
   url_fetcher_->Start();
 }
 
+void PrecacheFetcher::Fetcher::OnURLFetchDownloadProgress(
+    const URLFetcher* source,
+    int64 current,
+    int64 total) {
+  response_bytes_ = current;
+}
+
 void PrecacheFetcher::Fetcher::OnURLFetchComplete(const URLFetcher* source) {
   callback_.Run(*source);
 }
 
 PrecacheFetcher::PrecacheFetcher(
     const std::vector<std::string>& starting_hosts,
     net::URLRequestContextGetter* request_context,
     const std::string& manifest_url_prefix,
     PrecacheFetcher::PrecacheDelegate* precache_delegate)
     : starting_hosts_(starting_hosts),
       request_context_(request_context),
       manifest_url_prefix_(manifest_url_prefix),
-      precache_delegate_(precache_delegate) {
+      precache_delegate_(precache_delegate),
+      total_response_bytes_(0),
+      num_manifest_urls_to_fetch_(0) {
   DCHECK(request_context_.get());  // Request context must be non-NULL.
   DCHECK(precache_delegate_);  // Precache delegate must be non-NULL.
 
   DCHECK_NE(GURL(), GetConfigURL())
       << "Could not determine the precache config settings URL.";
   DCHECK_NE(std::string(), GetDefaultManifestURLPrefix())
       << "Could not determine the default precache manifest URL prefix.";
 }
 
 PrecacheFetcher::~PrecacheFetcher() {
+  // Number of manifests for which we have downloaded all resources.
+  int manifests_completed =
+      num_manifest_urls_to_fetch_ - manifest_urls_to_fetch_.size();
+
+  // If there are resource URLs left to fetch, the last manifest is not yet
+  // completed.
+  if (!resource_urls_to_fetch_.empty())
+    --manifests_completed;
+
+  DCHECK_GE(manifests_completed, 0);
+  int percent_completed = num_manifest_urls_to_fetch_ == 0
+                              ? 0
+                              : (static_cast<double>(manifests_completed) /
+                                 num_manifest_urls_to_fetch_ * 100);
+  UMA_HISTOGRAM_PERCENTAGE("Precache.Fetch.PercentCompleted",
+                           percent_completed);
+  UMA_HISTOGRAM_CUSTOM_COUNTS("Precache.Fetch.ResponseBytes",
+                              total_response_bytes_, 1, kMaxResponseBytes, 50);
 }
 
 void PrecacheFetcher::Start() {
   DCHECK(!fetcher_);  // Start shouldn't be called repeatedly.
 
   GURL config_url = GetConfigURL();
   DCHECK(config_url.is_valid());
 
   // Fetch the precache configuration settings from the server.
   fetcher_.reset(new Fetcher(request_context_.get(), config_url,
                              base::Bind(&PrecacheFetcher::OnConfigFetchComplete,
                                         base::Unretained(this)),
                              false /* ignore_response_body */));
 }
 
 void PrecacheFetcher::StartNextFetch() {
+  total_response_bytes_ += fetcher_->response_bytes();
+
   if (!resource_urls_to_fetch_.empty()) {
     // Fetch the next resource URL.
     fetcher_.reset(
         new Fetcher(request_context_.get(), resource_urls_to_fetch_.front(),
                     base::Bind(&PrecacheFetcher::OnResourceFetchComplete,
                                base::Unretained(this)),
                     true /* ignore_response_body */));
 
     resource_urls_to_fetch_.pop_front();
     return;
@@ skipping 42 matching lines @@
     if (rank > config.top_sites_count())
       break;
     unique_manifest_urls.insert(ConstructManifestURL(prefix, host));
   }
 
   for (const std::string& url : config.forced_site())
     unique_manifest_urls.insert(ConstructManifestURL(prefix, url));
 
   for (const std::string& manifest_url : unique_manifest_urls)
     manifest_urls_to_fetch_.push_back(GURL(manifest_url));
+  num_manifest_urls_to_fetch_ = manifest_urls_to_fetch_.size();
 
   StartNextFetch();
 }
 
 void PrecacheFetcher::OnManifestFetchComplete(const URLFetcher& source) {
   PrecacheManifest manifest;
 
   if (ParseProtoFromFetchResponse(source, &manifest)) {
     for (int i = 0; i < manifest.resource_size(); ++i) {
       if (manifest.resource(i).has_url()) {
         resource_urls_to_fetch_.push_back(GURL(manifest.resource(i).url()));
       }
     }
   }
 
   StartNextFetch();
 }
 
 void PrecacheFetcher::OnResourceFetchComplete(const URLFetcher& source) {
   // The resource has already been put in the cache during the fetch process, so
   // nothing more needs to be done for the resource.
   StartNextFetch();
 }
 
 }  // namespace precache