Wire up printing on the Mac

chrome/browser/printing/print_job.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.h"
 
 #include "base/message_loop.h"
 #include "base/timer.h"
 #include "chrome/browser/printing/print_job_worker.h"
 #include "chrome/common/notification_service.h"
 #include "printing/printed_document.h"
 #include "printing/printed_page.h"
 
 #ifdef _MSC_VER
 #pragma warning(disable:4355)  // 'this' : used in base member initializer list
 #endif
 
 using base::TimeDelta;
 
 namespace printing {
 
 PrintJob::PrintJob()
     : ui_message_loop_(MessageLoop::current()),
+      source_(NULL),
       worker_(),
-      source_(NULL),
       settings_(),
       is_job_pending_(false),
       is_print_dialog_box_shown_(false),
       is_canceling_(false) {
   DCHECK(ui_message_loop_);
   ui_message_loop_->AddDestructionObserver(this);
 }
 
 PrintJob::~PrintJob() {
   ui_message_loop_->RemoveDestructionObserver(this);
@@ skipping 241 matching lines @@
   scoped_refptr<JobEventDetails> details(
       new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), NULL));
   NotificationService::current()->Notify(
       NotificationType::PRINT_JOB_EVENT,
       Source<PrintJob>(this),
       Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::ControlledWorkerShutdown() {
   DCHECK_EQ(ui_message_loop_, MessageLoop::current());
+#if defined(OS_WIN)

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

add a todo to come back to this on mac and comment why we can get away with it
for now?

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

I don't think we'll ever need to come back to this; I've added a comment
explaining why.

   // We could easily get into a deadlock case if worker_->Stop() is used; the
   // printer driver created a window as a child of the browser window. By
   // canceling the job, the printer driver initiated dialog box is destroyed,
   // which sends a blocking message to its parent window. If the browser window
   // thread is not processing messages, a deadlock occurs.
   //
   // This function ensures that the dialog box will be destroyed in a timely
   // manner by the mere fact that the thread will terminate. So the potential
   // deadlock is eliminated.
   worker_->StopSoon();
@@ skipping 19 matching lines @@
     }
     else if (result == WAIT_OBJECT_0) {
       // The thread quit.
       break;
     } else {
       // An error occured. Assume the thread quit.
       NOTREACHED();
       break;
     }
   }
+#endif
 
   // Now make sure the thread object is cleaned up.
   worker_->Stop();
 }
 
 // Takes settings_ ownership and will be deleted in the receiving thread.
 JobEventDetails::JobEventDetails(Type type,
                                  PrintedDocument* document,
                                  PrintedPage* page)
     : document_(document),
       page_(page),
       type_(type) {
 }
 
 JobEventDetails::~JobEventDetails() {
 }
 
 PrintedDocument* JobEventDetails::document() const {
   return document_;
 }
 
 PrintedPage* JobEventDetails::page() const {
   return page_;
 }
 
 }  // namespace printing