Remove some unused proxy-related histograms.

net/proxy/multi_threaded_proxy_resolver.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/multi_threaded_proxy_resolver.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/proxy/proxy_info.h"
 
 // TODO(eroman): Have the MultiThreadedProxyResolver clear its PAC script
 //               data when SetPacScript fails. That will reclaim memory when
@@ skipping 191 matching lines @@
   GetProxyForURLJob(const GURL& url,
                     ProxyInfo* results,
                     const CompletionCallback& callback,
                     const BoundNetLog& net_log)
       : Job(TYPE_GET_PROXY_FOR_URL, callback),
         results_(results),
         net_log_(net_log),
         url_(url),
         was_waiting_for_thread_(false) {
     DCHECK(!callback.is_null());
-    start_time_ = base::TimeTicks::Now();
   }
 
   BoundNetLog* net_log() { return &net_log_; }
 
   virtual void WaitingForThread() OVERRIDE {
     was_waiting_for_thread_ = true;
     net_log_.BeginEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
   }
 
   virtual void FinishedWaitingForThread() OVERRIDE {
     DCHECK(executor());
 
-    submitted_to_thread_time_ = base::TimeTicks::Now();
-
     if (was_waiting_for_thread_) {
       net_log_.EndEvent(NetLog::TYPE_WAITING_FOR_PROXY_RESOLVER_THREAD);
     }
 
     net_log_.AddEvent(
         NetLog::TYPE_SUBMITTED_TO_RESOLVER_THREAD,
         NetLog::IntegerCallback("thread_number", executor()->thread_number()));
   }
 
   // Runs on the worker thread.
   virtual void Run(scoped_refptr<base::MessageLoopProxy> origin_loop) OVERRIDE {
     ProxyResolver* resolver = executor()->resolver();
     int rv = resolver->GetProxyForURL(
         url_, &results_buf_, CompletionCallback(), NULL, net_log_);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop->PostTask(
         FROM_HERE,
         base::Bind(&GetProxyForURLJob::QueryComplete, this, rv));
   }
 
  protected:
   virtual ~GetProxyForURLJob() {}
 
  private:
   // Runs the completion callback on the origin thread.
   void QueryComplete(int result_code) {
     // The Job may have been cancelled after it was started.
     if (!was_cancelled()) {
-      RecordPerformanceMetrics();
       if (result_code >= OK) {  // Note: unit-tests use values > 0.
         results_->Use(results_buf_);
       }
       RunUserCallback(result_code);
     }
     OnJobCompleted();
   }
 
-  void RecordPerformanceMetrics() {
-    DCHECK(!was_cancelled());
-
-    base::TimeTicks now = base::TimeTicks::Now();
-
-    // Log the total time the request took to complete.
-    UMA_HISTOGRAM_MEDIUM_TIMES("Net.MTPR_GetProxyForUrl_Time",
-                               now - start_time_);
-
-    // Log the time the request was stalled waiting for a thread to free up.
-    UMA_HISTOGRAM_MEDIUM_TIMES("Net.MTPR_GetProxyForUrl_Thread_Wait_Time",
-                               submitted_to_thread_time_ - start_time_);
-  }
-
   // Must only be used on the "origin" thread.
   ProxyInfo* results_;
 
   // Can be used on either "origin" or worker thread.
   BoundNetLog net_log_;
   const GURL url_;
 
   // Usable from within DoQuery on the worker thread.
   ProxyInfo results_buf_;
 
-  base::TimeTicks start_time_;
-  base::TimeTicks submitted_to_thread_time_;
-
   bool was_waiting_for_thread_;
 };
 
 // MultiThreadedProxyResolver::Executor ----------------------------------------
 
 MultiThreadedProxyResolver::Executor::Executor(
     MultiThreadedProxyResolver* coordinator,
     ProxyResolver* resolver,
     int thread_number)
     : coordinator_(coordinator),
@@ skipping 241 matching lines @@
     return;
 
   // Get the next job to process (FIFO). Transfer it from the pending queue
   // to the executor.
   scoped_refptr<Job> job = pending_jobs_.front();
   pending_jobs_.pop_front();
   executor->StartJob(job.get());
 }
 
 }  // namespace net