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:
@@ skipping 16 matching lines @@
 }
 
 // Returns true if |state| represents a terminal state.
 bool JobFinished(chromeos::CupsPrintJob::State state) {
   using chromeos::CupsPrintJob;
   return state == CupsPrintJob::State::STATE_CANCELLED ||
          state == CupsPrintJob::State::STATE_ERROR ||
          state == CupsPrintJob::State::STATE_DOCUMENT_DONE;
 }
 
+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) {
+      PurgeJobs();

[Carlson, 2017/02/24 00:02:08]

Does this deserve a "Giving up" log message?

[skau, 2017/02/28 00:59:58]

Done.

+    } else {
+      // Schedule another query with a larger delay.
+      DCHECK_GE(1, retry_count);
+      ScheduleQuery(base::TimeDelta::FromMilliseconds(kPollRate * retry_count));
+    }
+

[Carlson, 2017/02/24 00:02:08]

Nit:  Remove blank line

[skau, 2017/02/28 00:59:58]

Done.

+    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 (JobFinished(print_job->state())) {
         jobs_.erase(entry);
       } else {
         active_jobs.push_back(key);
       }
     }
   }
 
   // Keep polling until all jobs complete or error.
   if (!active_jobs.empty()) {
     ScheduleQuery();

[Carlson, 2017/02/24 00:02:08]

The fact that the reschedule here doesn't take into account whatever the
requested poll rate was (if the user requested a non-default poll rate) seems
wrong to me.

[skau, 2017/02/28 00:59:58]

Hmm.  The interval isn't intended to be configurable.  The intention is that we
poll every kPollRate unless nothing is polling (where we poll immediately) or
we're encountering errors (where we back off).  Do you find the code difficult
to read or do you think that the behavior should be different?  Or both?

I've added a comment with my intention.

[Carlson, 2017/02/28 01:29:47]

The custom poll rate option is just for testing?  If so, that seems fine.

I don't have a more specific complaint than if the user requests a specific poll
rate, having the reschedule happen at a *different* rate is surprising.

[Carlson, 2017/02/28 18:32:02]

Upon reading this more closely, I'm complaining about an issue that doesn't
exist because I was thinking I was in a different function than I was.  This is
fine.

   } 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