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

printing/backend/cups_connection.cc

 // Copyright 2016 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 "printing/backend/cups_connection.h"
 
+#include <map>
+#include <set>
 #include <string>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
+#include "printing/backend/cups_jobs.h"
 
 namespace printing {
 
 namespace {
 
-const int kTimeoutMs = 3000;
+constexpr int kTimeoutMs = 3000;
+
+// The number of jobs we'll retrieve for a queue.  We expect a user to queue at
+// most 10 jobs per printer.  If they queue more, they won't receive updates for
+// the 11th job until one finishes.
+constexpr int kProcessingJobsLimit = 10;
+
+// The number of completed jobs that are retrieved.  We only need one update for
+// a completed job to confirm its final status.  We could retrieve one but we
+// retrieve the last 3 in case that many finished between queries.
+constexpr int kCompletedJobsLimit = 3;
 
 class DestinationEnumerator {
  public:
   DestinationEnumerator() {}
 
   static int cups_callback(void* user_data, unsigned flags, cups_dest_t* dest) {
     cups_dest_t* copied_dest;
     cupsCopyDest(dest, 0, &copied_dest);
     reinterpret_cast<DestinationEnumerator*>(user_data)->store_dest(
         copied_dest);
 
     //  keep going
     return 1;
   }
 
   void store_dest(cups_dest_t* dest) { dests_.emplace_back(dest); }
 
   // Returns the collected destinations.
   std::vector<std::unique_ptr<cups_dest_t, DestinationDeleter>>& get_dests() {
     return dests_;
   }
 
  private:
   std::vector<std::unique_ptr<cups_dest_t, DestinationDeleter>> dests_;
 
   DISALLOW_COPY_AND_ASSIGN(DestinationEnumerator);
 };
 
-CupsJob createCupsJob(int job_id,
-                      base::StringPiece job_title,
-                      base::StringPiece printer_id,
-                      ipp_jstate_t state) {
-  CupsJob::JobState converted_state = CupsJob::UNKNOWN;
-  switch (state) {
-    case IPP_JOB_ABORTED:
-      converted_state = CupsJob::ABORTED;
-      break;
-    case IPP_JOB_CANCELLED:
-      converted_state = CupsJob::CANCELED;
-      break;
-    case IPP_JOB_COMPLETED:
-      converted_state = CupsJob::COMPLETED;
-      break;
-    case IPP_JOB_HELD:
-      converted_state = CupsJob::HELD;
-      break;
-    case IPP_JOB_PENDING:
-      converted_state = CupsJob::PENDING;
-      break;
-    case IPP_JOB_PROCESSING:
-      converted_state = CupsJob::PROCESSING;
-      break;
-    case IPP_JOB_STOPPED:
-      converted_state = CupsJob::STOPPED;
-      break;
-    default:
-      NOTREACHED();
-      break;
-  }
-
-  return {job_id, job_title.as_string(), printer_id.as_string(),
-          converted_state};
-}
-
 }  // namespace
 
 CupsConnection::CupsConnection(const GURL& print_server_url,
                                http_encryption_t encryption,
                                bool blocking)
     : print_server_url_(print_server_url),
       cups_encryption_(encryption),
       blocking_(blocking),
       cups_http_(nullptr) {}
 
@@ skipping 62 matching lines @@
   cups_dest_t* dest = cupsGetNamedDest(cups_http_.get(), name.c_str(), nullptr);
   if (!dest)
     return nullptr;
 
   cups_dinfo_t* info = cupsCopyDestInfo(cups_http_.get(), dest);
   return base::MakeUnique<CupsPrinter>(
       cups_http_.get(), std::unique_ptr<cups_dest_t, DestinationDeleter>(dest),
       std::unique_ptr<cups_dinfo_t, DestInfoDeleter>(info));
 }
 
-std::vector<CupsJob> CupsConnection::GetJobs() {
-  cups_job_t* jobs;
-  int num_jobs = cupsGetJobs2(cups_http_.get(),  // http connection
-                              &jobs,             // out param
-                              nullptr,           // all printers
-                              0,                 // all users
-                              CUPS_WHICHJOBS_ALL);
-
-  const JobsDeleter deleter(num_jobs);
-  std::unique_ptr<cups_job_t, const JobsDeleter&> scoped_jobs(jobs, deleter);
-
-  std::vector<CupsJob> job_copies;
-  for (int i = 0; i < num_jobs; i++) {
-    job_copies.push_back(
-        createCupsJob(jobs[i].id, jobs[i].title, jobs[i].dest, jobs[i].state));
+bool CupsConnection::GetJobs(const std::vector<std::string>& printer_ids,
+                             std::vector<QueueStatus>* queues) {
+  DCHECK(queues);
+  if (!Connect()) {
+    LOG(ERROR) << "Could not establish connection to CUPS";
+    return false;
   }
 
-  return job_copies;
+  std::vector<QueueStatus> temp_queues;
+
+  for (const std::string& id : printer_ids) {
+    temp_queues.emplace_back();
+    QueueStatus* queue_status = &temp_queues.back();
+
+    if (!GetPrinterStatus(cups_http_.get(), id,
+                          &queue_status->printer_status)) {
+      LOG(WARNING) << "Could not retrieve printer status for " << id;
+      return false;
+    }
+
+    if (!GetCupsJobs(cups_http_.get(), id, kCompletedJobsLimit, COMPLETED,
+                     &queue_status->jobs)) {
+      LOG(WARNING) << "Could not get completed jobs for " << id;
+      return false;
+    }
+
+    if (!GetCupsJobs(cups_http_.get(), id, kProcessingJobsLimit, PROCESSING,
+                     &queue_status->jobs)) {
+      LOG(WARNING) << "Could not get in progress jobs for " << id;
+      return false;
+    }
+  }
+  queues->insert(queues->end(), temp_queues.begin(), temp_queues.end());
+
+  return true;
 }
 
 std::string CupsConnection::server_name() const {
   return print_server_url_.host();
 }
 
 int CupsConnection::last_error() const {
   return cupsLastError();
 }
 
 }  // namespace printing