Added helper function to log CloudPrint.ServiceUtilityProcessHostEvent histogram.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 50 matching lines @@
   base::FilePath exposed_dir_;
 };
 
 }  // namespace
 
 #endif  // OS_WIN
 
 using content::ChildProcessHost;
 
 namespace {
+
 enum ServiceUtilityProcessHostEvent {
   SERVICE_UTILITY_STARTED,
   SERVICE_UTILITY_DISCONNECTED,
   SERVICE_UTILITY_METAFILE_REQUEST,
   SERVICE_UTILITY_METAFILE_SUCCEEDED,
   SERVICE_UTILITY_METAFILE_FAILED,
   SERVICE_UTILITY_CAPS_REQUEST,
   SERVICE_UTILITY_CAPS_SUCCEEDED,
   SERVICE_UTILITY_CAPS_FAILED,
   SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST,
   SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED,
   SERVICE_UTILITY_SEMANTIC_CAPS_FAILED,
   SERVICE_UTILITY_FAILED_TO_START,
   SERVICE_UTILITY_EVENT_MAX,
 };
+
+void ReportUmaEvent(ServiceUtilityProcessHostEvent id) {
+  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
+                            id,
+                            SERVICE_UTILITY_EVENT_MAX);
+}
+
 }  // namespace
 
 ServiceUtilityProcessHost::ServiceUtilityProcessHost(
     Client* client, base::MessageLoopProxy* client_message_loop_proxy)
         : handle_(base::kNullProcessHandle),
           client_(client),
           client_message_loop_proxy_(client_message_loop_proxy),
           waiting_for_reply_(false) {
   child_process_host_.reset(ChildProcessHost::Create(this));
 }
 
 ServiceUtilityProcessHost::~ServiceUtilityProcessHost() {
   // We need to kill the child process when the host dies.
   base::KillProcess(handle_, content::RESULT_CODE_NORMAL_EXIT, false);
 }
 
 bool ServiceUtilityProcessHost::StartRenderPDFPagesToMetafile(
     const base::FilePath& pdf_path,
     const printing::PdfRenderSettings& render_settings,
     const std::vector<printing::PageRange>& page_ranges) {
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_METAFILE_REQUEST,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_METAFILE_REQUEST);
   start_time_ = base::Time::Now();
 #if !defined(OS_WIN)
   // This is only implemented on Windows (because currently it is only needed
   // on Windows). Will add implementations on other platforms when needed.
   NOTIMPLEMENTED();
   return false;
 #else  // !defined(OS_WIN)
   scratch_metafile_dir_.reset(new base::ScopedTempDir);
   if (!scratch_metafile_dir_->CreateUniqueTempDir())
     return false;
@@ skipping 10 matching lines @@
       new ChromeUtilityMsg_RenderPDFPagesToMetafiles(
           IPC::TakeFileHandleForProcess(pdf_file.Pass(), handle()),
           metafile_path_,
           render_settings,
           page_ranges));
 #endif  // !defined(OS_WIN)
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterCapsAndDefaults(
     const std::string& printer_name) {
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_CAPS_REQUEST,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_CAPS_REQUEST);
   start_time_ = base::Time::Now();
   base::FilePath exposed_path;
   if (!StartProcess(true, exposed_path))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
   return child_process_host_->Send(
       new ChromeUtilityMsg_GetPrinterCapsAndDefaults(printer_name));
 }
 
 bool ServiceUtilityProcessHost::StartGetPrinterSemanticCapsAndDefaults(
     const std::string& printer_name) {
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_REQUEST);
   start_time_ = base::Time::Now();
   base::FilePath exposed_path;
   if (!StartProcess(true, exposed_path))
     return false;
   DCHECK(!waiting_for_reply_);
   waiting_for_reply_ = true;
   return child_process_host_->Send(
       new ChromeUtilityMsg_GetPrinterSemanticCapsAndDefaults(printer_name));
 }
 
 bool ServiceUtilityProcessHost::StartProcess(
     bool no_sandbox,
     const base::FilePath& exposed_dir) {
   std::string channel_id = child_process_host_->CreateChannel();
   if (channel_id.empty())
     return false;
 
   base::FilePath exe_path = GetUtilityProcessCmd();
   if (exe_path.empty()) {
     NOTREACHED() << "Unable to get utility process binary name.";
     return false;
   }
 
   CommandLine cmd_line(exe_path);
   cmd_line.AppendSwitchASCII(switches::kProcessType, switches::kUtilityProcess);
   cmd_line.AppendSwitchASCII(switches::kProcessChannelID, channel_id);
   cmd_line.AppendSwitch(switches::kLang);
 
   if (Launch(&cmd_line, no_sandbox, exposed_dir)) {
-    UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                              SERVICE_UTILITY_STARTED,
-                              SERVICE_UTILITY_EVENT_MAX);
+    ReportUmaEvent(SERVICE_UTILITY_STARTED);
     return true;
   }
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_FAILED_TO_START,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_FAILED_TO_START);
   return false;
 }
 
 bool ServiceUtilityProcessHost::Launch(CommandLine* cmd_line,
                                        bool no_sandbox,
                                        const base::FilePath& exposed_dir) {
 #if !defined(OS_WIN)
   // TODO(sanjeevr): Implement for non-Windows OSes.
   NOTIMPLEMENTED();
   return false;
@@ skipping 19 matching lines @@
 #endif
   return ChildProcessHost::GetChildPath(flags);
 }
 
 void ServiceUtilityProcessHost::OnChildDisconnected() {
   if (waiting_for_reply_) {
     // If we are yet to receive a reply then notify the client that the
     // child died.
     client_message_loop_proxy_->PostTask(
         FROM_HERE, base::Bind(&Client::OnChildDied, client_.get()));
-    UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                              SERVICE_UTILITY_DISCONNECTED,
-                              SERVICE_UTILITY_EVENT_MAX);
+    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)
 #if defined(OS_WIN)
@@ skipping 20 matching lines @@
 }
 
 base::ProcessHandle ServiceUtilityProcessHost::GetHandle() const {
   return handle_;
 }
 
 #if defined(OS_WIN)
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesSucceeded(
     const std::vector<printing::PageRange>& page_ranges,
     double scale_factor) {
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_METAFILE_SUCCEEDED,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_METAFILE_SUCCEEDED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileTime",
                       base::Time::Now() - start_time_);
   DCHECK(waiting_for_reply_);
   waiting_for_reply_ = false;
   // If the metafile was successfully created, we need to take our hands off the
   // scratch metafile directory. The client will delete it when it is done with
   // metafile.
   scratch_metafile_dir_->Take();
 
   // TODO(vitalybuka|scottmg): http://crbug.com/170859: Currently, only one
   // page is printed at a time. This would need to be refactored to change
   // this.
   CHECK_EQ(1u, page_ranges.size());
   CHECK_EQ(page_ranges[0].from, page_ranges[0].to);
   int page_number = page_ranges[0].from;
   client_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Client::MetafileAvailable,
                  client_.get(),
                  metafile_path_.InsertBeforeExtensionASCII(
                      base::StringPrintf(".%d", page_number)),
                  page_number,
                  scale_factor));
 }
 
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafileFailed() {
   DCHECK(waiting_for_reply_);
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_METAFILE_FAILED,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_METAFILE_FAILED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileFailTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Client::OnRenderPDFPagesToMetafileFailed, client_.get()));
 }
 #endif  // defined(OS_WIN)
 
 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsSucceeded(
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   DCHECK(waiting_for_reply_);
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_CAPS_SUCCEEDED,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_CAPS_SUCCEEDED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_message_loop_proxy_->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_);
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_message_loop_proxy_->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_);
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_CAPS_FAILED,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_CAPS_FAILED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsFailTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_message_loop_proxy_->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_);
-  UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceUtilityProcessHostEvent",
-                            SERVICE_UTILITY_SEMANTIC_CAPS_FAILED,
-                            SERVICE_UTILITY_EVENT_MAX);
+  ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_FAILED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsFailTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
   client_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
                  client_.get(), false, printer_name,
                  printing::PrinterSemanticCapsAndDefaults()));
 }
 
@@ skipping 14 matching lines @@
   if (!metafile.InitFromFile(metafile_path)) {
     OnRenderPDFPagesToMetafileFailed();
   } else {
     OnRenderPDFPagesToMetafileSucceeded(metafile,
                                         highest_rendered_page_number,
                                         scale_factor);
   }
 #endif  // defined(OS_WIN)
 }