Add some basic UMA for proxy service.

net/proxy/proxy_service.cc

 // Copyright (c) 2012 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 "net/proxy/proxy_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/log/net_log.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 #include "net/proxy/network_delegate_error_observer.h"
 #include "net/proxy/proxy_config_service_fixed.h"
@@ skipping 761 matching lines @@
              const BoundNetLog& net_log)
       : service_(service),
         user_callback_(user_callback),
         results_(results),
         url_(url),
         load_flags_(load_flags),
         network_delegate_(network_delegate),
         resolve_job_(NULL),
         config_id_(ProxyConfig::kInvalidConfigID),
         config_source_(PROXY_CONFIG_SOURCE_UNKNOWN),
-        net_log_(net_log) {
+        net_log_(net_log),
+        request_start_time_(TimeTicks::Now()) {
     DCHECK(!user_callback.is_null());
   }
 
   // Starts the resolve proxy request.
   int Start() {
     DCHECK(!was_cancelled());
     DCHECK(!is_started());
 
     DCHECK(service_->config_.is_valid());
 
@@ skipping 67 matching lines @@
     results_->config_id_ = config_id_;
     results_->config_source_ = config_source_;
     results_->did_use_pac_script_ = true;
     results_->proxy_resolve_start_time_ = proxy_resolve_start_time_;
     results_->proxy_resolve_end_time_ = TimeTicks::Now();
 
     // Reset the state associated with in-progress-resolve.
     config_id_ = ProxyConfig::kInvalidConfigID;
     config_source_ = PROXY_CONFIG_SOURCE_UNKNOWN;
 
+    UMA_HISTOGRAM_CUSTOM_TIMES(
+        "Net.ProxyService.ResolveTime",
+        results_->proxy_resolve_end_time_ - request_start_time_,
+        base::TimeDelta::FromMicroseconds(100),
+        base::TimeDelta::FromSeconds(10), 50);

[eroman, 2015/05/05 23:51:28]

I don't think the upper range is high enough.
I suggest 20 seconds (not much harm in increasing, since the buckets are spaced
logarithmically).

Also I don't know that we can rely on the tick granularity being better than 1ms

[Anand Mistry (off Chromium), 2015/05/06 06:52:18]

Done.
According to time.h, the granularity should be no worse than 1us if there's a
high-resolution timer. Mac and POSIX (Linux/ChromeOS) have this. On windows,
~68% of users have it according to a comment in time_win.cc.

+
     return rv;
   }
 
   BoundNetLog* net_log() { return &net_log_; }
 
   LoadState GetLoadState() const {
     if (is_started())
       return resolver()->GetLoadState(resolve_job_);
     return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
   }
@@ skipping 27 matching lines @@
   GURL url_;
   int load_flags_;
   NetworkDelegate* network_delegate_;
   ProxyResolver::RequestHandle resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   ProxyConfigSource config_source_;  // The source of proxy settings.
   BoundNetLog net_log_;
   // Time when the PAC is started.  Cached here since resetting ProxyInfo also
   // clears the proxy times.
   TimeTicks proxy_resolve_start_time_;
+  // Time when this request is created.
+  TimeTicks request_start_time_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            scoped_ptr<ProxyResolverFactory> resolver_factory,
                            NetLog* net_log)
     : resolver_factory_(resolver_factory.Pass()),
       next_config_id_(1),
       current_state_(STATE_NONE),
@@ skipping 115 matching lines @@
     ApplyProxyConfigIfAvailable();
 
   // Strip away any reference fragments and the username/password, as they
   // are not relevant to proxy resolution.
   GURL url = SimplifyUrlForRequest(raw_url);
 
   // Check if the request can be completed right away. (This is the case when
   // using a direct connection for example).
   int rv = TryToCompleteSynchronously(url, load_flags,
                                       network_delegate, result);
+  UMA_HISTOGRAM_BOOLEAN("Net.ProxyService.ResolvedSynchronously",

[eroman, 2015/05/05 23:51:29]

This is incomplete. Requests can also be completed synchronously via:
TryToCompleteSynchronously

[Anand Mistry (off Chromium), 2015/05/06 06:52:18]

I've changed these around. I hope they're better.

+                        rv != ERR_IO_PENDING);
   if (rv != ERR_IO_PENDING)
     return DidFinishResolvingProxy(url, load_flags, network_delegate,
                                    result, rv, net_log);
 
   if (callback.is_null())
     return ERR_IO_PENDING;
 
   scoped_refptr<PacRequest> req(
       new PacRequest(this, url, load_flags, network_delegate,
                      result, callback, net_log));
@@ skipping 293 matching lines @@
       pending_requests_.begin(), pending_requests_.end(), req);
   pending_requests_.erase(it);
 }
 
 int ProxyService::DidFinishResolvingProxy(const GURL& url,
                                           int load_flags,
                                           NetworkDelegate* network_delegate,
                                           ProxyInfo* result,
                                           int result_code,
                                           const BoundNetLog& net_log) {
+  // This function "fixes" the result code, so make sure script terminated
+  // errors are tracked.
+  UMA_HISTOGRAM_BOOLEAN("Net.ProxyService.ScriptTerminated",
+                        result_code == ERR_PAC_SCRIPT_TERMINATED);
+
   // Log the result of the proxy resolution.
   if (result_code == OK) {
     // Allow the network delegate to interpose on the resolution decision,
     // possibly modifying the ProxyInfo.
     if (network_delegate)
       network_delegate->NotifyResolveProxy(url, load_flags, *this, result);
 
     // When logging all events is enabled, dump the proxy list.
     if (net_log.GetCaptureMode().enabled()) {
       net_log.AddEvent(
@@ skipping 246 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net