Use job id from JobEventDetails to create CupsPrintJobs.

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 102 matching lines @@
 
   content::Details<::printing::JobEventDetails> job_details(details);
 
   // DOC_DONE occurs after the print job has been successfully sent to the
   // spooler which is when we begin tracking the print queue.
   if (job_details->type() == ::printing::JobEventDetails::DOC_DONE) {
     const ::printing::PrintedDocument* document = job_details->document();
     DCHECK(document);
     CreatePrintJob(base::UTF16ToUTF8(document->settings().device_name()),
                    base::UTF16ToUTF8(document->settings().title()),
-                   document->page_count());
+                   job_details->job_id(), document->page_count());
   }
 }
 
 bool CupsPrintJobManagerImpl::CreatePrintJob(const std::string& printer_name,
                                              const std::string& title,
+                                             int job_id,
                                              int total_page_number) {
-  // Of the current jobs, find the new one for the printer.
-  ::printing::CupsJob* new_job = nullptr;
-  std::vector<::printing::CupsJob> cups_jobs = cups_connection_.GetJobs();
-  for (auto& job : cups_jobs) {
-    if (printer_name == job.printer_id &&
-        !JobFinished(ConvertState(job.state)) &&
-        !base::ContainsKey(jobs_,
-                           CupsPrintJob::GetUniqueId(printer_name, job.id))) {
-      // We found an untracked job.  It should be ours.
-      new_job = &job;
-      break;
-    }
-  }
-
-  // The started job cannot be found in the queue.
-  if (!new_job) {
-    LOG(WARNING) << "Could not track print job.";
-    return false;
-  }
-
   auto printer =
       chromeos::PrintersManagerFactory::GetForBrowserContext(profile_)
           ->GetPrinter(printer_name);
   if (!printer) {
     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, new_job->id, title,
+  auto cpj = base::MakeUnique<CupsPrintJob>(*printer, job_id, title,
                                             total_page_number);
   std::string key = cpj->GetUniqueId();
   jobs_[key] = std::move(cpj);
-  NotifyJobCreated(jobs_[key].get());
+  CupsPrintJob* job = jobs_[key].get();
+  NotifyJobCreated(job);
 
-  JobStateUpdated(jobs_[key].get(), ConvertState(new_job->state));
+  // Always start jobs in the waiting state.
+  job->set_state(CupsPrintJob::State::STATE_WAITING);
+  NotifyJobUpdated(job);
 
-  ScheduleQuery();
+  ScheduleQuery(base::TimeDelta());
 
   return true;
 }
 
 void CupsPrintJobManagerImpl::ScheduleQuery() {
-  content::BrowserThread::PostDelayedTask(
-      content::BrowserThread::FILE_USER_BLOCKING, FROM_HERE,
-      base::Bind(&CupsPrintJobManagerImpl::QueryCups,
-                 weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kPollRate));
+  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,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(kPollRate));
+  }
 }
 
 // Query CUPS asynchronously.  Post results back to UI thread.
 void CupsPrintJobManagerImpl::QueryCups() {
   std::vector<::printing::CupsJob> jobs = cups_connection_.GetJobs();
 
   content::BrowserThread::PostTask(
       content::BrowserThread::ID::UI, FROM_HERE,
       base::Bind(&CupsPrintJobManagerImpl::UpdateJobs,
                  weak_ptr_factory_.GetWeakPtr(), jobs));
 }
 
 // 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) {
+  in_query_ = false;
+
+  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()) {
       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 (!jobs_.empty())
+  if (!active_jobs.empty()) {
     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();
+  }
 }
 
 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);
@@ skipping 27 matching lines @@
       break;
   }
 }
 
 // static
 CupsPrintJobManager* CupsPrintJobManager::CreateInstance(Profile* profile) {
   return new CupsPrintJobManagerImpl(profile);
 }
 
 }  // namespace chromeos