Record print job success and print queue size.

chrome/browser/chromeos/printing/cups_print_job_manager_impl.cc

 // Copyright 2017 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/browser/chromeos/printing/cups_print_job_manager_impl.h"
 
 #include <cups/cups.h>
 #include <algorithm>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/printing/cups_print_job.h"
 #include "chrome/browser/chromeos/printing/printers_manager.h"
 #include "chrome/browser/chromeos/printing/printers_manager_factory.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 13 matching lines @@
 const int kConnectingTimeout = 20;
 
 // Threshold for giving up on communicating with CUPS.
 const int kRetryMax = 6;
 
 using State = chromeos::CupsPrintJob::State;
 using ErrorCode = chromeos::CupsPrintJob::ErrorCode;
 
 using PrinterReason = printing::PrinterStatus::PrinterReason;
 
+// Enumeration of print job results for histograms.  Do not modify!
+enum JobResultForHistogram {
+  UNKNOWN = 0,         // unidentified result
+  FINISHED = 1,        // successful completion of job
+  TIMEOUT_CANCEL = 2,  // cancelled due to timeout
+  PRINTER_CANCEL = 3,  // cancelled by printer
+  LOST = 4,            // final state never received
+  RESULT_MAX
+};
+
+// Returns the appropriate JobResultForHistogram for a given |state|.  Only
+// FINISHED and PRINTER_CANCEL are derived from CupsPrintJob::State.
+JobResultForHistogram ResultForHistogram(State state) {
+  switch (state) {
+    case State::STATE_DOCUMENT_DONE:
+      return FINISHED;
+    case State::STATE_CANCELLED:
+      return PRINTER_CANCEL;
+    default:
+      break;
+  }
+
+  return UNKNOWN;
+}
+
+void RecordJobResult(JobResultForHistogram result) {
+  UMA_HISTOGRAM_ENUMERATION("Printing.CUPS.JobResult", TIMEOUT_CANCEL,
+                            RESULT_MAX);
+}
+
 // Returns the equivalient CupsPrintJob#State from a CupsJob#JobState.
 chromeos::CupsPrintJob::State ConvertState(printing::CupsJob::JobState state) {
   switch (state) {
     case printing::CupsJob::PENDING:
       return State::STATE_WAITING;
     case printing::CupsJob::HELD:
       return State::STATE_SUSPENDED;
     case printing::CupsJob::PROCESSING:
       return State::STATE_STARTED;
     case printing::CupsJob::CANCELED:
@@ skipping 157 matching lines @@
                                              int total_page_number) {
   auto printer =
       PrintersManagerFactory::GetForBrowserContext(profile_)->GetPrinter(
           printer_name);
   if (!printer) {
     LOG(WARNING) << "Printer was removed while job was in progress.  It cannot "
                     "be tracked";
     return false;
   }
 
+  // Records the number of jobs we're currently tracking when a new job is
+  // started.  This is equivalent to print queue size in the current
+  // implementation.
+  UMA_HISTOGRAM_EXACT_LINEAR("Printing.CUPS.PrintJobsQueued", jobs_.size(), 20);
+
   // Create a new print job.
   auto cpj = base::MakeUnique<CupsPrintJob>(*printer, job_id, title,
                                             total_page_number);
   std::string key = cpj->GetUniqueId();
   jobs_[key] = std::move(cpj);
 
   CupsPrintJob* job = jobs_[key].get();
   NotifyJobCreated(job);
 
   // Always start jobs in the waiting state.
@@ skipping 111 matching lines @@
 
       CupsPrintJob* print_job = entry->second.get();
 
       if (UpdatePrintJob(queue.printer_status, job, print_job)) {
         // The state of the job changed, notify observers.
         NotifyJobStateUpdate(print_job);
       }
 
       if (print_job->expired()) {
         // Job needs to be forcibly cancelled.
+        RecordJobResult(TIMEOUT_CANCEL);
         CancelPrintJob(print_job);
         // Beware, print_job was removed from jobs_ and deleted.
       } else if (print_job->IsJobFinished()) {
         // Cleanup completed jobs.
+        RecordJobResult(ResultForHistogram(print_job->state()));
         jobs_.erase(entry);
       } else {
         active_jobs.push_back(key);
       }
     }
   }
 
   // Keep polling until all jobs complete or error.
   if (!active_jobs.empty()) {
     // During normal operations, we poll at the default rate.
     ScheduleQuery();
   } else if (!jobs_.empty()) {
     // We're tracking jobs that we didn't receive an update for.  Something bad
     // has happened.
     LOG(ERROR) << "Lost track of (" << jobs_.size() << ") jobs";
     PurgeJobs();
   }
 }
 
 void CupsPrintJobManagerImpl::PurgeJobs() {
   for (const auto& entry : jobs_) {
     // Declare all lost jobs errors.
+    RecordJobResult(LOST);
     CupsPrintJob* job = entry.second.get();
     job->set_state(CupsPrintJob::State::STATE_ERROR);
     NotifyJobStateUpdate(job);
   }
 
   jobs_.clear();
 }
 
 void CupsPrintJobManagerImpl::CancelJobImpl(const std::string& printer_id,
                                             const int job_id) {
@@ skipping 41 matching lines @@
       break;
   }
 }
 
 // static
 CupsPrintJobManager* CupsPrintJobManager::CreateInstance(Profile* profile) {
   return new CupsPrintJobManagerImpl(profile);
 }
 
 }  // namespace chromeos