chrome/browser/printing/print_job_worker.h

   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 #ifndef CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_H_
   6 #define CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/weak_ptr.h"
  11 #include "base/threading/thread.h"
  12 #include "chrome/browser/printing/printer_query.h"
  13 #include "content/public/browser/browser_thread.h"
  14 #include "printing/page_number.h"
  15 #include "printing/print_job_constants.h"
  16 #include "printing/printing_context.h"
  17
  18 namespace base {
  19 class DictionaryValue;
  20 }
  21
  22 namespace printing {
  23
  24 class PrintJob;
  25 class PrintJobWorkerOwner;
  26 class PrintedDocument;
  27 class PrintedPage;
  28
  29 // Worker thread code. It manages the PrintingContext, which can be blocking
  30 // and/or run a message loop. This is the object that generates most
  31 // NOTIFY_PRINT_JOB_EVENT notifications, but they are generated through a
  32 // NotificationTask task to be executed from the right thread, the UI thread.
  33 // PrintJob always outlives its worker instance.
  34 class PrintJobWorker {
  35  public:
  36   PrintJobWorker(int render_process_id,
  37                  int render_view_id,
  38                  PrintJobWorkerOwner* owner);
  39   virtual ~PrintJobWorker();
  40
  41   void SetNewOwner(PrintJobWorkerOwner* new_owner);
  42
  43   // Initializes the print settings. If |ask_user_for_settings| is true, a
  44   // Print... dialog box will be shown to ask the user his preference.
  45   // |is_scripted| should be true for calls coming straight from window.print().
  46   void GetSettings(
  47       bool ask_user_for_settings,
  48       int document_page_count,
  49       bool has_selection,
  50       MarginType margin_type,
  51       bool is_scripted);
  52
  53   // Set the new print settings.
  54   void SetSettings(scoped_ptr<base::DictionaryValue> new_settings);
  55
  56   // Starts the printing loop. Every pages are printed as soon as the data is
  57   // available. Makes sure the new_document is the right one.
  58   void StartPrinting(PrintedDocument* new_document);
  59
  60   // Updates the printed document.
  61   void OnDocumentChanged(PrintedDocument* new_document);
  62
  63   // Dequeues waiting pages. Called when PrintJob receives a
  64   // NOTIFY_PRINTED_DOCUMENT_UPDATED notification. It's time to look again if
  65   // the next page can be printed.
  66   void OnNewPage();
  67
  68   // This is the only function that can be called in a thread.
  69   void Cancel();
  70
  71   // Returns true if the thread has been started, and not yet stopped.
  72   bool IsRunning() const;
  73
  74   // Posts the given task to be run.
  75   bool PostTask(const tracked_objects::Location& from_here,
  76                 const base::Closure& task);
  77
  78   // Signals the thread to exit in the near future.
  79   void StopSoon();
  80
  81   // Signals the thread to exit and returns once the thread has exited.
  82   void Stop();
  83
  84   // Starts the thread.
  85   bool Start();
  86
  87  protected:
  88   // Retrieves the context for testing only.
  89   PrintingContext* printing_context() { return printing_context_.get(); }
  90
  91  private:
  92   // The shared NotificationService service can only be accessed from the UI
  93   // thread, so this class encloses the necessary information to send the
  94   // notification from the right thread. Most NOTIFY_PRINT_JOB_EVENT
  95   // notifications are sent this way, except USER_INIT_DONE, USER_INIT_CANCELED
  96   // and DEFAULT_INIT_DONE. These three are sent through PrintJob::InitDone().
  97   class NotificationTask;
  98
  99   // Renders a page in the printer.
 100   void SpoolPage(PrintedPage* page);
 101
 102   // Closes the job since spooling is done.
 103   void OnDocumentDone();
 104
 105   // Discards the current document, the current page and cancels the printing
 106   // context.
 107   void OnFailure();
 108
 109   // Asks the user for print settings. Must be called on the UI thread.
 110   // Required on Mac and Linux. Windows can display UI from non-main threads,
 111   // but sticks with this for consistency.
 112   void GetSettingsWithUI(
 113       int document_page_count,
 114       bool has_selection,
 115       bool is_scripted);
 116
 117   // Called on the UI thread to update the print settings.
 118   void UpdatePrintSettings(scoped_ptr<base::DictionaryValue> new_settings);
 119
 120   // Reports settings back to owner_.
 121   void GetSettingsDone(PrintingContext::Result result);
 122
 123   // Use the default settings. When using GTK+ or Mac, this can still end up
 124   // displaying a dialog. So this needs to happen from the UI thread on these
 125   // systems.
 126   void UseDefaultSettings();
 127
 128   // Printing context delegate.
 129   scoped_ptr<PrintingContext::Delegate> printing_context_delegate_;
 130
 131   // Information about the printer setting.
 132   scoped_ptr<PrintingContext> printing_context_;
 133
 134   // The printed document. Only has read-only access.
 135   scoped_refptr<PrintedDocument> document_;
 136
 137   // The print job owning this worker thread. It is guaranteed to outlive this
 138   // object.
 139   PrintJobWorkerOwner* owner_;
 140
 141   // Current page number to print.
 142   PageNumber page_number_;
 143
 144   // Thread to run worker tasks.
 145   base::Thread thread_;
 146
 147   // Tread-safe pointer to task runner of the |thread_|.
 148   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 149
 150   // Used to generate a WeakPtr for callbacks.
 151   base::WeakPtrFactory<PrintJobWorker> weak_factory_;
 152
 153   DISALLOW_COPY_AND_ASSIGN(PrintJobWorker);
 154 };
 155
 156 }  // namespace printing
 157
 158 #endif  // CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_H_