At browser exit, wait for pending print jobs before starting shutdown. This is to avoid a nested me…

chrome/browser/printing/print_job.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
@@ skipping 17 matching lines @@
 }  // namespace
 
 namespace printing {
 
 PrintJob::PrintJob()
     : ui_message_loop_(MessageLoop::current()),
       source_(NULL),
       worker_(),
       settings_(),
       is_job_pending_(false),
-      is_canceling_(false) {
+      is_canceling_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(quit_factory_(this)) {
   DCHECK(ui_message_loop_);
   // This is normally a UI message loop, but in unit tests, the message loop is
   // of the 'default' type.
   DCHECK(ui_message_loop_->type() == MessageLoop::TYPE_UI ||
          ui_message_loop_->type() == MessageLoop::TYPE_DEFAULT);
   ui_message_loop_->AddDestructionObserver(this);
 }
 
 PrintJob::~PrintJob() {
   ui_message_loop_->RemoveDestructionObserver(this);
@@ skipping 92 matching lines @@
       new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), NULL));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::Stop() {
   DCHECK_EQ(ui_message_loop_, MessageLoop::current());
 
+  if (quit_factory_.HasWeakPtrs()) {
+    // In case we're running a nested message loop to wait for a job to finish,
+    // and we finished before the timeout, quit the nested loop right away.
+    Quit();
+    quit_factory_.InvalidateWeakPtrs();
+  }
+
   // Be sure to live long enough.
   scoped_refptr<PrintJob> handle(this);
 
   MessageLoop* worker_loop = worker_->message_loop();
   if (worker_loop) {
     ControlledWorkerShutdown();
 
     is_job_pending_ = false;
     registrar_.Remove(this, chrome::NOTIFICATION_PRINT_JOB_EVENT,
                       content::Source<PrintJob>(this));
@@ skipping 25 matching lines @@
       content::Source<PrintJob>(this),
       content::Details<JobEventDetails>(details.get()));
   Stop();
   is_canceling_ = false;
 }
 
 bool PrintJob::FlushJob(int timeout_ms) {
   // Make sure the object outlive this message loop.
   scoped_refptr<PrintJob> handle(this);
 
-  // Stop() will eventually be called, which will get out of the inner message
-  // loop. But, don't take it for granted and set a timer in case something goes
-  // wrong.
-  base::OneShotTimer<MessageLoop> quit_task;
-  if (timeout_ms) {
-    quit_task.Start(FROM_HERE, TimeDelta::FromMilliseconds(timeout_ms),
-                    MessageLoop::current(), &MessageLoop::Quit);
-  }
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      base::Bind(&PrintJob::Quit, quit_factory_.GetWeakPtr()), timeout_ms);
 
   MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
   MessageLoop::current()->Run();
 
   return true;
 }
 
 void PrintJob::DisconnectSource() {
   source_ = NULL;
   if (document_.get())
@@ skipping 127 matching lines @@
 #endif
 
   // Temporarily allow it until we fix
   // http://code.google.com/p/chromium/issues/detail?id=67044
   base::ThreadRestrictions::ScopedAllowIO allow_io;
 
   // Now make sure the thread object is cleaned up.
   worker_->Stop();
 }
 
+void PrintJob::Quit() {
+  MessageLoop::current()->Quit();
+}
+
 // 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