chrome/browser/printing/print_job_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/printing/print_job_manager.h"
   6
   7 #include "chrome/browser/chrome_notification_types.h"
   8 #include "chrome/browser/printing/print_job.h"
   9 #include "chrome/browser/printing/printer_query.h"
  10 #include "content/public/browser/browser_thread.h"
  11 #include "content/public/browser/notification_service.h"
  12 #include "printing/printed_document.h"
  13 #include "printing/printed_page.h"
  14
  15 namespace printing {
  16
  17 PrintQueriesQueue::PrintQueriesQueue() {
  18 }
  19
  20 PrintQueriesQueue::~PrintQueriesQueue() {
  21   base::AutoLock lock(lock_);
  22   queued_queries_.clear();
  23 }
  24
  25 void PrintQueriesQueue::SetDestination(PrintDestinationInterface* destination) {
  26   base::AutoLock lock(lock_);
  27   destination_ = destination;
  28 }
  29
  30 void PrintQueriesQueue::QueuePrinterQuery(PrinterQuery* job) {
  31   base::AutoLock lock(lock_);
  32   DCHECK(job);
  33   queued_queries_.push_back(make_scoped_refptr(job));
  34   DCHECK(job->is_valid());
  35 }
  36
  37 scoped_refptr<PrinterQuery> PrintQueriesQueue::PopPrinterQuery(
  38     int document_cookie) {
  39   base::AutoLock lock(lock_);
  40   for (PrinterQueries::iterator itr = queued_queries_.begin();
  41        itr != queued_queries_.end(); ++itr) {
  42     if ((*itr)->cookie() == document_cookie && !(*itr)->is_callback_pending()) {
  43       scoped_refptr<printing::PrinterQuery> current_query(*itr);
  44       queued_queries_.erase(itr);
  45       DCHECK(current_query->is_valid());
  46       return current_query;
  47     }
  48   }
  49   return NULL;
  50 }
  51
  52 scoped_refptr<PrinterQuery> PrintQueriesQueue::CreatePrinterQuery() {
  53   scoped_refptr<PrinterQuery> job = new printing::PrinterQuery;
  54   base::AutoLock lock(lock_);
  55   job->SetWorkerDestination(destination_);
  56   return job;
  57 }
  58
  59 void PrintQueriesQueue::Shutdown() {
  60   base::AutoLock lock(lock_);
  61   queued_queries_.clear();
  62   destination_ = NULL;
  63 }
  64
  65 PrintJobManager::PrintJobManager() : is_shutdown_(false) {
  66   registrar_.Add(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
  67                  content::NotificationService::AllSources());
  68 }
  69
  70 PrintJobManager::~PrintJobManager() {
  71 }
  72
  73 scoped_refptr<PrintQueriesQueue> PrintJobManager::queue() {
  74   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  75   if (!queue_)
  76     queue_ = new PrintQueriesQueue();
  77   return queue_;
  78 }
  79
  80 void PrintJobManager::Shutdown() {
  81   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  82   DCHECK(!is_shutdown_);
  83   is_shutdown_ = true;
  84   registrar_.RemoveAll();
  85   StopJobs(true);
  86   if (queue_)
  87     queue_->Shutdown();
  88   queue_ = NULL;
  89 }
  90
  91 void PrintJobManager::StopJobs(bool wait_for_finish) {
  92   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  93   // Copy the array since it can be modified in transit.
  94   PrintJobs to_stop;
  95   to_stop.swap(current_jobs_);
  96
  97   for (PrintJobs::const_iterator job = to_stop.begin(); job != to_stop.end();
  98        ++job) {
  99     // Wait for two minutes for the print job to be spooled.
 100     if (wait_for_finish)
 101       (*job)->FlushJob(base::TimeDelta::FromMinutes(2));
 102     (*job)->Stop();
 103   }
 104 }
 105
 106 void PrintJobManager::Observe(int type,
 107                               const content::NotificationSource& source,
 108                               const content::NotificationDetails& details) {
 109   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 110   switch (type) {
 111     case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
 112       OnPrintJobEvent(content::Source<PrintJob>(source).ptr(),
 113                       *content::Details<JobEventDetails>(details).ptr());
 114       break;
 115     }
 116     default: {
 117       NOTREACHED();
 118       break;
 119     }
 120   }
 121 }
 122
 123 void PrintJobManager::OnPrintJobEvent(
 124     PrintJob* print_job,
 125     const JobEventDetails& event_details) {
 126   switch (event_details.type()) {
 127     case JobEventDetails::NEW_DOC: {
 128       DCHECK(current_jobs_.end() == current_jobs_.find(print_job));
 129       // Causes a AddRef().
 130       current_jobs_.insert(print_job);
 131       break;
 132     }
 133     case JobEventDetails::JOB_DONE: {
 134       DCHECK(current_jobs_.end() != current_jobs_.find(print_job));
 135       current_jobs_.erase(print_job);
 136       break;
 137     }
 138     case JobEventDetails::FAILED: {
 139       current_jobs_.erase(print_job);
 140       break;
 141     }
 142     case JobEventDetails::USER_INIT_DONE:
 143     case JobEventDetails::USER_INIT_CANCELED:
 144     case JobEventDetails::DEFAULT_INIT_DONE:
 145     case JobEventDetails::NEW_PAGE:
 146     case JobEventDetails::PAGE_DONE:
 147     case JobEventDetails::DOC_DONE:
 148     case JobEventDetails::ALL_PAGES_REQUESTED: {
 149       // Don't care.
 150       break;
 151     }
 152     default: {
 153       NOTREACHED();
 154       break;
 155     }
 156   }
 157 }
 158
 159 }  // namespace printing