[CUPS] Implement the Print Job notification.

chrome/browser/chromeos/printing/fake_cups_print_job_manager.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 "chrome/browser/chromeos/printing/fake_cups_print_job_manager.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/threading/sequenced_task_runner_handle.h"
+#include "chrome/browser/chromeos/printing/cups_print_job.h"
+#include "chrome/browser/chromeos/printing/cups_print_job_manager_factory.h"
+#include "chrome/browser/notifications/notification.h"
+#include "content/public/browser/browser_context.h"
+
+namespace chromeos {
+
+// static
+int FakeCUPSPrintJobManager::next_job_id_ = 0;
+
+// static
+CUPSPrintJobManager* CUPSPrintJobManager::Get(
+    content::BrowserContext* browser_context) {
+  return CUPSPrintJobManagerFactory::GetForBrowserContext(browser_context);
+}
+
+FakeCUPSPrintJobManager::FakeCUPSPrintJobManager(Profile* profile)
+    : CUPSPrintJobManager(profile), weak_ptr_factory_(this) {}
+
+FakeCUPSPrintJobManager::~FakeCUPSPrintJobManager() {}
+
+bool FakeCUPSPrintJobManager::CreatePrintJob(const std::string& printer_name,
+                                             const std::string& title,
+                                             int total_page_number) {
+  // Create a new print job.
+  std::unique_ptr<CUPSPrintJob> new_job = base::MakeUnique<CUPSPrintJob>(
+      printer_name, next_job_id_++, title, total_page_number);
+  new_job->GetPrinter()->set_display_name(printer_name);
+  print_jobs_.push_back(std::move(new_job));
+
+  // Show the waiting-for-printing notification immediately.
+  base::SequencedTaskRunnerHandle::Get()->PostNonNestableDelayedTask(
+      FROM_HERE,
+      base::Bind(&FakeCUPSPrintJobManager::ChangePrintJobState,
+                 weak_ptr_factory_.GetWeakPtr(), print_jobs_.back().get()),
+      base::TimeDelta());
+
+  return true;
+}
+
+bool FakeCUPSPrintJobManager::CancelPrintJob(CUPSPrintJob* job) {
+  job->set_state(CUPSPrintJob::STATE_CANCELLED);
+  for (auto observer : observers_)
+    observer->OnPrintJobCancelled(job->job_id());
+
+  // Note: |job| is deleted here.
+  for (auto iter = print_jobs_.begin(); iter != print_jobs_.end(); ++iter) {
+    if (iter->get() == job) {
+      print_jobs_.erase(iter);
+      break;
+    }
+  }
+
+  return true;
+}
+
+bool FakeCUPSPrintJobManager::SuspendPrintJob(CUPSPrintJob* job) {
+  job->set_state(CUPSPrintJob::STATE_SUSPENDED);
+  for (auto observer : observers_)
+    observer->OnPrintJobSuspended(job);
+  return true;
+}
+
+bool FakeCUPSPrintJobManager::ResumePrintJob(CUPSPrintJob* job) {
+  job->set_state(CUPSPrintJob::STATE_RESUMED);
+  for (auto observer : observers_)
+    observer->OnPrintJobResumed(job);
+
+  base::SequencedTaskRunnerHandle::Get()->PostNonNestableDelayedTask(
+      FROM_HERE, base::Bind(&FakeCUPSPrintJobManager::ChangePrintJobState,
+                            weak_ptr_factory_.GetWeakPtr(), job),
+      base::TimeDelta::FromMilliseconds(3000));
+
+  return true;
+}
+
+void FakeCUPSPrintJobManager::ChangePrintJobState(CUPSPrintJob* job) {
+  // |job| might have been deleted.
+  bool found = false;
+  for (auto iter = print_jobs_.begin(); iter != print_jobs_.end(); ++iter) {
+    if (iter->get() == job) {
+      found = true;
+      break;
+    }
+  }
+
+  if (!found || job->state() == CUPSPrintJob::STATE_SUSPENDED ||
+      job->state() == CUPSPrintJob::STATE_ERROR) {
+    return;
+  }
+
+  switch (job->state()) {
+    case CUPSPrintJob::STATE_NONE:
+      job->set_state(CUPSPrintJob::STATE_WAITING);
+      for (auto observer : observers_)
+        observer->OnPrintJobCreated(job);
+      break;
+    case CUPSPrintJob::STATE_WAITING:
+      job->set_state(CUPSPrintJob::STATE_STARTED);
+      for (auto observer : observers_)
+        observer->OnPrintJobStarted(job);
+      break;
+    case CUPSPrintJob::STATE_STARTED:
+      job->set_printed_page_number(job->printed_page_number() + 1);
+      job->set_state(CUPSPrintJob::STATE_PAGE_DONE);
+      for (auto observer : observers_)
+        observer->OnPrintJobUpdated(job);
+      break;
+    case CUPSPrintJob::STATE_PAGE_DONE:
+    case CUPSPrintJob::STATE_RESUMED:
+      if (job->printed_page_number() == job->total_page_number()) {
+        job->set_state(CUPSPrintJob::STATE_DOCUMENT_DONE);
+        for (auto observer : observers_)
+          observer->OnPrintJobDone(job);
+      } else {
+        job->set_printed_page_number(job->printed_page_number() + 1);
+        job->set_state(CUPSPrintJob::STATE_PAGE_DONE);
+        for (auto observer : observers_)
+          observer->OnPrintJobUpdated(job);
+      }
+      break;
+    case CUPSPrintJob::STATE_DOCUMENT_DONE:
+      // Only for testing
+      job->set_state(CUPSPrintJob::STATE_ERROR);
+      job->set_error_code(CUPSPrintJob::UNKNOWN_ERROR);
+      for (auto observer : observers_)
+        observer->OnPrintJobError(job);
+      break;
+    default:
+      break;
+  }
+
+  base::SequencedTaskRunnerHandle::Get()->PostNonNestableDelayedTask(
+      FROM_HERE, base::Bind(&FakeCUPSPrintJobManager::ChangePrintJobState,
+                            weak_ptr_factory_.GetWeakPtr(), job),
+      base::TimeDelta::FromMilliseconds(3000));
+}
+
+}  // namespace chromeos