Print Preview: Display a throbber when the user requests the system print

chrome/browser/printing/print_view_manager.cc

 // Copyright (c) 2011 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_view_manager.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/print_preview_tab_controller.h"
 #include "chrome/browser/printing/printer_query.h"
+#include "chrome/browser/printing/print_view_manager_delegate.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/webui/print_preview_ui.h"
 #include "chrome/common/print_messages.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "grit/generated_resources.h"
@@ skipping 16 matching lines @@
 }  // namespace
 
 namespace printing {
 
 PrintViewManager::PrintViewManager(TabContentsWrapper* tab)
     : TabContentsObserver(tab->tab_contents()),
       tab_(tab),
       number_pages_(0),
       printing_succeeded_(false),
       inside_inner_message_loop_(false),
-      is_title_overridden_(false) {
+      is_title_overridden_(false),
+      delegate_(NULL) {
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   expecting_first_page_ = true;
 #endif
 }
 
 PrintViewManager::~PrintViewManager() {
   DisconnectFromCurrentPrintJob();
 }
 
-bool PrintViewManager::PrintNow() {
+bool PrintViewManager::PrintNow(PrintViewManagerDelegate* delegate) {
+  delegate_ = delegate;
+
   // Don't print interstitials.
   if (tab_contents()->showing_interstitial_page())
     return false;
 
   return Send(new PrintMsg_PrintPages(routing_id()));
 }
 
 bool PrintViewManager::PrintPreviewNow() {
   // Don't print preview interstitials.
   if (tab_contents()->showing_interstitial_page())
@@ skipping 45 matching lines @@
   return GURL();
 }
 
 void PrintViewManager::OnDidGetPrintedPagesCount(int cookie, int number_pages) {
   DCHECK_GT(cookie, 0);
   DCHECK_GT(number_pages, 0);
   number_pages_ = number_pages;
   OpportunisticallyCreatePrintJob(cookie);
 }
 
+void PrintViewManager::OnDidShowPrintDialog() {
+  if (delegate_)
+    delegate_->OnPrintDialogShown();

[Lei Zhang, 2011/06/21 01:54:46]

set |delegate_| to NULL here instead of below?

[James Hawkins, 2011/06/22 23:47:24]

No, why would we remove the delegate here? That's relying on the assumption that
the delegate wants no more messages after this call, or that this object will
never make another call to the delegate (which may not always be true).

+}
+
 void PrintViewManager::OnDidPrintPage(
     const PrintHostMsg_DidPrintPage_Params& params) {
   if (!OpportunisticallyCreatePrintJob(params.document_cookie))
     return;
 
   PrintedDocument* document = print_job_->document();
   if (!document || params.document_cookie != document->cookie()) {
     // Out of sync. It may happen since we are completely asynchronous. Old
     // spurious messages can be received if one of the processes is overloaded.
     return;
@@ skipping 62 matching lines @@
       NotificationType::PRINT_JOB_RELEASED,
       Source<TabContents>(tab_contents()),
       NotificationService::NoDetails());
 }
 
 bool PrintViewManager::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PrintViewManager, message)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidGetPrintedPagesCount,
                         OnDidGetPrintedPagesCount)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_DidShowPrintDialog, OnDidShowPrintDialog)
     IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage)
     IPC_MESSAGE_HANDLER(PrintHostMsg_PrintingFailed, OnPrintingFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PrintViewManager::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
@@ skipping 159 matching lines @@
   if (!print_job_.get() || !tab_contents())
     return;
   RenderViewHost* rvh = tab_contents()->render_view_host();
   rvh->Send(new PrintMsg_PrintingDone(rvh->routing_id(), success));
 }
 
 void PrintViewManager::TerminatePrintJob(bool cancel) {
   if (!print_job_.get())
     return;
 
+  delegate_ = NULL;
+
   if (cancel) {
     // We don't need the metafile data anymore because the printing is canceled.
     print_job_->Cancel();
     inside_inner_message_loop_ = false;
   } else {
     DCHECK(!inside_inner_message_loop_);
     DCHECK(!print_job_->document() || print_job_->document()->IsComplete());
 
     // TabContents is either dying or navigating elsewhere. We need to render
     // all the pages in an hurry if a print job is still pending. This does the
@@ skipping 76 matching lines @@
     return false;
   }
 
   // Settings are already loaded. Go ahead. This will set
   // print_job_->is_job_pending() to true.
   print_job_->StartPrinting();
   return true;
 }
 
 }  // namespace printing