Convert to CupsPrintJobManagerImpl to TaskScheduler.

chrome/browser/chromeos/printing/cups_print_job_manager_impl.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINT_JOB_MANAGER_IMPL_H_
 #define CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINT_JOB_MANAGER_IMPL_H_
 
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
+#include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
+#include "base/sequence_checker.h"
+#include "base/sequenced_task_runner.h"
+#include "base/single_thread_task_runner.h"
 #include "chrome/browser/chromeos/printing/cups_print_job.h"
 #include "chrome/browser/chromeos/printing/cups_print_job_manager.h"
 #include "chrome/browser/chromeos/printing/printers_manager.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "printing/backend/cups_connection.h"
 
 class Profile;
 
 namespace chromeos {
 
 struct QueryResult {
   QueryResult();
   QueryResult(const QueryResult& other);
   ~QueryResult();
 
   bool success;
   std::vector<::printing::QueueStatus> queues;
 };
 
+// A wrapper around the CUPS connection to ensure that it's always accessed on
+// the same sequence.
+class CupsWrapper : public base::SupportsWeakPtr<CupsWrapper> {
+ public:
+  CupsWrapper();
+  ~CupsWrapper();
+
+  // Query CUPS for the current jobs for the given |printer_ids|.  Writes result
+  // to |result|.
+  void QueryCups(const std::vector<std::string>& printer_ids,
+                 QueryResult* result);
+
+  // Cancel the print job on the blocking thread.
+  void CancelJobImpl(const std::string& printer_id, const int job_id);
+
+ private:
+  ::printing::CupsConnection cups_connection_;
+  SEQUENCE_CHECKER(sequence_checker_);
+};

[gab, 2017/06/27 17:44:18]

DISALLOW_COPY_AND_ASSIGN

[skau, 2017/06/27 20:25:41]

Done.

+
 class CupsPrintJobManagerImpl : public CupsPrintJobManager,
                                 public content::NotificationObserver {
  public:
   explicit CupsPrintJobManagerImpl(Profile* profile);
   ~CupsPrintJobManagerImpl() override;
 
   // CupsPrintJobManager overrides:
   void CancelPrintJob(CupsPrintJob* job) override;
   bool SuspendPrintJob(CupsPrintJob* job) override;
   bool ResumePrintJob(CupsPrintJob* job) override;
@@ skipping 13 matching lines @@
 
   // Schedule a query of CUPS for print job status with the default delay.
   void ScheduleQuery();
   // Schedule a query of CUPS for print job status with a delay of |delay|.
   void ScheduleQuery(const base::TimeDelta& delay);
 
   // Schedule the CUPS query off the UI thread. Posts results back to UI thread
   // to UpdateJobs.
   void PostQuery();
 
-  // 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,
-                      CupsPrintJob* print_job);
-
   // Process jobs from CUPS and perform notifications.
-  void UpdateJobs(const QueryResult& results);
+  void UpdateJobs(std::unique_ptr<QueryResult> results);
 
   // Mark remaining jobs as errors and remove active jobs.
   void PurgeJobs();
 
-  // Cancel the print job on the blocking thread.
-  void CancelJobImpl(const std::string& printer_id, const int job_id);
-
   // Notify observers that a state update has occured for |job|.
   void NotifyJobStateUpdate(CupsPrintJob* job);
 
   // Ongoing print jobs.
   std::map<std::string, std::unique_ptr<CupsPrintJob>> jobs_;
 
   // Prevents multiple queries from being scheduled simultaneously.
   bool in_query_ = false;
 
   // Records the number of consecutive times the GetJobs query has failed.
   int retry_count_ = 0;
 
-  ::printing::CupsConnection cups_connection_;
+  CupsWrapper cups_wrapper_;

[gab, 2017/06/27 17:44:18]

To ensure this is deleted on its sequence you'll need to use the std::unique_ptr
+ base::OnTaskRunnerDeleter documented @
https://cs.chromium.org/chromium/src/base/sequenced_task_runner.h?rcl=e7e9085...

That way your usage of WeakPtrs will be safe. In fact, you won't need the
WeakPtrs at all as the deletion will always run after all tasks already posted
(and there won't be any tasks posted after per this instance being gone and
|query_runner_| no longer being accessible (other than through
SequencedTaskRunnerHandle::Get() on the sequence itself but tasks on
|query_runner_| don't post back to self so it's fine).

[skau, 2017/06/27 20:25:41]

Thanks!  I was looking for that.

   content::NotificationRegistrar registrar_;
+  // Task runner for queries to CUPS.
+  scoped_refptr<base::SequencedTaskRunner> query_runner_;
+  // Task runner to for the Browser UI thread.
+  scoped_refptr<base::SingleThreadTaskRunner> browser_thread_runner_;
   base::WeakPtrFactory<CupsPrintJobManagerImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CupsPrintJobManagerImpl);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_PRINTING_CUPS_PRINT_JOB_MANAGER_IMPL_H_