Printing: Delete dead code in PrintJob and cleanup corresponding code in Prin...

chrome/browser/printing/print_job.cc

 // Copyright (c) 2010 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/threading/thread_restrictions.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"
 
 using base::TimeDelta;
 
 namespace printing {
 
 PrintJob::PrintJob()
     : ui_message_loop_(MessageLoop::current()),
       source_(NULL),
       worker_(),
       settings_(),
       is_job_pending_(false),
-      is_print_dialog_box_shown_(false),
       is_canceling_(false) {
   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);
   // The job should be finished (or at least canceled) when it is destroyed.
   DCHECK(!is_job_pending_);
-  DCHECK(!is_print_dialog_box_shown_);
   DCHECK(!is_canceling_);
   if (worker_.get())
     DCHECK(worker_->message_loop() == NULL);
   DCHECK_EQ(ui_message_loop_, MessageLoop::current());
 }
 
 void PrintJob::Initialize(PrintJobWorkerOwner* job,
                           PrintedPagesSource* source,
                           int page_count) {
   DCHECK(!source_);
   DCHECK(!worker_.get());
   DCHECK(!is_job_pending_);
-  DCHECK(!is_print_dialog_box_shown_);
   DCHECK(!is_canceling_);
   DCHECK(!document_.get());
   source_ = source;
   worker_.reset(job->DetachWorker(this));
   settings_ = job->settings();
 
   PrintedDocument* new_doc =
       new PrintedDocument(settings_, source_, job->cookie());
   new_doc->set_page_count(page_count);
   UpdatePrintedDocument(new_doc);
@@ skipping 44 matching lines @@
 }
 
 void PrintJob::WillDestroyCurrentMessageLoop() {
   NOTREACHED();
 }
 
 void PrintJob::StartPrinting() {
   DCHECK_EQ(ui_message_loop_, MessageLoop::current());
   DCHECK(worker_->message_loop());
   DCHECK(!is_job_pending_);
-  DCHECK(!is_print_dialog_box_shown_);
   if (!worker_->message_loop() || is_job_pending_)
     return;
 
   // Real work is done in PrintJobWorker::StartPrinting().
   worker_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       worker_.get(), &PrintJobWorker::StartPrinting, document_));
   // Set the flag right now.
   is_job_pending_ = true;
 
   // Tell everyone!
   scoped_refptr<JobEventDetails> details(
       new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), NULL));
   NotificationService::current()->Notify(
       NotificationType::PRINT_JOB_EVENT,
       Source<PrintJob>(this),
       Details<JobEventDetails>(details.get()));
 }
 
 void PrintJob::Stop() {
   DCHECK_EQ(ui_message_loop_, MessageLoop::current());
 
   // Be sure to live long enough.
   scoped_refptr<PrintJob> handle(this);
 
   MessageLoop* worker_loop = worker_->message_loop();
   if (worker_loop) {
-    if (is_print_dialog_box_shown_) {
-      // Make sure there is no Print... dialog box.
-      worker_loop->PostTask(FROM_HERE, NewRunnableMethod(
-          worker_.get(), &PrintJobWorker::DismissDialog));
-      is_print_dialog_box_shown_ = false;
-    }
-
     ControlledWorkerShutdown();
 
     is_job_pending_ = false;
     registrar_.Remove(this, NotificationType::PRINT_JOB_EVENT,
                       Source<PrintJob>(this));
   }
   // Flush the cached document.
   UpdatePrintedDocument(NULL);
 }
 
@@ skipping 48 matching lines @@
 void PrintJob::DisconnectSource() {
   source_ = NULL;
   if (document_.get())
     document_->DisconnectSource();
 }
 
 bool PrintJob::is_job_pending() const {
   return is_job_pending_;
 }
 
-bool PrintJob::is_print_dialog_box_shown() const {
-  return is_print_dialog_box_shown_;
-}
-
 PrintedDocument* PrintJob::document() const {
   return document_.get();
 }
 
 void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
   if (document_.get() == new_document)
     return;
 
   document_ = new_document;
 
   if (document_.get()) {
     settings_ = document_->settings();
   }
 
   if (worker_.get() && worker_->message_loop()) {
     DCHECK(!is_job_pending_);
     // Sync the document with the worker.
     worker_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
         worker_.get(), &PrintJobWorker::OnDocumentChanged, document_));
   }
 }
 
 void PrintJob::OnNotifyPrintJobEvent(const JobEventDetails& event_details) {
   switch (event_details.type()) {
     case JobEventDetails::FAILED: {
       settings_.Clear();
-      // Update internal state.
-      is_print_dialog_box_shown_ = false;
       // No need to cancel since the worker already canceled itself.
       Stop();
       break;
     }
     case JobEventDetails::USER_INIT_DONE:
     case JobEventDetails::DEFAULT_INIT_DONE:
     case JobEventDetails::USER_INIT_CANCELED: {
       DCHECK_EQ(event_details.document(), document_.get());
       break;
     }
@@ skipping 102 matching lines @@
 
 PrintedDocument* JobEventDetails::document() const {
   return document_;
 }
 
 PrintedPage* JobEventDetails::page() const {
   return page_;
 }
 
 }  // namespace printing