Remove black magic and >100 lines. Unhook a lot of dead code.

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 "chrome/browser/printing/print_job_worker.h"
 #include "chrome/browser/printing/printed_document.h"
 #include "chrome/browser/printing/printed_page.h"
 #include "chrome/common/notification_service.h"
 
 #ifdef _MSC_VER
 #pragma warning(disable:4355)  // 'this' : used in base member initializer list
 #endif
 
 using base::TimeDelta;
 
 namespace printing {
 
-PrintJob::PrintJob(PrintedPagesSource* source)
-    : ui_message_loop_(MessageLoop::current()),
-      worker_(new PrintJobWorker(this)),
-      source_(source),
-      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_(MessageLoop::current()),
       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);
@@ skipping 54 matching lines @@
       break;
     }
     default: {
       break;
     }
   }
 }
 
 void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
                                PrintingContext::Result result) {
-  DCHECK(!is_job_pending_);
-
-  if (!source_ || result == PrintingContext::FAILED) {
-    // The source is gone, there's nothing to do.
-    Cancel();
-    return;
-  }
-
-  // Only create a new PrintedDocument if the settings have changed or if
-  // there was no printed document.
-  if (!document_.get() || !new_settings.Equals(settings_)) {
-    UpdatePrintedDocument(new PrintedDocument(new_settings, source_,
-                                              PrintSettings::NewCookie()));
-  }
-
-  JobEventDetails::Type type;
-  if (is_print_dialog_box_shown_) {
-    type = (result == PrintingContext::OK) ?
-        JobEventDetails::USER_INIT_DONE :
-        JobEventDetails::USER_INIT_CANCELED;
-    // Dialog box is not shown anymore.
-    is_print_dialog_box_shown_ = false;
-  } else {
-    DCHECK_EQ(result, PrintingContext::OK);
-    type = JobEventDetails::DEFAULT_INIT_DONE;
-  }
-  scoped_refptr<JobEventDetails> details(
-      new JobEventDetails(type, document_.get(), NULL));
-  NotificationService::current()->Notify(
-      NotificationType::PRINT_JOB_EVENT,
-      Source<PrintJob>(this),
-      Details<JobEventDetails>(details.get()));
+  NOTREACHED();
 }
 
 PrintJobWorker* PrintJob::DetachWorker(PrintJobWorkerOwner* new_owner) {
   NOTREACHED();
   return NULL;
 }
 
 int PrintJob::cookie() const {
   if (!document_.get())
     // Always use an invalid cookie in this case.
     return 0;
   return document_->cookie();
 }
 
 void PrintJob::WillDestroyCurrentMessageLoop() {
   NOTREACHED();
 }
 
-void PrintJob::GetSettings(GetSettingsAskParam ask_user_for_settings,
-                           HWND parent_window) {
-  DCHECK_EQ(ui_message_loop_, MessageLoop::current());
-  DCHECK(!is_job_pending_);
-  DCHECK(!is_print_dialog_box_shown_);
-  // Is not reentrant.
-  if (is_job_pending_)
-    return;
-
-  // Lazy create the worker thread. There is one worker thread per print job.
-  if (!worker_->message_loop()) {
-    if (!worker_->Start())
-      return;
-
-    // Don't re-register if we were already registered.
-    NotificationService::current()->AddObserver(
-        this, NotificationType::PRINT_JOB_EVENT, Source<PrintJob>(this));
-  }
-
-  int page_count = 0;
-  if (document_.get()) {
-    page_count = document_->page_count();
-  }
-
-  // Real work is done in PrintJobWorker::Init().
-  is_print_dialog_box_shown_ = ask_user_for_settings == ASK_USER;
-  worker_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-      worker_.get(), &PrintJobWorker::GetSettings, is_print_dialog_box_shown_,
-      parent_window, page_count));
-}
-
 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(
@@ skipping 54 matching lines @@
   scoped_refptr<JobEventDetails> details(
       new JobEventDetails(JobEventDetails::FAILED, NULL, NULL));
   NotificationService::current()->Notify(
       NotificationType::PRINT_JOB_EVENT,
       Source<PrintJob>(this),
       Details<JobEventDetails>(details.get()));
   Stop();
   is_canceling_ = false;
 }
 
-bool PrintJob::RequestMissingPages() {
-  DCHECK_EQ(ui_message_loop_, MessageLoop::current());
-  DCHECK(!is_print_dialog_box_shown_);
-  if (!is_job_pending_ || is_print_dialog_box_shown_)
-    return false;
-
-  MessageLoop* worker_loop = worker_.get() ? worker_->message_loop() : NULL;
-  if (!worker_loop)
-    return false;
-
-  worker_loop->PostTask(FROM_HERE, NewRunnableMethod(
-      worker_.get(), &PrintJobWorker::RequestMissingPages));
-  return true;
-}
-
 bool PrintJob::FlushJob(int timeout_ms) {
-  if (!RequestMissingPages())
-    return false;
-
   // 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(TimeDelta::FromMilliseconds(timeout_ms),
                     MessageLoop::current(), &MessageLoop::Quit);
@@ skipping 169 matching lines @@
 PrintedDocument* JobEventDetails::document() const {
   return document_;
 }
 
 PrintedPage* JobEventDetails::page() const {
   return page_;
 }
 
 }  // namespace printing