Wire up printing on the Mac

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"
 #include "printing/printed_document.h"
 #include "printing/printed_page.h"
 
 namespace printing {
 
 class PrintJobWorker::NotificationTask : public Task {
  public:
   NotificationTask() : print_job_(NULL), details_(NULL) {
@@ skipping 39 matching lines @@
   // 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,
-                                 HWND parent_window,
+                                 gfx::NativeWindow parent_window,
                                  int document_page_count,
                                  bool has_selection) {
   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);
 
-  PrintingContext::Result result;
   if (ask_user_for_settings) {
-    result = printing_context_.AskUserForSettings(parent_window,
-                                                  document_page_count,
-                                                  has_selection);
+#if defined(OS_MACOSX)
+    ChromeThread::GetMessageLoop(ChromeThread::UI)->PostTask(
+        FROM_HERE, NewRunnableMethod(this, &PrintJobWorker::GetSettingsWithUI,
+                                     parent_window, document_page_count,
+                                     has_selection));
+#else
+    PrintingContext::Result result = printing_context_.AskUserForSettings(
+        parent_window, document_page_count, has_selection);
+    GetSettingsDone(result);
+#endif
   } else {
-    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(),
       result));
 }
 
+#if defined(OS_MACOSX)
+void PrintJobWorker::GetSettingsWithUI(gfx::NativeWindow parent_window,
+                                       int document_page_count,
+                                       bool has_selection) {
+  DCHECK_EQ(ChromeThread::GetMessageLoop(ChromeThread::UI),
+            MessageLoop::current());
+
+  PrintingContext::Result result = printing_context_.AskUserForSettings(
+      parent_window, document_page_count, has_selection);
+  message_loop()->PostTask(FROM_HERE, NewRunnableMethod(

[pink (ping after 24hrs), 2009/10/13 21:04:51]

so this will now run GetSettingsDone on the UI thread, correct? That's different
from where it runs on windows. Is that ok as well?

[Amanda Walker, 2009/10/13 21:20:55]

No, it'll run it on the PrintJobWorker thread.  message_loop() is this object's
message loop, not the UI loop.

[stuartmorgan, 2009/10/13 22:07:43]

Right; this is a PostTask rather than a straight call specifically to make sure
nothing is different from GetSettingsDone's perspective.

+      this, &PrintJobWorker::GetSettingsDone, result));
+}
+#endif
+
 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()));
+#if !defined(OS_MACOSX)

[pink (ping after 24hrs), 2009/10/13 21:04:51]

I see below why this the case, but it's 150 lines down the page. Is there any
way to make it more clear why there's all the extra ifdefs w/out having to find
the needle in the haystack?

[stuartmorgan, 2009/10/13 22:07:43]

I have a header comment on context() explaining when it's valid for the Mac
also; my feeling was that someone wondering why these are ifdef'd out would
presumably check the documentation for the call. I'd rather not replicate that
comment everywhere here, and that's the only central place I can see to put it.

   DCHECK(printing_context_.context());
+#endif
   if (!document_.get() || page_number_ != PageNumber::npos() ||
       document_ != new_document) {
     return;
   }
 
   PrintingContext::Result result =
       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()));
+#if !defined(OS_MACOSX)
   DCHECK(printing_context_.context());
+#endif
   if (page_number_ != PageNumber::npos())
     return;
 
   document_ = new_document;
 }
 
 void PrintJobWorker::OnNewPage() {
   if (!document_.get()) {
     // Spurious message.
     return;
   }
   // message_loop() could return NULL when the print job is cancelled.
   DCHECK_EQ(message_loop(), MessageLoop::current());
+#if !defined(OS_MACOSX)
   DCHECK(printing_context_.context());
   if (!printing_context_.context())
     return;
+#endif
 
   if (page_number_ == PageNumber::npos()) {
     // Find first page to print.
     int page_count = document_->page_count();
     if (!page_count) {
       // We still don't know how many pages the document contains. We can't
       // start to print the document yet since the header/footer may refer to
       // the document's page count.
       return;
     }
@@ skipping 32 matching lines @@
 }
 
 void PrintJobWorker::DismissDialog() {
   printing_context_.DismissDialog();
 }
 
 void PrintJobWorker::OnDocumentDone() {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(document_.get());
+#if !defined(OS_MACOSX)
   DCHECK(printing_context_.context());
+#endif
 
   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());
+#if !defined(OS_MACOSX)
   DCHECK(printing_context_.context());
+#endif
   // 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) {
     OnFailure();
     return;
   }
 
+#if defined(OS_MACOSX)
+  // Context is only valid between NewPage and PageDone, so we only check here.
+  DCHECK(printing_context_.context());
+#endif
   // Actual printing.
   document_->RenderPrintedPage(page, printing_context_.context());
 
   // Postprocess.
   if (printing_context_.PageDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Signal everyone that the page is printed.
@@ skipping 30 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;
 }