Added PrintingContext::Delegate to get parent view handle and application locale.

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/browser/printing/printing_ui_web_contents_observer.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"
 
 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();
 }
 
-}  // namespace
+class PrintingContextDelegate : public PrintingContext::Delegate {
+ public:
+  PrintingContextDelegate(int render_process_id, int render_view_id);
+  virtual ~PrintingContextDelegate();
+
+  virtual gfx::NativeView GetParentView() OVERRIDE;
+  virtual std::string GetAppLocale() OVERRIDE;
+
+ private:
+  void InitOnUiThread(int render_process_id, int render_view_id);
+
+  scoped_ptr<PrintingUIWebContentsObserver> web_contents_observer_;
+  base::WeakPtrFactory<PrintingContextDelegate> weak_ptr_factory_;
+};
+
+PrintingContextDelegate::PrintingContextDelegate(int render_process_id,
+                                                 int render_view_id)
+    : weak_ptr_factory_(this) {
+  InitOnUiThread(render_process_id, render_view_id);
+}
+
+PrintingContextDelegate::~PrintingContextDelegate() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+gfx::NativeView PrintingContextDelegate::GetParentView() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!web_contents_observer_)
+    return NULL;
+  return web_contents_observer_->GetParentView();
+}
+
+std::string PrintingContextDelegate::GetAppLocale() {
+  return g_browser_process->GetApplicationLocale();
+}
+
+void PrintingContextDelegate::InitOnUiThread(int render_process_id,
+                                             int render_view_id) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    // All data initialized here should be accessed on UI thread. Because object
+    // is being constructed now, anything that is going to access
+    // PrintingContextDelegate on UI thread would be scheduled after the tasks
+    // below.
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&PrintingContextDelegate::InitOnUiThread,
+                                       weak_ptr_factory_.GetWeakPtr(),
+                                       render_process_id,
+                                       render_view_id));
+    return;
+  }
+  content::RenderViewHost* view =
+      content::RenderViewHost::FromID(render_process_id, render_view_id);
+  if (!view)
+    return;
+  content::WebContents* wc = content::WebContents::FromRenderViewHost(view);
+  if (!wc)
+    return;
+  web_contents_observer_.reset(new PrintingUIWebContentsObserver(wc));
+}
 
 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));
 }
 
-PrintJobWorker::PrintJobWorker(PrintJobWorkerOwner* owner)
+}  // namespace
+
+PrintJobWorker::PrintJobWorker(int render_process_id,
+                               int render_view_id,
+                               PrintJobWorkerOwner* owner)
     : owner_(owner), thread_("Printing_Worker"), weak_factory_(this) {
   // The object is created in the IO thread.
   DCHECK(owner_->RunsTasksOnCurrentThread());
 
-  printing_context_.reset(PrintingContext::Create(
-      g_browser_process->GetApplicationLocale()));
+  printing_context_delegate_.reset(
+      new PrintingContextDelegate(render_process_id, render_view_id));
+  printing_context_ = PrintingContext::Create(printing_context_delegate_.get());
 }
 
 PrintJobWorker::~PrintJobWorker() {
   // The object is normally deleted in the UI thread, but when the user
   // cancels printing or in the case of print preview, the worker is destroyed
   // on the I/O thread.
   DCHECK(owner_->RunsTasksOnCurrentThread());
   Stop();
 }
 
 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
   DCHECK(page_number_ == PageNumber::npos());
   owner_ = new_owner;
 }
 
 void PrintJobWorker::SetPrintDestination(
     PrintDestinationInterface* destination) {
   destination_ = destination;
 }
 
 void PrintJobWorker::GetSettings(
     bool ask_user_for_settings,
-    scoped_ptr<PrintingUIWebContentsObserver> web_contents_observer,
     int document_page_count,
     bool has_selection,
     MarginType margin_type) {
   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 && destination_.get() == NULL) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
                    base::Bind(&PrintJobWorker::GetSettingsWithUI,
                               base::Unretained(this),
-                              base::Passed(&web_contents_observer),
                               document_page_count,
                               has_selection)));
   } else {
-    BrowserThread::DeleteSoon(
-        BrowserThread::UI, FROM_HERE, web_contents_observer.release());
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
                    base::Bind(&PrintJobWorker::UseDefaultSettings,
                               base::Unretained(this))));
   }
 }
 
 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,
                             base::Unretained(this),
                             base::Passed(&new_settings))));
 }
 
 void PrintJobWorker::UpdatePrintSettings(
     scoped_ptr<base::DictionaryValue> new_settings) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrintingContext::Result result =
       printing_context_->UpdatePrintSettings(*new_settings);
   GetSettingsDone(result);
 }
 
 void PrintJobWorker::GetSettingsDone(PrintingContext::Result result) {
   // Most PrintingContext functions may start a message loop and process
   // message recursively, so disable recursive task processing.
   // TODO(thestig): See above comment. SetNestableTasksAllowed(false) needs to
   // be called on the same thread as the previous call.  See
   // http://crbug.com/73466
   // MessageLoop::current()->SetNestableTasksAllowed(false);
 
   // We can't use OnFailure() here since owner_ may not support notifications.
 
   // 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(
-    scoped_ptr<PrintingUIWebContentsObserver> web_contents_observer,
     int document_page_count,
     bool has_selection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  gfx::NativeView parent_view = web_contents_observer->GetParentView();
-  if (!parent_view) {
-    GetSettingsWithUIDone(printing::PrintingContext::FAILED);
-    return;
-  }
   printing_context_->AskUserForSettings(
-      parent_view, document_page_count, has_selection,
+      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),
@@ skipping 129 matching lines @@
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK_EQ(page_number_, PageNumber::npos());
   DCHECK(document_.get());
 
   if (printing_context_->DocumentDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   owner_->PostTask(FROM_HERE,
-                   base::Bind(NotificationCallback,
+                   base::Bind(&NotificationCallback,
                               make_scoped_refptr(owner_),
                               JobEventDetails::DOC_DONE,
                               document_,
                               scoped_refptr<PrintedPage>()));
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
 }
 
 void PrintJobWorker::SpoolPage(PrintedPage* page) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   DCHECK_NE(page_number_, PageNumber::npos());
 
   // Signal everyone that the page is about to be printed.
   owner_->PostTask(FROM_HERE,
-                   base::Bind(NotificationCallback,
+                   base::Bind(&NotificationCallback,
                               make_scoped_refptr(owner_),
                               JobEventDetails::NEW_PAGE,
                               document_,
                               make_scoped_refptr(page)));
 
   // Preprocess.
   if (printing_context_->NewPage() != PrintingContext::OK) {
     OnFailure();
     return;
   }
@@ skipping 18 matching lines @@
 #endif
 
   // Postprocess.
   if (printing_context_->PageDone() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
   // Signal everyone that the page is printed.
   owner_->PostTask(FROM_HERE,
-                   base::Bind(NotificationCallback,
+                   base::Bind(&NotificationCallback,
                               make_scoped_refptr(owner_),
                               JobEventDetails::PAGE_DONE,
                               document_,
                               make_scoped_refptr(page)));
 }
 
 void PrintJobWorker::OnFailure() {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
   // We may loose our last reference by broadcasting the FAILED event.
   scoped_refptr<PrintJobWorkerOwner> handle(owner_);
 
   owner_->PostTask(FROM_HERE,
-                   base::Bind(NotificationCallback,
+                   base::Bind(&NotificationCallback,
                               make_scoped_refptr(owner_),
                               JobEventDetails::FAILED,
                               document_,
                               scoped_refptr<PrintedPage>()));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing