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/android/tab_android.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"
@@ skipping 14 matching lines @@
 }
 
 class PrintingContextDelegate : public PrintingContext::Delegate {
  public:
   PrintingContextDelegate(int render_process_id, int render_view_id);
   ~PrintingContextDelegate() override;
 
   gfx::NativeView GetParentView() override;
   std::string GetAppLocale() override;
 
+  void ShowSystemDialog() override;
+
  private:
   int render_process_id_;
   int render_view_id_;
 };
 
 PrintingContextDelegate::PrintingContextDelegate(int render_process_id,
                                                  int render_view_id)
     : render_process_id_(render_process_id),
       render_view_id_(render_view_id) {
 }
 
 PrintingContextDelegate::~PrintingContextDelegate() {
 }
 
 gfx::NativeView PrintingContextDelegate::GetParentView() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   content::RenderViewHost* view =
       content::RenderViewHost::FromID(render_process_id_, render_view_id_);
   if (!view)
     return NULL;
   content::WebContents* wc = content::WebContents::FromRenderViewHost(view);
   return wc ? wc->GetNativeView() : NULL;
 }
 
 std::string PrintingContextDelegate::GetAppLocale() {
   return g_browser_process->GetApplicationLocale();
 }
 
+void PrintingContextDelegate::ShowSystemDialog() {
+  LOG(INFO) << "DGN PrintingContextDelegate::ShowSystemDialog";
+#if defined(OS_ANDROID)
+  // Tab (Printable) needed to print. How to call it without the tab directly?
+  // Removing the dependency on chrome would make it easier to move it to
+  // printing_context_android
+  content::RenderViewHost* view = content::RenderViewHost::FromID(
+      render_process_id_, render_view_id_);
+  DCHECK(view);
+  content::WebContents* wc = content::WebContents::FromRenderViewHost(view);
+  TabAndroid* tab = TabAndroid::FromWebContents(wc);
+  if (tab) tab->ShowPrintDialog();
+#endif
+}
+
+
 void NotificationCallback(PrintJobWorkerOwner* print_job,
                           JobEventDetails::Type detail_type,
                           PrintedDocument* document,
                           PrintedPage* page) {
   JobEventDetails* details = new JobEventDetails(detail_type, document, page);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PRINT_JOB_EVENT,
       // We know that is is a PrintJob object in this circumstance.
       content::Source<PrintJob>(static_cast<PrintJob*>(print_job)),
       content::Details<JobEventDetails>(details));
@@ skipping 20 matching lines @@
   DCHECK(owner_->RunsTasksOnCurrentThread());
   Stop();
 }
 
 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
   DCHECK(page_number_ == PageNumber::npos());
   owner_ = new_owner;
 }
 
 void PrintJobWorker::GetSettings(
-    bool ask_user_for_settings,
+    GetSettingsAskParam ask_user_for_settings,
     int document_page_count,
     bool has_selection,
     MarginType margin_type) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK_EQ(page_number_, PageNumber::npos());
 
+  LOG(INFO) << "DGN GetSettings - askParam: " << ask_user_for_settings;
+
   // 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) {
+  if (ask_user_for_settings == GetSettingsAskParam::ASK_USER) {
     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)));
+  } else if (ask_user_for_settings == GetSettingsAskParam::SYSTEM_SPECIFIC) {
+    LOG(INFO) << "DGN SYSTEM_SPECIFIC! ";
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
+                   base::Bind(&PrintJobWorker::ShowSystemDialog,
+                              base::Unretained(this))));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
                    base::Bind(&PrintJobWorker::UseDefaultSettings,
                               base::Unretained(this))));
   }
 }
 
+void PrintJobWorker::ShowSystemDialog() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  LOG(INFO) << "DGN ShowSystemDialog";
+
+  if (printing_context_ == NULL) LOG(INFO) << "DGN printing_context_ is NULL";
+
+  printing_context_->SetPrintSettingsCallback(
+        base::Bind(&PrintJobWorkerOwner::ShowSystemDialogDone,
+                   base::Unretained(owner_)));
+
+  printing_context_delegate_->ShowSystemDialog();
+}
+
 void PrintJobWorker::SetSettings(
     scoped_ptr<base::DictionaryValue> new_settings) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&HoldRefCallback,
                  make_scoped_refptr(owner_),
                  base::Bind(&PrintJobWorker::UpdatePrintSettings,
@@ skipping 24 matching lines @@
                    base::Bind(&PrintJobWorkerOwner::GetSettingsDone,
                               make_scoped_refptr(owner_),
                               printing_context_->settings(),
                               result));
 }
 
 void PrintJobWorker::GetSettingsWithUI(
     int document_page_count,
     bool has_selection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  printing_context_->AskUserForSettings(
-      document_page_count,
-      has_selection,
-      base::Bind(&PrintJobWorker::GetSettingsWithUIDone,
-                 base::Unretained(this)));
+    printing_context_->AskUserForSettings(
+        document_page_count,
+        has_selection,
+        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),
                                  result)));
 }
@@ skipping 195 matching lines @@
                               document_,
                               scoped_refptr<PrintedPage>()));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing