Remove some unused cloud print histograms.

chrome/service/service_utility_process_host.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 "chrome/service/service_utility_process_host.h"
 
 #include <stdint.h>
 
 #include <queue>
 #include <utility>
@@ skipping 164 matching lines @@
 
 ServiceUtilityProcessHost::~ServiceUtilityProcessHost() {
   // We need to kill the child process when the host dies.
   process_.Terminate(content::RESULT_CODE_NORMAL_EXIT, false);
 }
 
 bool ServiceUtilityProcessHost::StartRenderPDFPagesToMetafile(
     const base::FilePath& pdf_path,
     const printing::PdfRenderSettings& render_settings) {
   ReportUmaEvent(SERVICE_UTILITY_METAFILE_REQUEST);
-  start_time_ = base::Time::Now();
   base::File pdf_file(pdf_path, base::File::FLAG_OPEN | base::File::FLAG_READ |
                                     base::File::FLAG_DELETE_ON_CLOSE);
   if (!pdf_file.IsValid() || !StartProcess(false))
     return false;
 
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
 
   pdf_to_emf_state_.reset(new PdfToEmfState(this));
   return pdf_to_emf_state_->Start(std::move(pdf_file), render_settings);
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
   ReportUmaEvent(SERVICE_UTILITY_CAPS_REQUEST);
-  start_time_ = base::Time::Now();
   if (!StartProcess(true))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
   return Send(new ChromeUtilityMsg_GetPrinterCapsAndDefaults(printer_name));
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterSemanticCapsAndDefaults(
     const std::string& printer_name) {
   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST);
-  start_time_ = base::Time::Now();
   if (!StartProcess(true))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
   return Send(
       new ChromeUtilityMsg_GetPrinterSemanticCapsAndDefaults(printer_name));
 }
 
 bool ServiceUtilityProcessHost::StartProcess(bool no_sandbox) {
   std::string mojo_channel_token =
@@ skipping 71 matching lines @@
   return ChildProcessHost::GetChildPath(ChildProcessHost::CHILD_NORMAL);
 }
 
 void ServiceUtilityProcessHost::OnChildDisconnected() {
   if (waiting_for_reply_) {
     // If we are yet to receive a reply then notify the client that the
     // child died.
     client_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Client::OnChildDied, client_.get()));
     ReportUmaEvent(SERVICE_UTILITY_DISCONNECTED);
-    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityDisconnectTime",
-                        base::Time::Now() - start_time_);
   }
   delete this;
 }
 
 bool ServiceUtilityProcessHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceUtilityProcessHost, message)
     IPC_MESSAGE_HANDLER(
         ChromeUtilityHostMsg_RenderPDFPagesToMetafiles_PageCount,
         OnRenderPDFPagesToMetafilesPageCount)
@@ skipping 49 matching lines @@
       base::Bind(&ServiceUtilityProcessHost::OnMetafileSpooled,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ServiceUtilityProcessHost::OnPDFToEmfFinished(bool success) {
   if (!waiting_for_reply_)
     return;
   waiting_for_reply_ = false;
   if (success) {
     ReportUmaEvent(SERVICE_UTILITY_METAFILE_SUCCEEDED);
-    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileTime",
-                        base::Time::Now() - start_time_);
   } else {
     ReportUmaEvent(SERVICE_UTILITY_METAFILE_FAILED);
-    UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileFailTime",
-                        base::Time::Now() - start_time_);
   }
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::OnRenderPDFPagesToMetafileDone,
                             client_.get(), success));
   pdf_to_emf_state_.reset();
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsSucceeded(
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_CAPS_SUCCEEDED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsTime",
-                      base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(),
                             true, printer_name, caps_and_defaults));
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsSucceeded(
     const std::string& printer_name,
     const printing::PrinterSemanticCapsAndDefaults& caps_and_defaults) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsTime",
-                      base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults, client_.get(),
                  true, printer_name, caps_and_defaults));
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsFailed(
     const std::string& printer_name) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_CAPS_FAILED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsFailTime",
-                      base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), false,
                  printer_name, printing::PrinterCapsAndDefaults()));
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsFailed(
     const std::string& printer_name) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_FAILED);
-  UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsFailTime",
-                      base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
                             client_.get(), false, printer_name,
                             printing::PrinterSemanticCapsAndDefaults()));
 }
 
 bool ServiceUtilityProcessHost::Client::MetafileAvailable(float scale_factor,
                                                           base::File file) {
   file.Seek(base::File::FROM_BEGIN, 0);
   int64_t size = file.GetLength();
   if (size <= 0) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   std::vector<char> data(size);
   if (file.ReadAtCurrentPos(data.data(), data.size()) != size) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   printing::Emf emf;
   if (!emf.InitFromData(data.data(), data.size())) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   OnRenderPDFPagesToMetafilePageDone(scale_factor, emf);
   return true;
 }