Remove some unused proxy-related histograms.

net/proxy/dhcp_proxy_script_fetcher_win.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/dhcp_proxy_script_fetcher_win.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/metrics/histogram.h"
 #include "base/threading/sequenced_worker_pool.h"
-#include "base/timer/elapsed_timer.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include <winsock2.h>
 #include <iphlpapi.h>
 #pragma comment(lib, "iphlpapi.lib")
 
 namespace {
 
 // How many threads to use at maximum to do DHCP lookups. This is
@@ skipping 54 matching lines @@
 }
 
 int DhcpProxyScriptFetcherWin::Fetch(base::string16* utf16_text,
                                      const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   if (state_ != STATE_START && state_ != STATE_DONE) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
-  fetch_start_time_ = base::TimeTicks::Now();
-
   state_ = STATE_WAIT_ADAPTERS;
   callback_ = callback;
   destination_string_ = utf16_text;
 
   last_query_ = ImplCreateAdapterQuery();
   GetTaskRunner()->PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           &DhcpProxyScriptFetcherWin::AdapterQuery::GetCandidateAdapterNames,
           last_query_.get()),
       base::Bind(
           &DhcpProxyScriptFetcherWin::OnGetCandidateAdapterNamesDone,
           AsWeakPtr(),
           last_query_));
 
   return ERR_IO_PENDING;
 }
 
 void DhcpProxyScriptFetcherWin::Cancel() {
   DCHECK(CalledOnValidThread());
 
-  if (state_ != STATE_DONE) {
-    // We only count this stat if the cancel was explicitly initiated by
-    // our client, and if we weren't already in STATE_DONE.
-    UMA_HISTOGRAM_TIMES("Net.DhcpWpadCancelTime",
-                        base::TimeTicks::Now() - fetch_start_time_);
-  }
-
   CancelImpl();
 }
 
 void DhcpProxyScriptFetcherWin::CancelImpl() {
   DCHECK(CalledOnValidThread());
 
   if (state_ != STATE_DONE) {
     callback_.Reset();
     wait_timer_.Stop();
     state_ = STATE_DONE;
@@ skipping 88 matching lines @@
   if (state_ == STATE_NO_RESULTS) {
     state_ = STATE_SOME_RESULTS;
     wait_timer_.Start(FROM_HERE,
         ImplGetMaxWait(), this, &DhcpProxyScriptFetcherWin::OnWaitTimer);
   }
 }
 
 void DhcpProxyScriptFetcherWin::OnWaitTimer() {
   DCHECK_EQ(state_, STATE_SOME_RESULTS);
 
-  // These are intended to help us understand whether our timeout may
-  // be too aggressive or not aggressive enough.
-  UMA_HISTOGRAM_COUNTS_100("Net.DhcpWpadNumAdaptersAtWaitTimer",
-                           fetchers_.size());
-  UMA_HISTOGRAM_COUNTS_100("Net.DhcpWpadNumPendingAdaptersAtWaitTimer",
-                           num_pending_fetchers_);
-
   TransitionToDone();
 }
 
 void DhcpProxyScriptFetcherWin::TransitionToDone() {
   DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS);
 
   int result = ERR_PAC_NOT_IN_DHCP;  // Default if no fetchers.
   if (!fetchers_.empty()) {
     // Scan twice for the result; once through the whole list for success,
     // then if no success, return result for most preferred network adapter,
@@ skipping 24 matching lines @@
       }
     }
   }
 
   CompletionCallback callback = callback_;
   CancelImpl();
   DCHECK_EQ(state_, STATE_DONE);
   DCHECK(fetchers_.empty());
   DCHECK(callback_.is_null());  // Invariant of data.
 
-  UMA_HISTOGRAM_TIMES("Net.DhcpWpadCompletionTime",
-                      base::TimeTicks::Now() - fetch_start_time_);
-
-  if (result != OK) {
-    UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-        "Net.DhcpWpadFetchError", std::abs(result), GetAllErrorCodesForUma());
-  }
-
   // We may be deleted re-entrantly within this outcall.
   callback.Run(result);
 }
 
 int DhcpProxyScriptFetcherWin::num_pending_fetchers() const {
   return num_pending_fetchers_;
 }
 
 URLRequestContext* DhcpProxyScriptFetcherWin::url_request_context() const {
   return url_request_context_;
@@ skipping 24 matching lines @@
   DCHECK(adapter_names);
   adapter_names->clear();
 
   // The GetAdaptersAddresses MSDN page recommends using a size of 15000 to
   // avoid reallocation.
   ULONG adapters_size = 15000;
   scoped_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> adapters;
   ULONG error = ERROR_SUCCESS;
   int num_tries = 0;
 
-  base::ElapsedTimer time_api_access;
   do {
     adapters.reset(static_cast<IP_ADAPTER_ADDRESSES*>(malloc(adapters_size)));
     // Return only unicast addresses, and skip information we do not need.
     error = GetAdaptersAddresses(AF_UNSPEC,
                                  GAA_FLAG_SKIP_ANYCAST |
                                  GAA_FLAG_SKIP_MULTICAST |
                                  GAA_FLAG_SKIP_DNS_SERVER |
                                  GAA_FLAG_SKIP_FRIENDLY_NAME,
                                  NULL,
                                  adapters.get(),
                                  &adapters_size);
     ++num_tries;
   } while (error == ERROR_BUFFER_OVERFLOW && num_tries <= 3);
 
-  // This is primarily to validate our belief that the GetAdaptersAddresses API
-  // function is fast enough to call synchronously from the network thread.
-  UMA_HISTOGRAM_TIMES("Net.DhcpWpadGetAdaptersAddressesTime",
-                      time_api_access.Elapsed());
-
-  if (error != ERROR_SUCCESS) {
-    UMA_HISTOGRAM_CUSTOM_ENUMERATION(
-        "Net.DhcpWpadGetAdaptersAddressesError",
-        error,
-        base::CustomHistogram::ArrayToCustomRanges(
-            kGetAdaptersAddressesErrors,
-            arraysize(kGetAdaptersAddressesErrors)));
-  }
-
   if (error == ERROR_NO_DATA) {
     // There are no adapters that we care about.
     return true;
   }
 
   if (error != ERROR_SUCCESS) {
     LOG(WARNING) << "Unexpected error retrieving WPAD configuration from DHCP.";
     return false;
   }
 
@@ skipping 25 matching lines @@
     DhcpProxyScriptFetcherWin::AdapterQuery::adapter_names() const {
   return adapter_names_;
 }
 
 bool DhcpProxyScriptFetcherWin::AdapterQuery::ImplGetCandidateAdapterNames(
     std::set<std::string>* adapter_names) {
   return DhcpProxyScriptFetcherWin::GetCandidateAdapterNames(adapter_names);
 }
 
 }  // namespace net