#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 "grit/generated_resources.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"
using content::BrowserThread;
+namespace printing {
+
namespace {
// Helper function to ensure |owner| is valid until at least |callback| returns.
callback.Run();
}
-} // namespace
+class PrintingContextDelegate : public PrintingContext::Delegate {
+ public:
+ PrintingContextDelegate(int render_process_id, int render_view_id);
+ virtual ~PrintingContextDelegate();
-namespace printing {
+ virtual gfx::NativeView GetParentView() OVERRIDE;
+ virtual std::string GetAppLocale() 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 NotificationCallback(PrintJobWorkerOwner* print_job,
JobEventDetails::Type detail_type,
content::Details<JobEventDetails>(details));
}
-PrintJobWorker::PrintJobWorker(PrintJobWorkerOwner* owner)
- : Thread("Printing_Worker"),
- owner_(owner),
- weak_factory_(this) {
+} // 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_EQ(owner_->message_loop(), base::MessageLoop::current());
+ 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_EQ(owner_->message_loop(), base::MessageLoop::current());
+ DCHECK(owner_->RunsTasksOnCurrentThread());
Stop();
}
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_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
DCHECK_EQ(page_number_, PageNumber::npos());
// Recursive task processing is needed for the dialog in case it needs to be
// 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) {
+ 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),
- base::Passed(&web_contents_observer),
document_page_count,
has_selection)));
} else {
}
void PrintJobWorker::SetSettings(
- const base::DictionaryValue* const new_settings) {
- DCHECK_EQ(message_loop(), base::MessageLoop::current());
+ scoped_ptr<base::DictionaryValue> new_settings) {
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
BrowserThread::PostTask(
BrowserThread::UI,
make_scoped_refptr(owner_),
base::Bind(&PrintJobWorker::UpdatePrintSettings,
base::Unretained(this),
- base::Owned(new_settings))));
+ base::Passed(&new_settings))));
}
void PrintJobWorker::UpdatePrintSettings(
- const base::DictionaryValue* const new_settings) {
+ scoped_ptr<base::DictionaryValue> new_settings) {
+ DCHECK_CURRENTLY_ON(BrowserThread::UI);
PrintingContext::Result result =
printing_context_->UpdatePrintSettings(*new_settings);
GetSettingsDone(result);
// We can't use OnFailure() here since owner_ may not support notifications.
// PrintJob will create the new PrintedDocument.
- owner_->message_loop()->PostTask(
- FROM_HERE,
- base::Bind(&PrintJobWorkerOwner::GetSettingsDone,
- make_scoped_refptr(owner_), printing_context_->settings(),
- result));
+ 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) {
- message_loop()->PostTask(
- FROM_HERE,
- base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
- base::Bind(&PrintJobWorker::GetSettingsDone,
- base::Unretained(this), result)));
+ PostTask(FROM_HERE,
+ base::Bind(&HoldRefCallback,
+ make_scoped_refptr(owner_),
+ base::Bind(&PrintJobWorker::GetSettingsDone,
+ base::Unretained(this),
+ result)));
}
void PrintJobWorker::UseDefaultSettings() {
}
void PrintJobWorker::StartPrinting(PrintedDocument* new_document) {
- DCHECK_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
DCHECK_EQ(page_number_, PageNumber::npos());
- DCHECK_EQ(document_, new_document);
+ DCHECK_EQ(document_.get(), new_document);
DCHECK(document_.get());
if (!document_.get() || page_number_ != PageNumber::npos() ||
}
void PrintJobWorker::OnDocumentChanged(PrintedDocument* new_document) {
- DCHECK_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
DCHECK_EQ(page_number_, PageNumber::npos());
if (page_number_ != PageNumber::npos())
return;
// message_loop() could return NULL when the print job is cancelled.
- DCHECK_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
if (page_number_ == PageNumber::npos()) {
// Find first page to print.
}
// We have enough information to initialize page_number_.
page_number_.Init(document_->settings(), page_count);
- if (destination_.get() != NULL)
- destination_->SetPageCount(page_count);
}
DCHECK_NE(page_number_, PageNumber::npos());
while (true) {
// Is the page available?
scoped_refptr<PrintedPage> page = document_->GetPage(page_number_.ToInt());
- if (!page) {
+ if (!page.get()) {
// We need to wait for the page to be available.
base::MessageLoop::current()->PostDelayedTask(
FROM_HERE,
// context we run.
}
+bool PrintJobWorker::IsRunning() const {
+ return thread_.IsRunning();
+}
+
+bool PrintJobWorker::PostTask(const tracked_objects::Location& from_here,
+ const base::Closure& task) {
+ if (task_runner_.get())
+ return task_runner_->PostTask(from_here, task);
+ return false;
+}
+
+void PrintJobWorker::StopSoon() {
+ thread_.StopSoon();
+}
+
+void PrintJobWorker::Stop() {
+ thread_.Stop();
+}
+
+bool PrintJobWorker::Start() {
+ bool result = thread_.Start();
+ task_runner_ = thread_.task_runner();
+ return result;
+}
+
void PrintJobWorker::OnDocumentDone() {
- DCHECK_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
DCHECK_EQ(page_number_, PageNumber::npos());
DCHECK(document_.get());
return;
}
- owner_->message_loop()->PostTask(
- FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
- JobEventDetails::DOC_DONE, document_,
- scoped_refptr<PrintedPage>()));
+ owner_->PostTask(FROM_HERE,
+ 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_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
DCHECK_NE(page_number_, PageNumber::npos());
// Signal everyone that the page is about to be printed.
- owner_->message_loop()->PostTask(
- FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
- JobEventDetails::NEW_PAGE, document_,
- make_scoped_refptr(page)));
+ owner_->PostTask(FROM_HERE,
+ base::Bind(&NotificationCallback,
+ make_scoped_refptr(owner_),
+ JobEventDetails::NEW_PAGE,
+ document_,
+ make_scoped_refptr(page)));
// Preprocess.
if (printing_context_->NewPage() != PrintingContext::OK) {
return;
}
- if (destination_.get() != NULL) {
- std::vector<uint8> metabytes(page->metafile()->GetDataSize());
- bool success = page->metafile()->GetData(
- reinterpret_cast<void*>(&metabytes[0]), metabytes.size());
- DCHECK(success) << "Failed to get metafile data.";
- destination_->SetPageContent(
- page->page_number(),
- reinterpret_cast<void*>(&metabytes[0]),
- metabytes.size());
- return;
- }
-
// Actual printing.
#if defined(OS_WIN) || defined(OS_MACOSX)
document_->RenderPrintedPage(*page, printing_context_->context());
}
// Signal everyone that the page is printed.
- owner_->message_loop()->PostTask(
- FROM_HERE,
- base::Bind(NotificationCallback, make_scoped_refptr(owner_),
- JobEventDetails::PAGE_DONE, document_,
- make_scoped_refptr(page)));
+ owner_->PostTask(FROM_HERE,
+ base::Bind(&NotificationCallback,
+ make_scoped_refptr(owner_),
+ JobEventDetails::PAGE_DONE,
+ document_,
+ make_scoped_refptr(page)));
}
void PrintJobWorker::OnFailure() {
- DCHECK_EQ(message_loop(), base::MessageLoop::current());
+ DCHECK(task_runner_->RunsTasksOnCurrentThread());
// We may loose our last reference by broadcasting the FAILED event.
scoped_refptr<PrintJobWorkerOwner> handle(owner_);
- owner_->message_loop()->PostTask(
- FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
- JobEventDetails::FAILED, document_,
- scoped_refptr<PrintedPage>()));
+ owner_->PostTask(FROM_HERE,
+ base::Bind(&NotificationCallback,
+ make_scoped_refptr(owner_),
+ JobEventDetails::FAILED,
+ document_,
+ scoped_refptr<PrintedPage>()));
Cancel();
// Makes sure the variables are reinitialized.
projects / platform / framework / web / crosswalk.git / blobdiff