Printing: Convert PrintingContext into an interface implemented by the separate

chrome/browser/printing/print_job_worker.cc

 // Copyright (c) 2006-2008 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/printing/print_job_worker.h"
 
 #include "base/message_loop.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/common/notification_service.h"
@@ skipping 34 matching lines @@
   scoped_refptr<PrintJobWorkerOwner> print_job_;
   scoped_refptr<JobEventDetails> details_;
 };
 
 
 PrintJobWorker::PrintJobWorker(PrintJobWorkerOwner* owner)
     : Thread("Printing_Worker"),
       owner_(owner) {
   // The object is created in the IO thread.
   DCHECK_EQ(owner_->message_loop(), MessageLoop::current());
+
+  printing_context_.reset(PrintingContext::Create());
 }
 
 PrintJobWorker::~PrintJobWorker() {
   // The object is deleted in the UI thread.
   DCHECK_EQ(owner_->message_loop(), MessageLoop::current());
 }
 
 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
   DCHECK(page_number_ == PageNumber::npos());
   owner_ = new_owner;
 }
 
 void PrintJobWorker::GetSettings(bool ask_user_for_settings,
                                  gfx::NativeView parent_view,
                                  int document_page_count,
                                  bool has_selection,
                                  bool use_overlays) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
 
   // Recursive task processing is needed for the dialog in case it needs to be
   // destroyed by a task.
   MessageLoop::current()->SetNestableTasksAllowed(true);
-  printing_context_.SetUseOverlays(use_overlays);
+  printing_context_->set_use_overlays(use_overlays);
 
   if (ask_user_for_settings) {
 #if defined(OS_MACOSX) || defined(USE_X11)
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableMethod(this, &PrintJobWorker::GetSettingsWithUI,
                           parent_view, document_page_count,
                           has_selection));
 #else
-    printing_context_.AskUserForSettings(
+    printing_context_->AskUserForSettings(
         parent_view,
         document_page_count,
         has_selection,
         NewCallback(this, &PrintJobWorker::GetSettingsDone));
 #endif  // defined(OS_MACOSX) || defined(USE_X11)
   } else {
-    PrintingContext::Result result = printing_context_.UseDefaultSettings();
+    PrintingContext::Result result = printing_context_->UseDefaultSettings();
     GetSettingsDone(result);
   }
 }
 
 void PrintJobWorker::GetSettingsDone(PrintingContext::Result result) {
   // Most PrintingContext functions may start a message loop and process
   // message recursively, so disable recursive task processing.
   MessageLoop::current()->SetNestableTasksAllowed(false);
 
   // We can't use OnFailure() here since owner_ may not support notifications.
 
   // PrintJob will create the new PrintedDocument.
   owner_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       owner_,
       &PrintJobWorkerOwner::GetSettingsDone,
-      printing_context_.settings(),
+      printing_context_->settings(),
       result));
 }
 
 #if defined(OS_MACOSX) || defined(USE_X11)
 void PrintJobWorker::GetSettingsWithUI(gfx::NativeView parent_view,
                                        int document_page_count,
                                        bool has_selection) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
-  printing_context_.AskUserForSettings(
+  printing_context_->AskUserForSettings(
       parent_view,
       document_page_count,
       has_selection,
       NewCallback(this, &PrintJobWorker::GetSettingsWithUIDone));
 }
 
 void PrintJobWorker::GetSettingsWithUIDone(PrintingContext::Result result) {
   message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &PrintJobWorker::GetSettingsDone, result));
 }
 #endif  // defined(OS_MACOSX) || defined(USE_X11)
 
 void PrintJobWorker::StartPrinting(PrintedDocument* new_document) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK_EQ(document_, new_document);
   DCHECK(document_.get());
-  DCHECK(new_document->settings().Equals(printing_context_.settings()));
+  DCHECK(new_document->settings().Equals(printing_context_->settings()));
 
   if (!document_.get() || page_number_ != PageNumber::npos() ||
       document_ != new_document) {
     return;
   }
 
   PrintingContext::Result result =
-      printing_context_.NewDocument(document_->name());
+      printing_context_->NewDocument(document_->name());
   if (result != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Try to print already cached data. It may already have been generated for
   // the print preview.
   OnNewPage();
   // Don't touch this anymore since the instance could be destroyed. It happens
   // if all the pages are printed a one sweep and the client doesn't have a
   // handle to us anymore. There's a timing issue involved between the worker
   // thread and the UI thread. Take no chance.
 }
 
 void PrintJobWorker::OnDocumentChanged(PrintedDocument* new_document) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(!new_document ||
-         new_document->settings().Equals(printing_context_.settings()));
+         new_document->settings().Equals(printing_context_->settings()));
 
   if (page_number_ != PageNumber::npos())
     return;
 
   document_ = new_document;
 }
 
 void PrintJobWorker::OnNewPage() {
   if (!document_.get()) {
     // Spurious message.
@@ skipping 33 matching lines @@
     if (page_number_ == PageNumber::npos()) {
       OnDocumentDone();
       // Don't touch this anymore since the instance could be destroyed.
       break;
     }
   }
 }
 
 void PrintJobWorker::Cancel() {
   // This is the only function that can be called from any thread.
-  printing_context_.Cancel();
+  printing_context_->Cancel();
   // Cannot touch any member variable since we don't know in which thread
   // context we run.
 }
 
 void PrintJobWorker::DismissDialog() {
-  printing_context_.DismissDialog();
+  printing_context_->DismissDialog();
 }
 
 void PrintJobWorker::OnDocumentDone() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(document_.get());
 
-  if (printing_context_.DocumentDone() != PrintingContext::OK) {
+  if (printing_context_->DocumentDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Tell everyone!
   NotificationTask* task = new NotificationTask();
   task->Init(owner_,
              JobEventDetails::DOC_DONE,
              document_.get(),
              NULL);
   owner_->message_loop()->PostTask(FROM_HERE, task);
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
 }
 
 void PrintJobWorker::SpoolPage(PrintedPage& page) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_NE(page_number_, PageNumber::npos());
 
   // Signal everyone that the page is about to be printed.
   NotificationTask* task = new NotificationTask();
   task->Init(owner_,
              JobEventDetails::NEW_PAGE,
              document_.get(),
              &page);
   owner_->message_loop()->PostTask(FROM_HERE, task);
 
   // Preprocess.
-  if (printing_context_.NewPage() != PrintingContext::OK) {
+  if (printing_context_->NewPage() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Actual printing.
-  document_->RenderPrintedPage(page, printing_context_.context());
+  document_->RenderPrintedPage(page, printing_context_->context());
 
   // Postprocess.
-  if (printing_context_.PageDone() != PrintingContext::OK) {
+  if (printing_context_->PageDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Signal everyone that the page is printed.
   task = new NotificationTask();
   task->Init(owner_,
              JobEventDetails::PAGE_DONE,
              document_.get(),
              &page);
@@ skipping 25 matching lines @@
     printing::PrintJobWorker* obj) {
   DCHECK(!owner_.get());
   owner_ = obj->owner_;
 }
 
 void RunnableMethodTraits<printing::PrintJobWorker>::ReleaseCallee(
     printing::PrintJobWorker* obj) {
   DCHECK_EQ(owner_, obj->owner_);
   owner_ = NULL;
 }