Remove Net.ProxyService.* histograms.

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 <cmath>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
-#include "base/metrics/histogram_macros.h"
-#include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/proxy_delegate.h"
 #include "net/base/url_util.h"
 #include "net/log/net_log_capture_mode.h"
@@ skipping 825 matching lines @@
   // Returns true if Cancel() has been called.
   bool was_cancelled() const {
     return user_callback_.is_null();
   }
 
   // Helper to call after ProxyResolver completion (both synchronous and
   // asynchronous). Fixes up the result that is to be returned to user.
   int QueryDidComplete(int result_code) {
     DCHECK(!was_cancelled());
 
-    // This state is cleared when resolve_job_ is reset below.
-    bool script_executed = is_started();
-
     // Clear |resolve_job_| so is_started() returns false while
     // DidFinishResolvingProxy() runs.
     resolve_job_.reset();
 
     // Note that DidFinishResolvingProxy might modify |results_|.
     int rv = service_->DidFinishResolvingProxy(url_, method_, proxy_delegate_,
-                                               results_, result_code, net_log_,
-                                               creation_time_, script_executed);
+                                               results_, result_code, net_log_);
 
     // Make a note in the results which configuration was in use at the
     // time of the resolve.
     results_->config_id_ = config_id_;
     results_->config_source_ = config_source_;
     results_->did_use_pac_script_ = true;
     results_->proxy_resolve_start_time_ = creation_time_;
     results_->proxy_resolve_end_time_ = TimeTicks::Now();
 
     // Reset the state associated with in-progress-resolve.
@@ skipping 171 matching lines @@
   // Sanitize the URL before passing it on to the proxy resolver (i.e. PAC
   // script). The goal is to remove sensitive data (like embedded user names
   // and password), and local data (i.e. reference fragment) which does not need
   // to be disclosed to the resolver.
   GURL url = SanitizeUrl(raw_url, sanitize_url_policy_);
 
   // Check if the request can be completed right away. (This is the case when
   // using a direct connection for example).
   int rv = TryToCompleteSynchronously(url, proxy_delegate, result);
   if (rv != ERR_IO_PENDING) {
-    rv = DidFinishResolvingProxy(
-        url, method, proxy_delegate, result, rv, net_log,
-        callback.is_null() ? TimeTicks() : TimeTicks::Now(), false);
+    rv = DidFinishResolvingProxy(url, method, proxy_delegate, result, rv,
+                                 net_log);
     return rv;
   }
 
   if (callback.is_null())
     return ERR_IO_PENDING;
 
   scoped_refptr<PacRequest> req(new PacRequest(
       this, url, method, proxy_delegate, result, callback, net_log));
 
   if (current_state_ == STATE_READY) {
@@ skipping 145 matching lines @@
   script_poller_.reset(new ProxyScriptDeciderPoller(
       base::Bind(&ProxyService::InitializeUsingDecidedConfig,
                  base::Unretained(this)),
       fetched_config_, resolver_factory_->expects_pac_bytes(),
       proxy_script_fetcher_.get(), dhcp_proxy_script_fetcher_.get(), result,
       init_proxy_resolver_->script_data(), NULL));
   script_poller_->set_quick_check_enabled(quick_check_enabled_);
 
   init_proxy_resolver_.reset();
 
-  // When using the out-of-process resolver, creating the resolver can complete
-  // with the ERR_PAC_SCRIPT_TERMINATED result code, which indicates the
-  // resolver process crashed.
-  UMA_HISTOGRAM_BOOLEAN("Net.ProxyService.ScriptTerminatedOnInit",
-                        result == ERR_PAC_SCRIPT_TERMINATED);
-
   if (result != OK) {
     if (fetched_config_.pac_mandatory()) {
       VLOG(1) << "Failed configuring with mandatory PAC script, blocking all "
                  "traffic.";
       config_ = fetched_config_;
       result = ERR_MANDATORY_PROXY_CONFIGURATION_FAILED;
     } else {
       VLOG(1) << "Failed configuring with PAC script, falling-back to manual "
                  "proxy servers.";
       config_ = fetched_config_;
@@ skipping 112 matching lines @@
 void ProxyService::RemovePendingRequest(PacRequest* req) {
   DCHECK(ContainsPendingRequest(req));
   pending_requests_.erase(req);
 }
 
 int ProxyService::DidFinishResolvingProxy(const GURL& url,
                                           const std::string& method,
                                           ProxyDelegate* proxy_delegate,
                                           ProxyInfo* result,
                                           int result_code,
-                                          const NetLogWithSource& net_log,
-                                          base::TimeTicks start_time,
-                                          bool script_executed) {
-  // Don't track any metrics if start_time is 0, which will happen when the user
-  // calls |TryResolveProxySynchronously|.
-  if (!start_time.is_null()) {
-    TimeDelta diff = TimeTicks::Now() - start_time;
-    if (script_executed) {
-      // This function "fixes" the result code, so make sure script terminated
-      // errors are tracked. Only track result codes that were a result of
-      // script execution.
-      UMA_HISTOGRAM_BOOLEAN("Net.ProxyService.ScriptTerminated",
-                            result_code == ERR_PAC_SCRIPT_TERMINATED);
-      UMA_HISTOGRAM_CUSTOM_TIMES("Net.ProxyService.GetProxyUsingScriptTime",
-                                 diff, base::TimeDelta::FromMicroseconds(100),
-                                 base::TimeDelta::FromSeconds(20), 50);
-      UMA_HISTOGRAM_SPARSE_SLOWLY("Net.ProxyService.GetProxyUsingScriptResult",
-                                  std::abs(result_code));
-    }
-    UMA_HISTOGRAM_BOOLEAN("Net.ProxyService.ResolvedUsingScript",
-                          script_executed);
-    UMA_HISTOGRAM_CUSTOM_TIMES("Net.ProxyService.ResolveProxyTime", diff,
-                               base::TimeDelta::FromMicroseconds(100),
-                               base::TimeDelta::FromSeconds(20), 50);
-  }
-
+                                          const NetLogWithSource& net_log) {
   // Log the result of the proxy resolution.
   if (result_code == OK) {
     // Allow the proxy delegate to interpose on the resolution decision,
     // possibly modifying the ProxyInfo.
     if (proxy_delegate)
       proxy_delegate->OnResolveProxy(url, method, *this, result);
 
     net_log.AddEvent(NetLogEventType::PROXY_SERVICE_RESOLVED_PROXY_LIST,
                      base::Bind(&NetLogFinishedResolvingProxyCallback, result));
 
@@ skipping 261 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net