Implement window.print() on Android

chrome/browser/printing/print_job_worker.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_worker.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/printing/print_job.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "printing/print_job_constants.h"
 #include "printing/printed_document.h"
 #include "printing/printed_page.h"
 #include "printing/printing_utils.h"
 #include "ui/base/l10n/l10n_util.h"
 
+#if defined(OS_ANDROID)
+#include "chrome/browser/android/tab_android.h"
+#endif
+
 using content::BrowserThread;
 
 namespace printing {
 
 namespace {
 
 // Helper function to ensure |owner| is valid until at least |callback| returns.
 void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner,
                      const base::Closure& callback) {
   callback.Run();
@@ skipping 76 matching lines @@
 
 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
   DCHECK(page_number_ == PageNumber::npos());
   owner_ = new_owner;
 }
 
 void PrintJobWorker::GetSettings(
     bool ask_user_for_settings,
     int document_page_count,
     bool has_selection,
-    MarginType margin_type) {
+    MarginType margin_type,
+    bool is_scripted) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK_EQ(page_number_, PageNumber::npos());
 
   // Recursive task processing is needed for the dialog in case it needs to be
   // destroyed by a task.
   // TODO(thestig): This code is wrong. SetNestableTasksAllowed(true) is needed
   // on the thread where the PrintDlgEx is called, and definitely both calls
   // should happen on the same thread. See http://crbug.com/73466
   // MessageLoop::current()->SetNestableTasksAllowed(true);
   printing_context_->set_margin_type(margin_type);
 
   // When we delegate to a destination, we don't ask the user for settings.
   // TODO(mad): Ask the destination for settings.
   if (ask_user_for_settings) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
                    base::Bind(&PrintJobWorker::GetSettingsWithUI,
                               base::Unretained(this),
                               document_page_count,
-                              has_selection)));
+                              has_selection,
+                              is_scripted)));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
                    base::Bind(&PrintJobWorker::UseDefaultSettings,
                               base::Unretained(this))));
   }
 }
 
 void PrintJobWorker::SetSettings(
@@ skipping 31 matching lines @@
   // PrintJob will create the new PrintedDocument.
   owner_->PostTask(FROM_HERE,
                    base::Bind(&PrintJobWorkerOwner::GetSettingsDone,
                               make_scoped_refptr(owner_),
                               printing_context_->settings(),
                               result));
 }
 
 void PrintJobWorker::GetSettingsWithUI(
     int document_page_count,
-    bool has_selection) {
+    bool has_selection,
+    bool is_scripted) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+#if defined(OS_ANDROID)
+  if (is_scripted) {
+    PrintingContextDelegate* printing_context_delegate =
+        static_cast<PrintingContextDelegate*>(printing_context_delegate_.get());
+    content::WebContents* web_contents =
+        printing_context_delegate->GetWebContents();
+    TabAndroid* tab = TabAndroid::FromWebContents(web_contents);
+    if (tab) {
+      // If the following method fails (print not supported by policy, print
+      // in progress...) or is not called, attempting to start a pending print
+      // does nothing and will notify that printing is finished.

[Bernhard Bauer, 2014/12/15 10:44:59]

I'm not particularly familiar with this code, but I don't really understand this
comment, or rather what the consequences of that are. Why is that comment here
and not somewhere else, like where the method is declared?

[dgn, 2014/12/15 13:16:24]

Initially, the comment was there to clarify what happens if tab is nullptr and
the method is not called. The normal code path, after using
tab->setPendingPrint, would be to call PrintingController#StartPendingPrint().
So, I wrote it when I was trying to answer the question "what happens if the
pending print is not set up properly? Will javascript be hanging forever?"

I rewrote the comment and added something about failure in
PrintingController#StartPendingPrint's doc

+      tab->SetPendingPrint();
+    }
+  }
+#endif
+
   printing_context_->AskUserForSettings(
       document_page_count,
       has_selection,
+      is_scripted,
       base::Bind(&PrintJobWorker::GetSettingsWithUIDone,
                  base::Unretained(this)));
 }
 
 void PrintJobWorker::GetSettingsWithUIDone(PrintingContext::Result result) {
   PostTask(FROM_HERE,
            base::Bind(&HoldRefCallback,
                       make_scoped_refptr(owner_),
                       base::Bind(&PrintJobWorker::GetSettingsDone,
                                  base::Unretained(this),
@@ skipping 197 matching lines @@
                               document_,
                               scoped_refptr<PrintedPage>()));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing