Implement IPP Get-Jobs and Get-Printer-Attributes requests.

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 <set>
 #include <string>
 #include <utility>
@@ skipping 15 matching lines @@
 #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;
 
+// Threshold for giving up on communicating with CUPS.
+const int kRetryMax = 6;
+
 // 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;
     case printing::CupsJob::HELD:
       return cpj::STATE_SUSPENDED;
     case printing::CupsJob::PROCESSING:
       return cpj::STATE_STARTED;
     case printing::CupsJob::CANCELED:
       return cpj::STATE_CANCELLED;
     case printing::CupsJob::COMPLETED:
       return cpj::STATE_DOCUMENT_DONE;
     case printing::CupsJob::STOPPED:
       return cpj::STATE_SUSPENDED;
     case printing::CupsJob::ABORTED:
       return cpj::STATE_ERROR;
     case printing::CupsJob::UNKNOWN:
       break;
   }
 
   NOTREACHED();
 
   return cpj::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;
+}
+
 }  // 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 53 matching lines @@
     LOG(WARNING) << "Printer was removed while job was in progress.  It cannot "
                     "be tracked";
     return false;
   }
 
   // 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.
   job->set_state(CupsPrintJob::State::STATE_WAITING);
   NotifyJobUpdated(job);
 
   ScheduleQuery(base::TimeDelta());
 
   return true;
 }
 
 void CupsPrintJobManagerImpl::ScheduleQuery() {
   ScheduleQuery(base::TimeDelta::FromMilliseconds(kPollRate));
 }
 
 void CupsPrintJobManagerImpl::ScheduleQuery(const base::TimeDelta& delay) {
   if (!in_query_) {
     in_query_ = true;
-    content::BrowserThread::PostDelayedTask(
-        content::BrowserThread::FILE_USER_BLOCKING, FROM_HERE,
-        base::Bind(&CupsPrintJobManagerImpl::QueryCups,
+
+    base::SequencedTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&CupsPrintJobManagerImpl::PostQuery,
                    weak_ptr_factory_.GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(kPollRate));
+        delay);
   }
 }
 
-// Query CUPS asynchronously.  Post results back to UI thread.
-void CupsPrintJobManagerImpl::QueryCups() {
-  std::vector<::printing::CupsJob> jobs = cups_connection_.GetJobs();
+void CupsPrintJobManagerImpl::PostQuery() {
+  // The set of active printers is expected to be small.
+  std::set<std::string> printer_ids;
+  for (const auto& entry : jobs_) {
+    printer_ids.insert(entry.second->printer().id());
+  }
+  std::vector<std::string> ids{printer_ids.begin(), printer_ids.end()};
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::ID::UI, FROM_HERE,
+  content::BrowserThread::PostTaskAndReplyWithResult(
+      content::BrowserThread::FILE_USER_BLOCKING, FROM_HERE,
+      base::Bind(&QueryCups, &cups_connection_, ids),
       base::Bind(&CupsPrintJobManagerImpl::UpdateJobs,
-                 weak_ptr_factory_.GetWeakPtr(), jobs));
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 // Use job information to update local job states.  Previously completed jobs
 // could be in |jobs| but those are ignored as we will not emit updates for them
 // after they are completed.
-void CupsPrintJobManagerImpl::UpdateJobs(
-    const std::vector<::printing::CupsJob>& jobs) {
+void CupsPrintJobManagerImpl::UpdateJobs(const QueryResult& result) {
+  const std::vector<::printing::QueueStatus>& queues = result.queues;
+
+  // Query has completed.  Allow more queries.
   in_query_ = false;
 
+  // If the query failed, either retry or purge.
+  if (!result.success) {
+    retry_count_++;
+    LOG(WARNING) << "Failed to query CUPS for queue status.  Schedule retry ("
+                 << retry_count_ << ")";
+    if (retry_count_ > kRetryMax) {
+      LOG(ERROR) << "CUPS is unreachable.  Giving up on all jobs.";
+      PurgeJobs();
+    } else {
+      // Schedule another query with a larger delay.
+      DCHECK_GE(1, retry_count_);
+      ScheduleQuery(
+          base::TimeDelta::FromMilliseconds(kPollRate * retry_count_));
+    }
+    return;
+  }
+
+  // A query has completed.  Reset retry counter.
+  retry_count_ = 0;
+
   std::vector<std::string> active_jobs;
-  for (auto& job : jobs) {
-    std::string key = CupsPrintJob::GetUniqueId(job.printer_id, job.id);
-    const auto& entry = jobs_.find(key);
-    if (entry != jobs_.end()) {
+  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));
 
       // 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";
-    for (const auto& entry : jobs_) {
-      // Declare all lost jobs errors.
-      JobStateUpdated(entry.second.get(), CupsPrintJob::State::STATE_ERROR);
-    }
-
-    jobs_.clear();
+    PurgeJobs();
   }
 }
 
+void CupsPrintJobManagerImpl::PurgeJobs() {
+  for (const auto& entry : jobs_) {
+    // Declare all lost jobs errors.
+    JobStateUpdated(entry.second.get(), CupsPrintJob::State::STATE_ERROR);
+  }
+
+  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:
@@ skipping 25 matching lines @@
       break;
   }
 }
 
 // static
 CupsPrintJobManager* CupsPrintJobManager::CreateInstance(Profile* profile) {
   return new CupsPrintJobManagerImpl(profile);
 }
 
 }  // namespace chromeos