Refine notifications for print jobs in progress.

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/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.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"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "printing/backend/cups_connection.h"
 #include "printing/printed_document.h"
 
 namespace {
 
 // The rate in milliseconds at which we will poll CUPS for print job updates.
 const int kPollRate = 1000;
 
+// How long we'll wait to connect to a printer before declaring an error.
+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;
+
 // Returns the equivalient CupsPrintJob#State from a CupsJob#JobState.
 chromeos::CupsPrintJob::State ConvertState(printing::CupsJob::JobState state) {
-  using cpj = chromeos::CupsPrintJob::State;
-
   switch (state) {
     case printing::CupsJob::PENDING:
-      return cpj::STATE_WAITING;
+      return State::STATE_WAITING;
     case printing::CupsJob::HELD:
-      return cpj::STATE_SUSPENDED;
+      return State::STATE_SUSPENDED;
     case printing::CupsJob::PROCESSING:
-      return cpj::STATE_STARTED;
+      return State::STATE_STARTED;
     case printing::CupsJob::CANCELED:
-      return cpj::STATE_CANCELLED;
+      return State::STATE_CANCELLED;
     case printing::CupsJob::COMPLETED:
-      return cpj::STATE_DOCUMENT_DONE;
+      return State::STATE_DOCUMENT_DONE;
     case printing::CupsJob::STOPPED:
-      return cpj::STATE_SUSPENDED;
+      return State::STATE_SUSPENDED;
     case printing::CupsJob::ABORTED:
-      return cpj::STATE_ERROR;
+      return State::STATE_ERROR;
     case printing::CupsJob::UNKNOWN:
       break;
   }
 
   NOTREACHED();
 
-  return cpj::STATE_NONE;
+  return State::STATE_NONE;
 }
 
 chromeos::QueryResult QueryCups(::printing::CupsConnection* connection,
                                 const std::vector<std::string>& printer_ids) {
   chromeos::QueryResult result;
   result.success = connection->GetJobs(printer_ids, &result.queues);
   return result;
 }
 
+// Returns true if |printer_status|.reasons contains |reason|.
+bool ContainsReason(const printing::PrinterStatus printer_status,
+                    PrinterReason::Reason reason) {
+  return std::find_if(printer_status.reasons.begin(),
+                      printer_status.reasons.end(),
+                      [&reason](const PrinterReason& r) {
+                        return r.reason == reason;
+                      }) != printer_status.reasons.end();
+}
+
+// Extracts an ErrorCode from PrinterStatus#reasons.  Returns NO_ERROR if there
+// are no reasons which indicate an error.
+chromeos::CupsPrintJob::ErrorCode ErrorCodeFromReasons(
+    const printing::PrinterStatus& printer_status) {
+  for (const auto& reason : printer_status.reasons) {
+    switch (reason.reason) {
+      case PrinterReason::MEDIA_JAM:
+      case PrinterReason::MEDIA_EMPTY:
+      case PrinterReason::MEDIA_NEEDED:
+      case PrinterReason::MEDIA_LOW:
+        return chromeos::CupsPrintJob::ErrorCode::PAPER_JAM;
+      case PrinterReason::TONER_EMPTY:
+      case PrinterReason::TONER_LOW:
+        return chromeos::CupsPrintJob::ErrorCode::OUT_OF_INK;
+      default:
+        break;
+    }
+  }
+  return chromeos::CupsPrintJob::ErrorCode::NO_ERROR;
+}
+
+// Check if the job should timeout.  Returns true if the job has timed out.
+bool EnforceTimeout(const printing::CupsJob& job,
+                    chromeos::CupsPrintJob* print_job) {
+  // Check to see if we should time out.
+  base::TimeDelta time_waiting =
+      base::Time::Now() - base::Time::FromTimeT(job.processing_started);
+  if (time_waiting > base::TimeDelta::FromSeconds(kConnectingTimeout)) {
+    print_job->set_state(chromeos::CupsPrintJob::State::STATE_ERROR);
+    print_job->set_error_code(
+        chromeos::CupsPrintJob::ErrorCode::PRINTER_UNREACHABLE);
+    LOG(WARNING) << "Connecting to printer timed out";
+    return true;
+  }
+
+  return false;
+}
+
+// Update the current printed page.  Returns true of the page has been updated.
+bool UpdateCurrentPage(const printing::CupsJob& job,
+                       chromeos::CupsPrintJob* print_job) {
+  bool pages_updated = false;
+  if (job.current_pages <= 0) {
+    print_job->set_printed_page_number(0);
+    print_job->set_state(State::STATE_STARTED);
+  } else {
+    pages_updated = job.current_pages != print_job->printed_page_number();
+    print_job->set_printed_page_number(job.current_pages);
+    print_job->set_state(State::STATE_PAGE_DONE);
+  }
+
+  return pages_updated;
+}
+
+// Updates the state of a print job based on |printer_status| and |job|. Returns
+// true if observers need to be notified of an update.
+bool UpdatePrintJob(const printing::PrinterStatus& printer_status,
+                    const printing::CupsJob& job,
+                    chromeos::CupsPrintJob* print_job) {
+  DCHECK_EQ(job.id, print_job->job_id());
+
+  State old_state = print_job->state();
+
+  bool pages_updated = false;
+  switch (job.state) {
+    case printing::CupsJob::PROCESSING:
+      if (ContainsReason(printer_status, PrinterReason::CONNECTING_TO_DEVICE)) {
+        EnforceTimeout(job, print_job);

[Carlson, 2017/03/14 21:54:05]

I suspect you meant to use the return value for EnforceTimeout().

[skau, 2017/03/15 01:29:09]

I did.  But I actually need it later since the change is going to be a little
tricky.

+        break;
+      }
+      pages_updated = UpdateCurrentPage(job, print_job);
+      break;
+    case printing::CupsJob::COMPLETED:
+      DCHECK_GE(job.current_pages, print_job->total_page_number());
+      print_job->set_state(State::STATE_DOCUMENT_DONE);
+      break;
+    case printing::CupsJob::ABORTED:
+    case printing::CupsJob::CANCELED:
+      print_job->set_error_code(ErrorCodeFromReasons(printer_status));
+    // fall through
+    default:
+      print_job->set_state(ConvertState(job.state));
+      break;
+  }
+
+  return print_job->state() != old_state || pages_updated;
+}
+
 }  // namespace
 
 namespace chromeos {
 
 CupsPrintJobManagerImpl::CupsPrintJobManagerImpl(Profile* profile)
     : CupsPrintJobManager(profile),
       cups_connection_(GURL(), HTTP_ENCRYPT_NEVER, false),
       weak_ptr_factory_(this) {
   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
                  content::NotificationService::AllSources());
@@ skipping 136 matching lines @@
   std::vector<std::string> active_jobs;
   for (const auto& queue : queues) {
     for (auto& job : queue.jobs) {
       std::string key = CupsPrintJob::GetUniqueId(job.printer_id, job.id);
       const auto& entry = jobs_.find(key);
       if (entry == jobs_.end())
         continue;
 
       CupsPrintJob* print_job = entry->second.get();
 
-      // Update a job we're tracking.
-      JobStateUpdated(print_job, ConvertState(job.state));
+      if (UpdatePrintJob(queue.printer_status, job, print_job)) {
+        // The state of the job changed, notify observers.
+        NotifyJobStateUpdate(print_job);
+      }
 
       // Cleanup completed jobs.
       if (print_job->IsJobFinished()) {
         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.
-    JobStateUpdated(entry.second.get(), CupsPrintJob::State::STATE_ERROR);
+    CupsPrintJob* job = entry.second.get();
+    job->set_state(CupsPrintJob::State::STATE_ERROR);
+    NotifyJobStateUpdate(job);
   }
 
   jobs_.clear();
 }
 
-void CupsPrintJobManagerImpl::JobStateUpdated(CupsPrintJob* job,
-                                              CupsPrintJob::State new_state) {
-  if (job->state() == new_state)
-    return;
-
-  // We don't track state transitions because some of them might be missed due
-  // to how we query jobs.
-  job->set_state(new_state);
-  switch (new_state) {
-    case CupsPrintJob::State::STATE_NONE:
+void CupsPrintJobManagerImpl::NotifyJobStateUpdate(CupsPrintJob* job) {
+  switch (job->state()) {
+    case State::STATE_NONE:
       // State does not require notification.
       break;
-    case CupsPrintJob::State::STATE_WAITING:
+    case State::STATE_WAITING:
       NotifyJobUpdated(job);
       break;
-    case CupsPrintJob::State::STATE_STARTED:
+    case State::STATE_STARTED:
       NotifyJobStarted(job);
       break;
-    case CupsPrintJob::State::STATE_RESUMED:
+    case State::STATE_PAGE_DONE:
+      NotifyJobUpdated(job);
+      break;
+    case State::STATE_RESUMED:
       NotifyJobResumed(job);
       break;
-    case CupsPrintJob::State::STATE_SUSPENDED:
+    case State::STATE_SUSPENDED:
       NotifyJobSuspended(job);
       break;
-    case CupsPrintJob::State::STATE_CANCELLED:
+    case State::STATE_CANCELLED:
       NotifyJobCanceled(job);
       break;
-    case CupsPrintJob::State::STATE_ERROR:
+    case State::STATE_ERROR:
       NotifyJobError(job);
       break;
-    case CupsPrintJob::State::STATE_PAGE_DONE:
-      NOTREACHED() << "CUPS does not surface this state so it's not expected";
-      break;
-    case CupsPrintJob::State::STATE_DOCUMENT_DONE:
+    case State::STATE_DOCUMENT_DONE:
       NotifyJobDone(job);
       break;
   }
 }
 
 // static
 CupsPrintJobManager* CupsPrintJobManager::CreateInstance(Profile* profile) {
   return new CupsPrintJobManagerImpl(profile);
 }
 
 }  // namespace chromeos