mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Update printing code to latest

Browse source
This commit is contained in:
Cheng Zhao 2017-01-31 17:38:05 +09:00 • committed by Kevin Sawicki
commit ab783413a2
16 changed files with 374 additions and 463 deletions
Download patch file Download diff file Expand all files Collapse all files

120
chromium_src/chrome/browser/printing/print_job.cc
View file

@ -4,14 +4,20 @@
#include "chrome/browser/printing/print_job.h" #include "chrome/browser/printing/print_job.h"
#include <memory>
#include <utility>
#include "base/bind.h" #include "base/bind.h"
#include "base/bind_helpers.h" #include "base/bind_helpers.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h" #include "base/message_loop/message_loop.h"
#include "base/run_loop.h" #include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_restrictions.h" #include "base/threading/thread_restrictions.h"
#include "base/threading/thread_task_runner_handle.h" #include "base/threading/thread_task_runner_handle.h"
#include "base/threading/worker_pool.h" #include "base/threading/worker_pool.h"
#include "base/timer/timer.h" #include "build/build_config.h"
#include "chrome/browser/chrome_notification_types.h" #include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/printing/print_job_worker.h" #include "chrome/browser/printing/print_job_worker.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
@ -24,25 +30,22 @@
#include "printing/pdf_render_settings.h" #include "printing/pdf_render_settings.h"
#endif #endif
using base::TimeDelta; using base::TimeDelta;
namespace printing {
namespace { namespace {
// Helper function to ensure |owner| is valid until at least |callback| returns. // Helper function to ensure |owner| is valid until at least |callback| returns.
void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner, void HoldRefCallback(const scoped_refptr<PrintJobWorkerOwner>& owner,
const base::Closure& callback) { const base::Closure& callback) {
callback.Run(); callback.Run();
} }
} // namespace } // namespace
namespace printing {
PrintJob::PrintJob() PrintJob::PrintJob()
: source_(NULL), : source_(nullptr),
worker_(),
settings_(),
is_job_pending_(false), is_job_pending_(false),
is_canceling_(false), is_canceling_(false),
quit_factory_(this) { quit_factory_(this) {
@ -65,12 +68,12 @@ void PrintJob::Initialize(PrintJobWorkerOwner* job,
PrintedPagesSource* source, PrintedPagesSource* source,
int page_count) { int page_count) {
DCHECK(!source_); DCHECK(!source_);
DCHECK(!worker_.get()); DCHECK(!worker_);
DCHECK(!is_job_pending_); DCHECK(!is_job_pending_);
DCHECK(!is_canceling_); DCHECK(!is_canceling_);
DCHECK(!document_.get()); DCHECK(!document_.get());
source_ = source; source_ = source;
worker_.reset(job->DetachWorker(this)); worker_ = job->DetachWorker(this);
settings_ = job->settings(); settings_ = job->settings();
PrintedDocument* new_doc = PrintedDocument* new_doc =
@ -90,15 +93,9 @@ void PrintJob::Observe(int type,
const content::NotificationSource& source, const content::NotificationSource& source,
const content::NotificationDetails& details) { const content::NotificationDetails& details) {
DCHECK(RunsTasksOnCurrentThread()); DCHECK(RunsTasksOnCurrentThread());
switch (type) { DCHECK_EQ(chrome::NOTIFICATION_PRINT_JOB_EVENT, type);
case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr()); OnNotifyPrintJobEvent(*content::Details<JobEventDetails>(details).ptr());
break;
}
default: {
break;
}
}
} }
void PrintJob::GetSettingsDone(const PrintSettings& new_settings, void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
@ -106,9 +103,10 @@ void PrintJob::GetSettingsDone(const PrintSettings& new_settings,
NOTREACHED(); NOTREACHED();
} }
PrintJobWorker* PrintJob::DetachWorker(PrintJobWorkerOwner* new_owner) { std::unique_ptr<PrintJobWorker> PrintJob::DetachWorker(
PrintJobWorkerOwner* new_owner) {
NOTREACHED(); NOTREACHED();
return NULL; return nullptr;
} }
const PrintSettings& PrintJob::settings() const { const PrintSettings& PrintJob::settings() const {
@ -116,23 +114,22 @@ const PrintSettings& PrintJob::settings() const {
} }
int PrintJob::cookie() const { int PrintJob::cookie() const {
if (!document_.get())
// Always use an invalid cookie in this case. // Always use an invalid cookie in this case.
if (!document_.get())
return 0; return 0;
return document_->cookie(); return document_->cookie();
} }
void PrintJob::StartPrinting() { void PrintJob::StartPrinting() {
DCHECK(RunsTasksOnCurrentThread()); DCHECK(RunsTasksOnCurrentThread());
DCHECK(worker_->IsRunning()); if (!worker_->IsRunning() || is_job_pending_) {
DCHECK(!is_job_pending_); NOTREACHED();
if (!worker_->IsRunning() || is_job_pending_)
return; return;
}
// Real work is done in PrintJobWorker::StartPrinting(). // Real work is done in PrintJobWorker::StartPrinting().
worker_->PostTask(FROM_HERE, worker_->PostTask(FROM_HERE,
base::Bind(&HoldRefCallback, base::Bind(&HoldRefCallback, make_scoped_refptr(this),
make_scoped_refptr(this),
base::Bind(&PrintJobWorker::StartPrinting, base::Bind(&PrintJobWorker::StartPrinting,
base::Unretained(worker_.get()), base::Unretained(worker_.get()),
base::RetainedRef(document_)))); base::RetainedRef(document_))));
@ -141,7 +138,7 @@ void PrintJob::StartPrinting() {
// Tell everyone! // Tell everyone!
scoped_refptr<JobEventDetails> details( scoped_refptr<JobEventDetails> details(
new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), NULL)); new JobEventDetails(JobEventDetails::NEW_DOC, document_.get(), nullptr));
content::NotificationService::current()->Notify( content::NotificationService::current()->Notify(
chrome::NOTIFICATION_PRINT_JOB_EVENT, chrome::NOTIFICATION_PRINT_JOB_EVENT,
content::Source<PrintJob>(this), content::Source<PrintJob>(this),
@ -165,7 +162,8 @@ void PrintJob::Stop() {
ControlledWorkerShutdown(); ControlledWorkerShutdown();
} else { } else {
// Flush the cached document. // Flush the cached document.
UpdatePrintedDocument(NULL); is_job_pending_ = false;
UpdatePrintedDocument(nullptr);
} }
} }
@ -185,7 +183,7 @@ void PrintJob::Cancel() {
} }
// Make sure a Cancel() is broadcast. // Make sure a Cancel() is broadcast.
scoped_refptr<JobEventDetails> details( scoped_refptr<JobEventDetails> details(
new JobEventDetails(JobEventDetails::FAILED, NULL, NULL)); new JobEventDetails(JobEventDetails::FAILED, nullptr, nullptr));
content::NotificationService::current()->Notify( content::NotificationService::current()->Notify(
chrome::NOTIFICATION_PRINT_JOB_EVENT, chrome::NOTIFICATION_PRINT_JOB_EVENT,
content::Source<PrintJob>(this), content::Source<PrintJob>(this),
@ -210,7 +208,7 @@ bool PrintJob::FlushJob(base::TimeDelta timeout) {
} }
void PrintJob::DisconnectSource() { void PrintJob::DisconnectSource() {
source_ = NULL; source_ = nullptr;
if (document_.get()) if (document_.get())
document_->DisconnectSource(); document_->DisconnectSource();
} }
@ -237,8 +235,10 @@ class PrintJob::PdfToEmfState {
void Start(const scoped_refptr<base::RefCountedMemory>& data, void Start(const scoped_refptr<base::RefCountedMemory>& data,
const PdfRenderSettings& conversion_settings, const PdfRenderSettings& conversion_settings,
bool print_text_with_gdi,
const PdfToEmfConverter::StartCallback& start_callback) { const PdfToEmfConverter::StartCallback& start_callback) {
converter_->Start(data, conversion_settings, start_callback); converter_->Start(data, conversion_settings, print_text_with_gdi,
start_callback);
} }
void GetMorePages( void GetMorePages(
@ -273,48 +273,51 @@ class PrintJob::PdfToEmfState {
std::unique_ptr<PdfToEmfConverter> converter_; std::unique_ptr<PdfToEmfConverter> converter_;
}; };
void PrintJob::AppendPrintedPage(int page_number) {
pdf_page_mapping_.push_back(page_number);
}
void PrintJob::StartPdfToEmfConversion( void PrintJob::StartPdfToEmfConversion(
const scoped_refptr<base::RefCountedMemory>& bytes, const scoped_refptr<base::RefCountedMemory>& bytes,
const gfx::Size& page_size, const gfx::Size& page_size,
const gfx::Rect& content_area) { const gfx::Rect& content_area,
DCHECK(!ptd_to_emf_state_.get()); bool print_text_with_gdi) {
ptd_to_emf_state_.reset(new PdfToEmfState(page_size, content_area)); DCHECK(!pdf_to_emf_state_);
pdf_to_emf_state_ = base::MakeUnique<PdfToEmfState>(page_size, content_area);
const int kPrinterDpi = settings().dpi(); const int kPrinterDpi = settings().dpi();
ptd_to_emf_state_->Start( pdf_to_emf_state_->Start(
bytes, bytes, PdfRenderSettings(content_area, kPrinterDpi, true),
printing::PdfRenderSettings(content_area, kPrinterDpi, true), print_text_with_gdi, base::Bind(&PrintJob::OnPdfToEmfStarted, this));
base::Bind(&PrintJob::OnPdfToEmfStarted, this));
} }
void PrintJob::OnPdfToEmfStarted(int page_count) { void PrintJob::OnPdfToEmfStarted(int page_count) {
if (page_count <= 0) { if (page_count <= 0) {
ptd_to_emf_state_.reset(); pdf_to_emf_state_.reset();
Cancel(); Cancel();
return; return;
} }
ptd_to_emf_state_->set_page_count(page_count); pdf_to_emf_state_->set_page_count(page_count);
ptd_to_emf_state_->GetMorePages( pdf_to_emf_state_->GetMorePages(
base::Bind(&PrintJob::OnPdfToEmfPageConverted, this)); base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
} }
void PrintJob::OnPdfToEmfPageConverted(int page_number, void PrintJob::OnPdfToEmfPageConverted(int page_number,
float scale_factor, float scale_factor,
std::unique_ptr<MetafilePlayer> emf) { std::unique_ptr<MetafilePlayer> emf) {
DCHECK(ptd_to_emf_state_); DCHECK(pdf_to_emf_state_);
if (!document_.get() || !emf) { if (!document_.get() || !emf || page_number < 0 ||
ptd_to_emf_state_.reset(); static_cast<size_t>(page_number) >= pdf_page_mapping_.size()) {
pdf_to_emf_state_.reset();
Cancel(); Cancel();
return; return;
} }
// Update the rendered document. It will send notifications to the listener. // Update the rendered document. It will send notifications to the listener.
document_->SetPage(page_number, document_->SetPage(pdf_page_mapping_[page_number], std::move(emf),
std::move(emf), scale_factor, pdf_to_emf_state_->page_size(),
scale_factor, pdf_to_emf_state_->content_area());
ptd_to_emf_state_->page_size(),
ptd_to_emf_state_->content_area());
ptd_to_emf_state_->GetMorePages( pdf_to_emf_state_->GetMorePages(
base::Bind(&PrintJob::OnPdfToEmfPageConverted, this)); base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
} }
@ -326,16 +329,14 @@ void PrintJob::UpdatePrintedDocument(PrintedDocument* new_document) {
document_ = new_document; document_ = new_document;
if (document_.get()) { if (document_.get())
settings_ = document_->settings(); settings_ = document_->settings();
}
if (worker_) { if (worker_) {
DCHECK(!is_job_pending_); DCHECK(!is_job_pending_);
// Sync the document with the worker. // Sync the document with the worker.
worker_->PostTask(FROM_HERE, worker_->PostTask(FROM_HERE,
base::Bind(&HoldRefCallback, base::Bind(&HoldRefCallback, make_scoped_refptr(this),
make_scoped_refptr(this),
base::Bind(&PrintJobWorker::OnDocumentChanged, base::Bind(&PrintJobWorker::OnDocumentChanged,
base::Unretained(worker_.get()), base::Unretained(worker_.get()),
base::RetainedRef(document_)))); base::RetainedRef(document_))));
@ -371,9 +372,9 @@ void PrintJob::OnNotifyPrintJobEvent(const JobEventDetails& event_details) {
} }
case JobEventDetails::PAGE_DONE: case JobEventDetails::PAGE_DONE:
#if defined(OS_WIN) #if defined(OS_WIN)
ptd_to_emf_state_->OnPageProcessed( pdf_to_emf_state_->OnPageProcessed(
base::Bind(&PrintJob::OnPdfToEmfPageConverted, this)); base::Bind(&PrintJob::OnPdfToEmfPageConverted, this));
#endif // OS_WIN #endif // defined(OS_WIN)
break; break;
default: { default: {
NOTREACHED(); NOTREACHED();
@ -391,7 +392,7 @@ void PrintJob::OnDocumentDone() {
Stop(); Stop();
scoped_refptr<JobEventDetails> details( scoped_refptr<JobEventDetails> details(
new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), NULL)); new JobEventDetails(JobEventDetails::JOB_DONE, document_.get(), nullptr));
content::NotificationService::current()->Notify( content::NotificationService::current()->Notify(
chrome::NOTIFICATION_PRINT_JOB_EVENT, chrome::NOTIFICATION_PRINT_JOB_EVENT,
content::Source<PrintJob>(this), content::Source<PrintJob>(this),
@ -419,8 +420,7 @@ void PrintJob::ControlledWorkerShutdown() {
// to wait on the thread to quit before continuing. // to wait on the thread to quit before continuing.
if (worker_->IsRunning()) { if (worker_->IsRunning()) {
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, FROM_HERE, base::Bind(&PrintJob::ControlledWorkerShutdown, this),
base::Bind(&PrintJob::ControlledWorkerShutdown, this),
base::TimeDelta::FromMilliseconds(100)); base::TimeDelta::FromMilliseconds(100));
return; return;
} }
@ -437,7 +437,7 @@ void PrintJob::ControlledWorkerShutdown() {
is_job_pending_ = false; is_job_pending_ = false;
registrar_.RemoveAll(); registrar_.RemoveAll();
UpdatePrintedDocument(NULL); UpdatePrintedDocument(nullptr);
} }
void PrintJob::HoldUntilStopIsCalled() { void PrintJob::HoldUntilStopIsCalled() {

47
chromium_src/chrome/browser/printing/print_job.h
View file

@ -6,15 +6,15 @@
#define CHROME_BROWSER_PRINTING_PRINT_JOB_H_ #define CHROME_BROWSER_PRINTING_PRINT_JOB_H_
#include <memory> #include <memory>
#include <vector>
#include "base/macros.h"
#include "base/memory/weak_ptr.h" #include "base/memory/weak_ptr.h"
#include "base/message_loop/message_loop.h" #include "build/build_config.h"
#include "chrome/browser/printing/print_job_worker_owner.h" #include "chrome/browser/printing/print_job_worker_owner.h"
#include "content/public/browser/notification_observer.h" #include "content/public/browser/notification_observer.h"
#include "content/public/browser/notification_registrar.h" #include "content/public/browser/notification_registrar.h"
class Thread;
namespace base { namespace base {
class RefCountedMemory; class RefCountedMemory;
} }
@ -49,16 +49,17 @@ class PrintJob : public PrintJobWorkerOwner,
int page_count); int page_count);
// content::NotificationObserver implementation. // content::NotificationObserver implementation.
virtual void Observe(int type, void Observe(int type,
const content::NotificationSource& source, const content::NotificationSource& source,
const content::NotificationDetails& details) override; const content::NotificationDetails& details) override;
// PrintJobWorkerOwner implementation. // PrintJobWorkerOwner implementation.
virtual void GetSettingsDone(const PrintSettings& new_settings, void GetSettingsDone(const PrintSettings& new_settings,
PrintingContext::Result result) override; PrintingContext::Result result) override;
virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) override; std::unique_ptr<PrintJobWorker> DetachWorker(
virtual const PrintSettings& settings() const override; PrintJobWorkerOwner* new_owner) override;
virtual int cookie() const override; const PrintSettings& settings() const override;
int cookie() const override;
// Starts the actual printing. Signals the worker that it should begin to // Starts the actual printing. Signals the worker that it should begin to
// spool as soon as data is available. // spool as soon as data is available.
@ -91,23 +92,21 @@ class PrintJob : public PrintJobWorkerOwner,
PrintedDocument* document() const; PrintedDocument* document() const;
#if defined(OS_WIN) #if defined(OS_WIN)
// Let the PrintJob know the 0-based |page_number| of a given printed page.
void AppendPrintedPage(int page_number);
void StartPdfToEmfConversion( void StartPdfToEmfConversion(
const scoped_refptr<base::RefCountedMemory>& bytes, const scoped_refptr<base::RefCountedMemory>& bytes,
const gfx::Size& page_size, const gfx::Size& page_size,
const gfx::Rect& content_area); const gfx::Rect& content_area,
bool print_text_with_gdi);
void OnPdfToEmfStarted(int page_count); #endif // defined(OS_WIN)
void OnPdfToEmfPageConverted(int page_number,
float scale_factor,
std::unique_ptr<MetafilePlayer> emf);
#endif // OS_WIN
protected: protected:
virtual ~PrintJob(); ~PrintJob() override;
private: private:
// Updates document_ to a new instance. // Updates |document_| to a new instance.
void UpdatePrintedDocument(PrintedDocument* new_document); void UpdatePrintedDocument(PrintedDocument* new_document);
// Processes a NOTIFY_PRINT_JOB_EVENT notification. // Processes a NOTIFY_PRINT_JOB_EVENT notification.
@ -126,6 +125,13 @@ class PrintJob : public PrintJobWorkerOwner,
void HoldUntilStopIsCalled(); void HoldUntilStopIsCalled();
#if defined(OS_WIN)
void OnPdfToEmfStarted(int page_count);
void OnPdfToEmfPageConverted(int page_number,
float scale_factor,
std::unique_ptr<MetafilePlayer> emf);
#endif // defined(OS_WIN)
content::NotificationRegistrar registrar_; content::NotificationRegistrar registrar_;
// Source that generates the PrintedPage's (i.e. a WebContents). It will be // Source that generates the PrintedPage's (i.e. a WebContents). It will be
@ -152,8 +158,9 @@ class PrintJob : public PrintJobWorkerOwner,
#if defined(OS_WIN) #if defined(OS_WIN)
class PdfToEmfState; class PdfToEmfState;
std::unique_ptr<PdfToEmfState> ptd_to_emf_state_; std::unique_ptr<PdfToEmfState> pdf_to_emf_state_;
#endif // OS_WIN std::vector<int> pdf_page_mapping_;
#endif // defined(OS_WIN)
// Used at shutdown so that we can quit a nested message loop. // Used at shutdown so that we can quit a nested message loop.
base::WeakPtrFactory<PrintJob> quit_factory_; base::WeakPtrFactory<PrintJob> quit_factory_;

28
chromium_src/chrome/browser/printing/print_job_manager.cc
View file

@ -35,7 +35,7 @@ scoped_refptr<PrinterQuery> PrintQueriesQueue::PopPrinterQuery(
for (PrinterQueries::iterator itr = queued_queries_.begin(); for (PrinterQueries::iterator itr = queued_queries_.begin();
itr != queued_queries_.end(); ++itr) { itr != queued_queries_.end(); ++itr) {
if ((*itr)->cookie() == document_cookie && !(*itr)->is_callback_pending()) { if ((*itr)->cookie() == document_cookie && !(*itr)->is_callback_pending()) {
scoped_refptr<printing::PrinterQuery> current_query(*itr); scoped_refptr<PrinterQuery> current_query(*itr);
queued_queries_.erase(itr); queued_queries_.erase(itr);
DCHECK(current_query->is_valid()); DCHECK(current_query->is_valid());
return current_query; return current_query;
@ -46,10 +46,9 @@ scoped_refptr<PrinterQuery> PrintQueriesQueue::PopPrinterQuery(
scoped_refptr<PrinterQuery> PrintQueriesQueue::CreatePrinterQuery( scoped_refptr<PrinterQuery> PrintQueriesQueue::CreatePrinterQuery(
int render_process_id, int render_process_id,
int render_view_id) { int render_frame_id) {
scoped_refptr<PrinterQuery> job = return make_scoped_refptr(
new printing::PrinterQuery(render_process_id, render_view_id); new PrinterQuery(render_process_id, render_frame_id));
return job;
} }
void PrintQueriesQueue::Shutdown() { void PrintQueriesQueue::Shutdown() {
@ -76,14 +75,14 @@ PrintJobManager::~PrintJobManager() {
} }
scoped_refptr<PrintQueriesQueue> PrintJobManager::queue() { scoped_refptr<PrintQueriesQueue> PrintJobManager::queue() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
if (!queue_.get()) if (!queue_.get())
queue_ = new PrintQueriesQueue(); queue_ = new PrintQueriesQueue();
return queue_; return queue_;
} }
void PrintJobManager::Shutdown() { void PrintJobManager::Shutdown() {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
DCHECK(!is_shutdown_); DCHECK(!is_shutdown_);
is_shutdown_ = true; is_shutdown_ = true;
registrar_.RemoveAll(); registrar_.RemoveAll();
@ -94,7 +93,7 @@ void PrintJobManager::Shutdown() {
} }
void PrintJobManager::StopJobs(bool wait_for_finish) { void PrintJobManager::StopJobs(bool wait_for_finish) {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// Copy the array since it can be modified in transit. // Copy the array since it can be modified in transit.
PrintJobs to_stop; PrintJobs to_stop;
to_stop.swap(current_jobs_); to_stop.swap(current_jobs_);
@ -111,18 +110,11 @@ void PrintJobManager::StopJobs(bool wait_for_finish) {
void PrintJobManager::Observe(int type, void PrintJobManager::Observe(int type,
const content::NotificationSource& source, const content::NotificationSource& source,
const content::NotificationDetails& details) { const content::NotificationDetails& details) {
DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
switch (type) { DCHECK_EQ(chrome::NOTIFICATION_PRINT_JOB_EVENT, type);
case chrome::NOTIFICATION_PRINT_JOB_EVENT: {
OnPrintJobEvent(content::Source<PrintJob>(source).ptr(), OnPrintJobEvent(content::Source<PrintJob>(source).ptr(),
*content::Details<JobEventDetails>(details).ptr()); *content::Details<JobEventDetails>(details).ptr());
break;
}
default: {
NOTREACHED();
break;
}
}
} }
void PrintJobManager::OnPrintJobEvent( void PrintJobManager::OnPrintJobEvent(

7
chromium_src/chrome/browser/printing/print_job_manager.h
View file

@ -10,6 +10,7 @@
#include <vector> #include <vector>
#include "base/logging.h" #include "base/logging.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "base/synchronization/lock.h" #include "base/synchronization/lock.h"
#include "base/threading/non_thread_safe.h" #include "base/threading/non_thread_safe.h"
@ -37,7 +38,7 @@ class PrintQueriesQueue : public base::RefCountedThreadSafe<PrintQueriesQueue> {
// Creates new query. // Creates new query.
scoped_refptr<PrinterQuery> CreatePrinterQuery(int render_process_id, scoped_refptr<PrinterQuery> CreatePrinterQuery(int render_process_id,
int render_view_id); int render_frame_id);
void Shutdown(); void Shutdown();
@ -58,13 +59,13 @@ class PrintQueriesQueue : public base::RefCountedThreadSafe<PrintQueriesQueue> {
class PrintJobManager : public content::NotificationObserver { class PrintJobManager : public content::NotificationObserver {
public: public:
PrintJobManager(); PrintJobManager();
virtual ~PrintJobManager(); ~PrintJobManager() override;
// On browser quit, we should wait to have the print job finished. // On browser quit, we should wait to have the print job finished.
void Shutdown(); void Shutdown();
// content::NotificationObserver // content::NotificationObserver
virtual void Observe(int type, void Observe(int type,
const content::NotificationSource& source, const content::NotificationSource& source,
const content::NotificationDetails& details) override; const content::NotificationDetails& details) override;

97
chromium_src/chrome/browser/printing/print_job_worker.cc
View file

@ -4,19 +4,25 @@
#include "chrome/browser/printing/print_job_worker.h" #include "chrome/browser/printing/print_job_worker.h"
#include <memory>
#include "base/bind.h" #include "base/bind.h"
#include "base/bind_helpers.h" #include "base/bind_helpers.h"
#include "base/callback.h" #include "base/callback.h"
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "base/location.h"
#include "base/memory/ptr_util.h"
#include "base/message_loop/message_loop.h" #include "base/message_loop/message_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h" #include "base/threading/thread_task_runner_handle.h"
#include "base/values.h" #include "base/values.h"
#include "build/build_config.h"
#include "chrome/browser/browser_process.h" #include "chrome/browser/browser_process.h"
#include "chrome/browser/chrome_notification_types.h" #include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/printing/print_job.h" #include "chrome/browser/printing/print_job.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
#include "content/public/browser/notification_service.h" #include "content/public/browser/notification_service.h"
#include "content/public/browser/render_view_host.h" #include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h" #include "content/public/browser/web_contents.h"
#include "printing/print_job_constants.h" #include "printing/print_job_constants.h"
#include "printing/printed_document.h" #include "printing/printed_document.h"
@ -31,41 +37,45 @@ namespace printing {
namespace { namespace {
// Helper function to ensure |owner| is valid until at least |callback| returns. // Helper function to ensure |owner| is valid until at least |callback| returns.
void HoldRefCallback(const scoped_refptr<printing::PrintJobWorkerOwner>& owner, void HoldRefCallback(const scoped_refptr<PrintJobWorkerOwner>& owner,
const base::Closure& callback) { const base::Closure& callback) {
callback.Run(); callback.Run();
} }
class PrintingContextDelegate : public PrintingContext::Delegate { class PrintingContextDelegate : public PrintingContext::Delegate {
public: public:
PrintingContextDelegate(int render_process_id, int render_view_id); PrintingContextDelegate(int render_process_id, int render_frame_id);
virtual ~PrintingContextDelegate(); ~PrintingContextDelegate() override;
virtual gfx::NativeView GetParentView() override; gfx::NativeView GetParentView() override;
virtual std::string GetAppLocale() override; std::string GetAppLocale() override;
// Not exposed to PrintingContext::Delegate because of dependency issues.
content::WebContents* GetWebContents();
private: private:
int render_process_id_; const int render_process_id_;
int render_view_id_; const int render_frame_id_;
}; };
PrintingContextDelegate::PrintingContextDelegate(int render_process_id, PrintingContextDelegate::PrintingContextDelegate(int render_process_id,
int render_view_id) int render_frame_id)
: render_process_id_(render_process_id), : render_process_id_(render_process_id),
render_view_id_(render_view_id) { render_frame_id_(render_frame_id) {}
}
PrintingContextDelegate::~PrintingContextDelegate() { PrintingContextDelegate::~PrintingContextDelegate() {
} }
gfx::NativeView PrintingContextDelegate::GetParentView() { gfx::NativeView PrintingContextDelegate::GetParentView() {
content::WebContents* wc = GetWebContents();
return wc ? wc->GetNativeView() : nullptr;
}
content::WebContents* PrintingContextDelegate::GetWebContents() {
DCHECK_CURRENTLY_ON(BrowserThread::UI); DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::RenderViewHost* view = auto* rfh =
content::RenderViewHost::FromID(render_process_id_, render_view_id_); content::RenderFrameHost::FromID(render_process_id_, render_frame_id_);
if (!view) return rfh ? content::WebContents::FromRenderFrameHost(rfh) : nullptr;
return NULL;
content::WebContents* wc = content::WebContents::FromRenderViewHost(view);
return wc ? wc->GetNativeView() : NULL;
} }
std::string PrintingContextDelegate::GetAppLocale() { std::string PrintingContextDelegate::GetAppLocale() {
@ -84,17 +94,24 @@ void NotificationCallback(PrintJobWorkerOwner* print_job,
content::Details<JobEventDetails>(details)); content::Details<JobEventDetails>(details));
} }
void PostOnOwnerThread(const scoped_refptr<PrintJobWorkerOwner>& owner,
const PrintingContext::PrintSettingsCallback& callback,
PrintingContext::Result result) {
owner->PostTask(FROM_HERE, base::Bind(&HoldRefCallback, owner,
base::Bind(callback, result)));
}
} // namespace } // namespace
PrintJobWorker::PrintJobWorker(int render_process_id, PrintJobWorker::PrintJobWorker(int render_process_id,
int render_view_id, int render_frame_id,
PrintJobWorkerOwner* owner) PrintJobWorkerOwner* owner)
: owner_(owner), thread_("Printing_Worker"), weak_factory_(this) { : owner_(owner), thread_("Printing_Worker"), weak_factory_(this) {
// The object is created in the IO thread. // The object is created in the IO thread.
DCHECK(owner_->RunsTasksOnCurrentThread()); DCHECK(owner_->RunsTasksOnCurrentThread());
printing_context_delegate_.reset( printing_context_delegate_ = base::MakeUnique<PrintingContextDelegate>(
new PrintingContextDelegate(render_process_id, render_view_id)); render_process_id, render_frame_id);
printing_context_ = PrintingContext::Create(printing_context_delegate_.get()); printing_context_ = PrintingContext::Create(printing_context_delegate_.get());
} }
@ -111,11 +128,12 @@ void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
owner_ = new_owner; owner_ = new_owner;
} }
void PrintJobWorker::GetSettings( void PrintJobWorker::GetSettings(bool ask_user_for_settings,
bool ask_user_for_settings,
int document_page_count, int document_page_count,
bool has_selection, bool has_selection,
MarginType margin_type) { MarginType margin_type,
bool is_scripted,
bool is_modifiable) {
DCHECK(task_runner_->RunsTasksOnCurrentThread()); DCHECK(task_runner_->RunsTasksOnCurrentThread());
DCHECK_EQ(page_number_, PageNumber::npos()); DCHECK_EQ(page_number_, PageNumber::npos());
@ -126,6 +144,7 @@ void PrintJobWorker::GetSettings(
// should happen on the same thread. See http://crbug.com/73466 // should happen on the same thread. See http://crbug.com/73466
// MessageLoop::current()->SetNestableTasksAllowed(true); // MessageLoop::current()->SetNestableTasksAllowed(true);
printing_context_->set_margin_type(margin_type); printing_context_->set_margin_type(margin_type);
printing_context_->set_is_modifiable(is_modifiable);
// When we delegate to a destination, we don't ask the user for settings. // When we delegate to a destination, we don't ask the user for settings.
// TODO(mad): Ask the destination for settings. // TODO(mad): Ask the destination for settings.
@ -136,7 +155,8 @@ void PrintJobWorker::GetSettings(
base::Bind(&PrintJobWorker::GetSettingsWithUI, base::Bind(&PrintJobWorker::GetSettingsWithUI,
base::Unretained(this), base::Unretained(this),
document_page_count, document_page_count,
has_selection))); has_selection,
is_scripted)));
} else { } else {
BrowserThread::PostTask( BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, BrowserThread::UI, FROM_HERE,
@ -188,23 +208,16 @@ void PrintJobWorker::GetSettingsDone(PrintingContext::Result result) {
void PrintJobWorker::GetSettingsWithUI( void PrintJobWorker::GetSettingsWithUI(
int document_page_count, int document_page_count,
bool has_selection) { bool has_selection,
bool is_scripted) {
DCHECK_CURRENTLY_ON(BrowserThread::UI); DCHECK_CURRENTLY_ON(BrowserThread::UI);
printing_context_->AskUserForSettings(
document_page_count,
has_selection,
false,
base::Bind(&PrintJobWorker::GetSettingsWithUIDone,
base::Unretained(this)));
}
void PrintJobWorker::GetSettingsWithUIDone(PrintingContext::Result result) { // weak_factory_ creates pointers valid only on owner_ thread.
PostTask(FROM_HERE, printing_context_->AskUserForSettings(
base::Bind(&HoldRefCallback, document_page_count, has_selection, is_scripted,
make_scoped_refptr(owner_), base::Bind(&PostOnOwnerThread, make_scoped_refptr(owner_),
base::Bind(&PrintJobWorker::GetSettingsDone, base::Bind(&PrintJobWorker::GetSettingsDone,
base::Unretained(this), weak_factory_.GetWeakPtr())));
result)));
} }
void PrintJobWorker::UseDefaultSettings() { void PrintJobWorker::UseDefaultSettings() {
@ -225,8 +238,6 @@ void PrintJobWorker::StartPrinting(PrintedDocument* new_document) {
base::string16 document_name = base::string16 document_name =
printing::SimplifyDocumentTitle(document_->name()); printing::SimplifyDocumentTitle(document_->name());
if (document_name.empty()) {
}
PrintingContext::Result result = PrintingContext::Result result =
printing_context_->NewDocument(document_name); printing_context_->NewDocument(document_name);
if (result != PrintingContext::OK) { if (result != PrintingContext::OK) {
@ -352,7 +363,8 @@ void PrintJobWorker::SpoolPage(PrintedPage* page) {
DCHECK_NE(page_number_, PageNumber::npos()); DCHECK_NE(page_number_, PageNumber::npos());
// Signal everyone that the page is about to be printed. // Signal everyone that the page is about to be printed.
owner_->PostTask(FROM_HERE, owner_->PostTask(
FROM_HERE,
base::Bind(&NotificationCallback, base::RetainedRef(owner_), base::Bind(&NotificationCallback, base::RetainedRef(owner_),
JobEventDetails::NEW_PAGE, base::RetainedRef(document_), JobEventDetails::NEW_PAGE, base::RetainedRef(document_),
base::RetainedRef(page))); base::RetainedRef(page)));
@ -390,8 +402,7 @@ void PrintJobWorker::OnFailure() {
// We may loose our last reference by broadcasting the FAILED event. // We may loose our last reference by broadcasting the FAILED event.
scoped_refptr<PrintJobWorkerOwner> handle(owner_); scoped_refptr<PrintJobWorkerOwner> handle(owner_);
owner_->PostTask( owner_->PostTask(FROM_HERE,
FROM_HERE,
base::Bind(&NotificationCallback, base::RetainedRef(owner_), base::Bind(&NotificationCallback, base::RetainedRef(owner_),
JobEventDetails::FAILED, JobEventDetails::FAILED,
base::RetainedRef(document_), nullptr)); base::RetainedRef(document_), nullptr));

23
chromium_src/chrome/browser/printing/print_job_worker.h
View file

@ -7,9 +7,11 @@
#include <memory> #include <memory>
#include "base/macros.h"
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h" #include "base/memory/weak_ptr.h"
#include "base/threading/thread.h" #include "base/threading/thread.h"
#include "chrome/browser/printing/printer_query.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
#include "printing/page_number.h" #include "printing/page_number.h"
#include "printing/print_job_constants.h" #include "printing/print_job_constants.h"
@ -34,19 +36,22 @@ class PrintedPage;
class PrintJobWorker { class PrintJobWorker {
public: public:
PrintJobWorker(int render_process_id, PrintJobWorker(int render_process_id,
int render_view_id, int render_frame_id,
PrintJobWorkerOwner* owner); PrintJobWorkerOwner* owner);
virtual ~PrintJobWorker(); virtual ~PrintJobWorker();
void SetNewOwner(PrintJobWorkerOwner* new_owner); void SetNewOwner(PrintJobWorkerOwner* new_owner);
// Initializes the print settings. If |ask_user_for_settings| is true, a // Initializes the print settings. If |ask_user_for_settings| is true, a
// Print... dialog box will be shown to ask the user his preference. // Print... dialog box will be shown to ask the user their preference.
void GetSettings( // |is_scripted| should be true for calls coming straight from window.print().
bool ask_user_for_settings, // |is_modifiable| implies HTML and not other formats like PDF.
void GetSettings(bool ask_user_for_settings,
int document_page_count, int document_page_count,
bool has_selection, bool has_selection,
MarginType margin_type); MarginType margin_type,
bool is_scripted,
bool is_modifiable);
// Set the new print settings. // Set the new print settings.
void SetSettings(std::unique_ptr<base::DictionaryValue> new_settings); void SetSettings(std::unique_ptr<base::DictionaryValue> new_settings);
@ -109,12 +114,8 @@ class PrintJobWorker {
// but sticks with this for consistency. // but sticks with this for consistency.
void GetSettingsWithUI( void GetSettingsWithUI(
int document_page_count, int document_page_count,
bool has_selection); bool has_selection,
bool is_scripted);
// The callback used by PrintingContext::GetSettingsWithUI() to notify this
// object that the print settings are set. This is needed in order to bounce
// back into the IO thread for GetSettingsDone().
void GetSettingsWithUIDone(PrintingContext::Result result);
// Called on the UI thread to update the print settings. // Called on the UI thread to update the print settings.
void UpdatePrintSettings(std::unique_ptr<base::DictionaryValue> new_settings); void UpdatePrintSettings(std::unique_ptr<base::DictionaryValue> new_settings);

7
chromium_src/chrome/browser/printing/print_job_worker_owner.cc
View file

@ -4,13 +4,14 @@
#include "chrome/browser/printing/print_job_worker_owner.h" #include "chrome/browser/printing/print_job_worker_owner.h"
#include "base/message_loop/message_loop.h" #include "base/location.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
namespace printing { namespace printing {
PrintJobWorkerOwner::PrintJobWorkerOwner() PrintJobWorkerOwner::PrintJobWorkerOwner()
: task_runner_(base::MessageLoop::current()->task_runner()) { : task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
}
PrintJobWorkerOwner::~PrintJobWorkerOwner() { PrintJobWorkerOwner::~PrintJobWorkerOwner() {
} }

5
chromium_src/chrome/browser/printing/print_job_worker_owner.h
View file

@ -5,6 +5,8 @@
#ifndef CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_OWNER_H__ #ifndef CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_OWNER_H__
#define CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_OWNER_H__ #define CHROME_BROWSER_PRINTING_PRINT_JOB_WORKER_OWNER_H__
#include <memory>
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "printing/printing_context.h" #include "printing/printing_context.h"
@ -34,7 +36,8 @@ class PrintJobWorkerOwner
PrintingContext::Result result) = 0; PrintingContext::Result result) = 0;
// Detach the PrintJobWorker associated to this object. // Detach the PrintJobWorker associated to this object.
virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) = 0; virtual std::unique_ptr<PrintJobWorker> DetachWorker(
PrintJobWorkerOwner* new_owner) = 0;
// Access the current settings. // Access the current settings.
virtual const PrintSettings& settings() const = 0; virtual const PrintSettings& settings() const = 0;

5
chromium_src/chrome/browser/printing/print_preview_message_handler.cc
View file

@ -11,6 +11,7 @@
#include "chrome/browser/printing/printer_query.h" #include "chrome/browser/printing/printer_query.h"
#include "chrome/common/print_messages.h" #include "chrome/common/print_messages.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_view_host.h" #include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents.h" #include "content/public/browser/web_contents.h"
#include "printing/page_size_margins.h" #include "printing/page_size_margins.h"
@ -116,8 +117,8 @@ void PrintPreviewMessageHandler::PrintToPDF(
options.GetInteger(printing::kPreviewRequestID, &request_id); options.GetInteger(printing::kPreviewRequestID, &request_id);
print_to_pdf_callback_map_[request_id] = callback; print_to_pdf_callback_map_[request_id] = callback;
content::RenderViewHost* rvh = web_contents()->GetRenderViewHost(); content::RenderFrameHost* rfh = web_contents()->GetMainFrame();
rvh->Send(new PrintMsg_PrintPreview(rvh->GetRoutingID(), options)); rfh->Send(new PrintMsg_PrintPreview(rfh->GetRoutingID(), options));
} }
void PrintPreviewMessageHandler::RunPrintToPDFCallback( void PrintPreviewMessageHandler::RunPrintToPDFCallback(

47
chromium_src/chrome/browser/printing/printer_query.cc
View file

@ -4,6 +4,9 @@
#include "chrome/browser/printing/printer_query.h" #include "chrome/browser/printing/printer_query.h"
#include <memory>
#include <utility>
#include "base/bind.h" #include "base/bind.h"
#include "base/bind_helpers.h" #include "base/bind_helpers.h"
#include "base/message_loop/message_loop.h" #include "base/message_loop/message_loop.h"
@ -13,8 +16,8 @@
namespace printing { namespace printing {
PrinterQuery::PrinterQuery(int render_process_id, int render_view_id) PrinterQuery::PrinterQuery(int render_process_id, int render_frame_id)
: worker_(new PrintJobWorker(render_process_id, render_view_id, this)), : worker_(new PrintJobWorker(render_process_id, render_frame_id, this)),
is_print_dialog_box_shown_(false), is_print_dialog_box_shown_(false),
cookie_(PrintSettings::NewCookie()), cookie_(PrintSettings::NewCookie()),
last_status_(PrintingContext::FAILED) { last_status_(PrintingContext::FAILED) {
@ -25,7 +28,7 @@ PrinterQuery::~PrinterQuery() {
// The job should be finished (or at least canceled) when it is destroyed. // The job should be finished (or at least canceled) when it is destroyed.
DCHECK(!is_print_dialog_box_shown_); DCHECK(!is_print_dialog_box_shown_);
// If this fires, it is that this pending printer context has leaked. // If this fires, it is that this pending printer context has leaked.
DCHECK(!worker_.get()); DCHECK(!worker_);
} }
void PrinterQuery::GetSettingsDone(const PrintSettings& new_settings, void PrinterQuery::GetSettingsDone(const PrintSettings& new_settings,
@ -47,12 +50,13 @@ void PrinterQuery::GetSettingsDone(const PrintSettings& new_settings,
} }
} }
PrintJobWorker* PrinterQuery::DetachWorker(PrintJobWorkerOwner* new_owner) { std::unique_ptr<PrintJobWorker> PrinterQuery::DetachWorker(
PrintJobWorkerOwner* new_owner) {
DCHECK(callback_.is_null()); DCHECK(callback_.is_null());
DCHECK(worker_.get()); DCHECK(worker_);
worker_->SetNewOwner(new_owner); worker_->SetNewOwner(new_owner);
return worker_.release(); return std::move(worker_);
} }
const PrintSettings& PrinterQuery::settings() const { const PrintSettings& PrinterQuery::settings() const {
@ -63,29 +67,30 @@ int PrinterQuery::cookie() const {
return cookie_; return cookie_;
} }
void PrinterQuery::GetSettings( void PrinterQuery::GetSettings(GetSettingsAskParam ask_user_for_settings,
GetSettingsAskParam ask_user_for_settings,
int expected_page_count, int expected_page_count,
bool has_selection, bool has_selection,
MarginType margin_type, MarginType margin_type,
bool is_scripted,
bool is_modifiable,
const base::Closure& callback) { const base::Closure& callback) {
DCHECK(RunsTasksOnCurrentThread()); DCHECK(RunsTasksOnCurrentThread());
DCHECK(!is_print_dialog_box_shown_); DCHECK(!is_print_dialog_box_shown_ || !is_scripted);
StartWorker(callback); StartWorker(callback);
// Real work is done in PrintJobWorker::GetSettings(). // Real work is done in PrintJobWorker::GetSettings().
is_print_dialog_box_shown_ = ask_user_for_settings == ASK_USER; is_print_dialog_box_shown_ =
worker_->PostTask(FROM_HERE, ask_user_for_settings == GetSettingsAskParam::ASK_USER;
base::Bind(&PrintJobWorker::GetSettings, worker_->PostTask(
base::Unretained(worker_.get()), FROM_HERE,
is_print_dialog_box_shown_, base::Bind(&PrintJobWorker::GetSettings, base::Unretained(worker_.get()),
expected_page_count, is_print_dialog_box_shown_, expected_page_count, has_selection,
has_selection, margin_type, is_scripted, is_modifiable));
margin_type));
} }
void PrinterQuery::SetSettings(std::unique_ptr<base::DictionaryValue> new_settings, void PrinterQuery::SetSettings(
std::unique_ptr<base::DictionaryValue> new_settings,
const base::Closure& callback) { const base::Closure& callback) {
StartWorker(callback); StartWorker(callback);
@ -97,7 +102,7 @@ void PrinterQuery::SetSettings(std::unique_ptr<base::DictionaryValue> new_settin
void PrinterQuery::StartWorker(const base::Closure& callback) { void PrinterQuery::StartWorker(const base::Closure& callback) {
DCHECK(callback_.is_null()); DCHECK(callback_.is_null());
DCHECK(worker_.get()); DCHECK(worker_);
// Lazily create the worker thread. There is one worker thread per print job. // Lazily create the worker thread. There is one worker thread per print job.
if (!worker_->IsRunning()) if (!worker_->IsRunning())
@ -107,7 +112,7 @@ void PrinterQuery::StartWorker(const base::Closure& callback) {
} }
void PrinterQuery::StopWorker() { void PrinterQuery::StopWorker() {
if (worker_.get()) { if (worker_) {
// http://crbug.com/66082: We're blocking on the PrinterQuery's worker // http://crbug.com/66082: We're blocking on the PrinterQuery's worker
// thread. It's not clear to me if this may result in blocking the current // thread. It's not clear to me if this may result in blocking the current
// thread for an unacceptable time. We should probably fix it. // thread for an unacceptable time. We should probably fix it.
@ -122,7 +127,7 @@ bool PrinterQuery::is_callback_pending() const {
} }
bool PrinterQuery::is_valid() const { bool PrinterQuery::is_valid() const {
return worker_.get() != NULL; return !!worker_;
} }
} // namespace printing } // namespace printing

21
chromium_src/chrome/browser/printing/printer_query.h
View file

@ -9,6 +9,7 @@
#include "base/callback.h" #include "base/callback.h"
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "base/macros.h"
#include "chrome/browser/printing/print_job_worker_owner.h" #include "chrome/browser/printing/print_job_worker_owner.h"
#include "printing/print_job_constants.h" #include "printing/print_job_constants.h"
@ -25,29 +26,31 @@ class PrintJobWorker;
class PrinterQuery : public PrintJobWorkerOwner { class PrinterQuery : public PrintJobWorkerOwner {
public: public:
// GetSettings() UI parameter. // GetSettings() UI parameter.
enum GetSettingsAskParam { enum class GetSettingsAskParam {
DEFAULTS, DEFAULTS,
ASK_USER, ASK_USER,
}; };
PrinterQuery(int render_process_id, int render_view_id); PrinterQuery(int render_process_id, int render_frame_id);
// PrintJobWorkerOwner implementation. // PrintJobWorkerOwner implementation.
virtual void GetSettingsDone(const PrintSettings& new_settings, void GetSettingsDone(const PrintSettings& new_settings,
PrintingContext::Result result) override; PrintingContext::Result result) override;
virtual PrintJobWorker* DetachWorker(PrintJobWorkerOwner* new_owner) override; std::unique_ptr<PrintJobWorker> DetachWorker(
virtual const PrintSettings& settings() const override; PrintJobWorkerOwner* new_owner) override;
virtual int cookie() const override; const PrintSettings& settings() const override;
int cookie() const override;
// Initializes the printing context. It is fine to call this function multiple // Initializes the printing context. It is fine to call this function multiple
// times to reinitialize the settings. |web_contents_observer| can be queried // times to reinitialize the settings. |web_contents_observer| can be queried
// to find the owner of the print setting dialog box. It is unused when // to find the owner of the print setting dialog box. It is unused when
// |ask_for_user_settings| is DEFAULTS. // |ask_for_user_settings| is DEFAULTS.
void GetSettings( void GetSettings(GetSettingsAskParam ask_user_for_settings,
GetSettingsAskParam ask_user_for_settings,
int expected_page_count, int expected_page_count,
bool has_selection, bool has_selection,
MarginType margin_type, MarginType margin_type,
bool is_scripted,
bool is_modifiable,
const base::Closure& callback); const base::Closure& callback);
// Updates the current settings with |new_settings| dictionary values. // Updates the current settings with |new_settings| dictionary values.
@ -66,7 +69,7 @@ class PrinterQuery : public PrintJobWorkerOwner {
bool is_valid() const; bool is_valid() const;
private: private:
virtual ~PrinterQuery(); ~PrinterQuery() override;
// Lazy create the worker thread. There is one worker thread per print job. // Lazy create the worker thread. There is one worker thread per print job.
void StartWorker(const base::Closure& callback); void StartWorker(const base::Closure& callback);

219
chromium_src/chrome/browser/printing/printing_message_filter.cc
View file

@ -14,23 +14,12 @@
#include "chrome/browser/profiles/profile_io_data.h" #include "chrome/browser/profiles/profile_io_data.h"
#include "chrome/common/print_messages.h" #include "chrome/common/print_messages.h"
#include "content/public/browser/browser_thread.h" #include "content/public/browser/browser_thread.h"
#include "content/public/browser/render_view_host.h" #include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h" #include "content/public/browser/web_contents.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/common/child_process_host.h" #include "content/public/common/child_process_host.h"
#include "printing/features/features.h"
#if defined(ENABLE_FULL_PRINTING)
#include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
#endif
#if defined(OS_CHROMEOS)
#include <fcntl.h>
#include <map>
#include "base/files/file_util.h"
#include "base/lazy_instance.h"
#include "chrome/browser/printing/print_dialog_cloud.h"
#endif
#if defined(OS_ANDROID) #if defined(OS_ANDROID)
#include "base/strings/string_number_conversions.h" #include "base/strings/string_number_conversions.h"
@ -44,19 +33,6 @@ namespace printing {
namespace { namespace {
#if defined(OS_CHROMEOS)
typedef std::map<int, base::FilePath> SequenceToPathMap;
struct PrintingSequencePathMap {
SequenceToPathMap map;
int sequence;
};
// No locking, only access on the FILE thread.
static base::LazyInstance<PrintingSequencePathMap>
g_printing_file_descriptor_map = LAZY_INSTANCE_INITIALIZER;
#endif
void RenderParamsFromPrintSettings(const PrintSettings& settings, void RenderParamsFromPrintSettings(const PrintSettings& settings,
PrintMsg_Print_Params* params) { PrintMsg_Print_Params* params) {
params->page_size = settings.page_setup_device_units().physical_size(); params->page_size = settings.page_setup_device_units().physical_size();
@ -71,6 +47,7 @@ void RenderParamsFromPrintSettings(const PrintSettings& settings,
params->margin_top = settings.page_setup_device_units().content_area().y(); params->margin_top = settings.page_setup_device_units().content_area().y();
params->margin_left = settings.page_setup_device_units().content_area().x(); params->margin_left = settings.page_setup_device_units().content_area().x();
params->dpi = settings.dpi(); params->dpi = settings.dpi();
params->scale_factor = settings.scale_factor();
// Currently hardcoded at 72dpi. See PrintSettings' constructor. // Currently hardcoded at 72dpi. See PrintSettings' constructor.
params->desired_dpi = settings.desired_dpi(); params->desired_dpi = settings.desired_dpi();
// Always use an invalid cookie. // Always use an invalid cookie.
@ -78,10 +55,30 @@ void RenderParamsFromPrintSettings(const PrintSettings& settings,
params->selection_only = settings.selection_only(); params->selection_only = settings.selection_only();
params->supports_alpha_blend = settings.supports_alpha_blend(); params->supports_alpha_blend = settings.supports_alpha_blend();
params->should_print_backgrounds = settings.should_print_backgrounds(); params->should_print_backgrounds = settings.should_print_backgrounds();
params->display_header_footer = settings.display_header_footer();
params->title = settings.title(); params->title = settings.title();
params->url = settings.url(); params->url = settings.url();
} }
#if defined(OS_ANDROID)
content::WebContents* GetWebContentsForRenderFrame(int render_process_id,
int render_frame_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::RenderFrameHost* frame =
content::RenderFrameHost::FromID(render_process_id, render_frame_id);
return frame ? content::WebContents::FromRenderFrameHost(frame) : nullptr;
}
PrintViewManagerBasic* GetPrintManager(int render_process_id,
int render_frame_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::WebContents* web_contents =
GetWebContentsForRenderFrame(render_process_id, render_frame_id);
return web_contents ? PrintViewManagerBasic::FromWebContents(web_contents)
: nullptr;
}
#endif
} // namespace } // namespace
PrintingMessageFilter::PrintingMessageFilter(int render_process_id) PrintingMessageFilter::PrintingMessageFilter(int render_process_id)
@ -94,14 +91,13 @@ PrintingMessageFilter::PrintingMessageFilter(int render_process_id)
PrintingMessageFilter::~PrintingMessageFilter() { PrintingMessageFilter::~PrintingMessageFilter() {
} }
void PrintingMessageFilter::OnDestruct() const {
BrowserThread::DeleteOnUIThread::Destruct(this);
}
void PrintingMessageFilter::OverrideThreadForMessage( void PrintingMessageFilter::OverrideThreadForMessage(
const IPC::Message& message, BrowserThread::ID* thread) { const IPC::Message& message, BrowserThread::ID* thread) {
#if defined(OS_CHROMEOS) #if defined(OS_ANDROID)
if (message.type() == PrintHostMsg_AllocateTempFileForPrinting::ID ||
message.type() == PrintHostMsg_TempFileForPrintingWritten::ID) {
*thread = BrowserThread::FILE;
}
#elif defined(OS_ANDROID)
if (message.type() == PrintHostMsg_AllocateTempFileForPrinting::ID || if (message.type() == PrintHostMsg_AllocateTempFileForPrinting::ID ||
message.type() == PrintHostMsg_TempFileForPrintingWritten::ID) { message.type() == PrintHostMsg_TempFileForPrintingWritten::ID) {
*thread = BrowserThread::UI; *thread = BrowserThread::UI;
@ -112,10 +108,7 @@ void PrintingMessageFilter::OverrideThreadForMessage(
bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) { bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
bool handled = true; bool handled = true;
IPC_BEGIN_MESSAGE_MAP(PrintingMessageFilter, message) IPC_BEGIN_MESSAGE_MAP(PrintingMessageFilter, message)
#if defined(OS_WIN) #if defined(OS_ANDROID)
IPC_MESSAGE_HANDLER(PrintHostMsg_DuplicateSection, OnDuplicateSection)
#endif
#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
IPC_MESSAGE_HANDLER(PrintHostMsg_AllocateTempFileForPrinting, IPC_MESSAGE_HANDLER(PrintHostMsg_AllocateTempFileForPrinting,
OnAllocateTempFileForPrinting) OnAllocateTempFileForPrinting)
IPC_MESSAGE_HANDLER(PrintHostMsg_TempFileForPrintingWritten, IPC_MESSAGE_HANDLER(PrintHostMsg_TempFileForPrintingWritten,
@ -126,139 +119,46 @@ bool PrintingMessageFilter::OnMessageReceived(const IPC::Message& message) {
IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint) IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_ScriptedPrint, OnScriptedPrint)
IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings, IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_UpdatePrintSettings,
OnUpdatePrintSettings) OnUpdatePrintSettings)
#if defined(ENABLE_FULL_PRINTING)
IPC_MESSAGE_HANDLER(PrintHostMsg_CheckForCancel, OnCheckForCancel)
#endif
IPC_MESSAGE_UNHANDLED(handled = false) IPC_MESSAGE_UNHANDLED(handled = false)
IPC_END_MESSAGE_MAP() IPC_END_MESSAGE_MAP()
return handled; return handled;
} }
#if defined(OS_WIN) #if defined(OS_ANDROID)
void PrintingMessageFilter::OnDuplicateSection(
base::SharedMemoryHandle renderer_handle,
base::SharedMemoryHandle* browser_handle) {
// Duplicate the handle in this process right now so the memory is kept alive
// (even if it is not mapped)
base::SharedMemory shared_buf(renderer_handle, true);
shared_buf.GiveToProcess(base::GetCurrentProcessHandle(), browser_handle);
}
#endif
#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
void PrintingMessageFilter::OnAllocateTempFileForPrinting( void PrintingMessageFilter::OnAllocateTempFileForPrinting(
int render_view_id, int render_frame_id,
base::FileDescriptor* temp_file_fd, base::FileDescriptor* temp_file_fd,
int* sequence_number) { int* sequence_number) {
#if defined(OS_CHROMEOS)
// TODO(thestig): Use |render_view_id| for Chrome OS.
DCHECK_CURRENTLY_ON(BrowserThread::FILE);
temp_file_fd->fd = *sequence_number = -1;
temp_file_fd->auto_close = false;
SequenceToPathMap* map = &g_printing_file_descriptor_map.Get().map;
*sequence_number = g_printing_file_descriptor_map.Get().sequence++;
base::FilePath path;
if (base::CreateTemporaryFile(&path)) {
int fd = open(path.value().c_str(), O_WRONLY);
if (fd >= 0) {
SequenceToPathMap::iterator it = map->find(*sequence_number);
if (it != map->end()) {
NOTREACHED() << "Sequence number already in use. seq=" <<
*sequence_number;
} else {
(*map)[*sequence_number] = path;
temp_file_fd->fd = fd;
temp_file_fd->auto_close = true;
}
}
}
#elif defined(OS_ANDROID)
DCHECK_CURRENTLY_ON(BrowserThread::UI); DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::WebContents* wc = GetWebContentsForRenderView(render_view_id);
if (!wc)
return;
PrintViewManagerBasic* print_view_manager = PrintViewManagerBasic* print_view_manager =
PrintViewManagerBasic::FromWebContents(wc); GetPrintManager(render_process_id_, render_frame_id);
if (!print_view_manager)
return;
// The file descriptor is originally created in & passed from the Android // The file descriptor is originally created in & passed from the Android
// side, and it will handle the closing. // side, and it will handle the closing.
const base::FileDescriptor& file_descriptor = temp_file_fd->fd = print_view_manager->file_descriptor().fd;
print_view_manager->file_descriptor();
temp_file_fd->fd = file_descriptor.fd;
temp_file_fd->auto_close = false; temp_file_fd->auto_close = false;
#endif
} }
void PrintingMessageFilter::OnTempFileForPrintingWritten(int render_view_id, void PrintingMessageFilter::OnTempFileForPrintingWritten(int render_frame_id,
int sequence_number) { int sequence_number) {
#if defined(OS_CHROMEOS)
DCHECK_CURRENTLY_ON(BrowserThread::FILE);
SequenceToPathMap* map = &g_printing_file_descriptor_map.Get().map;
SequenceToPathMap::iterator it = map->find(sequence_number);
if (it == map->end()) {
NOTREACHED() << "Got a sequence that we didn't pass to the "
"renderer: " << sequence_number;
return;
}
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&PrintingMessageFilter::CreatePrintDialogForFile,
this, render_view_id, it->second));
// Erase the entry in the map.
map->erase(it);
#elif defined(OS_ANDROID)
DCHECK_CURRENTLY_ON(BrowserThread::UI); DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::WebContents* wc = GetWebContentsForRenderView(render_view_id);
if (!wc)
return;
PrintViewManagerBasic* print_view_manager = PrintViewManagerBasic* print_view_manager =
PrintViewManagerBasic::FromWebContents(wc); GetPrintManager(render_process_id_, render_frame_id);
const base::FileDescriptor& file_descriptor = if (print_view_manager)
print_view_manager->file_descriptor(); print_view_manager->PdfWritingDone(true);
PrintingContextAndroid::PdfWritingDone(file_descriptor.fd, true);
// Invalidate the file descriptor so it doesn't accidentally get reused.
print_view_manager->set_file_descriptor(base::FileDescriptor(-1, false));
#endif
}
#endif // defined(OS_CHROMEOS) || defined(OS_ANDROID)
#if defined(OS_CHROMEOS)
void PrintingMessageFilter::CreatePrintDialogForFile(
int render_view_id,
const base::FilePath& path) {
content::WebContents* wc = GetWebContentsForRenderView(render_view_id);
if (!wc)
return;
print_dialog_cloud::CreatePrintDialogForFile(
wc->GetBrowserContext(),
wc->GetTopLevelNativeWindow(),
path,
wc->GetTitle(),
base::string16(),
std::string("application/pdf"));
}
#endif // defined(OS_CHROMEOS)
content::WebContents* PrintingMessageFilter::GetWebContentsForRenderView(
int render_view_id) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
content::RenderViewHost* view = content::RenderViewHost::FromID(
render_process_id_, render_view_id);
return view ? content::WebContents::FromRenderViewHost(view) : NULL;
} }
#endif // defined(OS_ANDROID)
void PrintingMessageFilter::OnGetDefaultPrintSettings(IPC::Message* reply_msg) { void PrintingMessageFilter::OnGetDefaultPrintSettings(IPC::Message* reply_msg) {
DCHECK_CURRENTLY_ON(BrowserThread::IO); DCHECK_CURRENTLY_ON(BrowserThread::IO);
scoped_refptr<PrinterQuery> printer_query; scoped_refptr<PrinterQuery> printer_query;
#if 0 if (false) {
if (!profile_io_data_->printing_enabled()->GetValue()) {
// Reply with NULL query. // Reply with NULL query.
OnGetDefaultPrintSettingsReply(printer_query, reply_msg); OnGetDefaultPrintSettingsReply(printer_query, reply_msg);
return; return;
} }
#endif
printer_query = queue_->PopPrinterQuery(0); printer_query = queue_->PopPrinterQuery(0);
if (!printer_query.get()) { if (!printer_query.get()) {
printer_query = printer_query =
@ -268,14 +168,10 @@ void PrintingMessageFilter::OnGetDefaultPrintSettings(IPC::Message* reply_msg) {
// Loads default settings. This is asynchronous, only the IPC message sender // Loads default settings. This is asynchronous, only the IPC message sender
// will hang until the settings are retrieved. // will hang until the settings are retrieved.
printer_query->GetSettings( printer_query->GetSettings(
PrinterQuery::DEFAULTS, PrinterQuery::GetSettingsAskParam::DEFAULTS, 0, false, DEFAULT_MARGINS,
0, false, false,
false, base::Bind(&PrintingMessageFilter::OnGetDefaultPrintSettingsReply, this,
DEFAULT_MARGINS, printer_query, reply_msg));
base::Bind(&PrintingMessageFilter::OnGetDefaultPrintSettingsReply,
this,
printer_query,
reply_msg));
} }
void PrintingMessageFilter::OnGetDefaultPrintSettingsReply( void PrintingMessageFilter::OnGetDefaultPrintSettingsReply(
@ -312,14 +208,10 @@ void PrintingMessageFilter::OnScriptedPrint(
queue_->CreatePrinterQuery(render_process_id_, reply_msg->routing_id()); queue_->CreatePrinterQuery(render_process_id_, reply_msg->routing_id());
} }
printer_query->GetSettings( printer_query->GetSettings(
PrinterQuery::ASK_USER, PrinterQuery::GetSettingsAskParam::ASK_USER, params.expected_pages_count,
params.expected_pages_count, params.has_selection, params.margin_type, true, true,
params.has_selection, base::Bind(&PrintingMessageFilter::OnScriptedPrintReply, this,
params.margin_type, printer_query, reply_msg));
base::Bind(&PrintingMessageFilter::OnScriptedPrintReply,
this,
printer_query,
reply_msg));
} }
void PrintingMessageFilter::OnScriptedPrintReply( void PrintingMessageFilter::OnScriptedPrintReply(
@ -407,11 +299,10 @@ void PrintingMessageFilter::OnUpdatePrintSettingsReply(
params.params.document_cookie = printer_query->cookie(); params.params.document_cookie = printer_query->cookie();
params.pages = PageRange::GetPages(printer_query->settings().ranges()); params.pages = PageRange::GetPages(printer_query->settings().ranges());
} }
PrintHostMsg_UpdatePrintSettings::WriteReplyParams( bool canceled = printer_query.get() &&
reply_msg, (printer_query->last_status() == PrintingContext::CANCEL);
params, PrintHostMsg_UpdatePrintSettings::WriteReplyParams(reply_msg, params,
printer_query.get() && canceled);
(printer_query->last_status() == printing::PrintingContext::CANCEL));
Send(reply_msg); Send(reply_msg);
// If user hasn't cancelled. // If user hasn't cancelled.
if (printer_query.get()) { if (printer_query.get()) {

57
chromium_src/chrome/browser/printing/printing_message_filter.h
View file

@ -10,13 +10,7 @@
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "content/public/browser/browser_message_filter.h" #include "content/public/browser/browser_message_filter.h"
#if defined(OS_WIN)
#include "base/memory/shared_memory.h"
#endif
struct PrintHostMsg_ScriptedPrint_Params; struct PrintHostMsg_ScriptedPrint_Params;
class Profile;
class ProfileIOData;
namespace base { namespace base {
class DictionaryValue; class DictionaryValue;
@ -29,7 +23,6 @@ class WebContents;
namespace printing { namespace printing {
class PrintJobManager;
class PrintQueriesQueue; class PrintQueriesQueue;
class PrinterQuery; class PrinterQuery;
@ -46,43 +39,26 @@ class PrintingMessageFilter : public content::BrowserMessageFilter {
bool OnMessageReceived(const IPC::Message& message) override; bool OnMessageReceived(const IPC::Message& message) override;
private: private:
friend class base::DeleteHelper<PrintingMessageFilter>;
friend class content::BrowserThread;
virtual ~PrintingMessageFilter(); virtual ~PrintingMessageFilter();
#if defined(OS_WIN) void OnDestruct() const override;
// Used to pass resulting EMF from renderer to browser in printing.
void OnDuplicateSection(base::SharedMemoryHandle renderer_handle,
base::SharedMemoryHandle* browser_handle);
#endif
#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
// Used to ask the browser allocate a temporary file for the renderer
// to fill in resulting PDF in renderer.
void OnAllocateTempFileForPrinting(int render_view_id,
base::FileDescriptor* temp_file_fd,
int* sequence_number);
void OnTempFileForPrintingWritten(int render_view_id, int sequence_number);
#endif
#if defined(OS_CHROMEOS)
void CreatePrintDialogForFile(int render_view_id, const base::FilePath& path);
#endif
#if defined(OS_ANDROID) #if defined(OS_ANDROID)
// Used to ask the browser allocate a temporary file for the renderer
// to fill in resulting PDF in renderer.
void OnAllocateTempFileForPrinting(int render_frame_id,
base::FileDescriptor* temp_file_fd,
int* sequence_number);
void OnTempFileForPrintingWritten(int render_frame_id, int sequence_number);
// Updates the file descriptor for the PrintViewManagerBasic of a given // Updates the file descriptor for the PrintViewManagerBasic of a given
// render_view_id. // render_frame_id.
void UpdateFileDescriptor(int render_view_id, int fd); void UpdateFileDescriptor(int render_frame_id, int fd);
#endif #endif
// Given a render_view_id get the corresponding WebContents.
// Must be called on the UI thread.
content::WebContents* GetWebContentsForRenderView(int render_view_id);
// GetPrintSettingsForRenderView must be called via PostTask and
// base::Bind. Collapse the settings-specific params into a
// struct to avoid running into issues with too many params
// to base::Bind.
struct GetPrintSettingsForRenderViewParams;
// Get the default print setting. // Get the default print setting.
void OnGetDefaultPrintSettings(IPC::Message* reply_msg); void OnGetDefaultPrintSettings(IPC::Message* reply_msg);
void OnGetDefaultPrintSettingsReply(scoped_refptr<PrinterQuery> printer_query, void OnGetDefaultPrintSettingsReply(scoped_refptr<PrinterQuery> printer_query,
@ -105,13 +81,6 @@ class PrintingMessageFilter : public content::BrowserMessageFilter {
void OnUpdatePrintSettingsReply(scoped_refptr<PrinterQuery> printer_query, void OnUpdatePrintSettingsReply(scoped_refptr<PrinterQuery> printer_query,
IPC::Message* reply_msg); IPC::Message* reply_msg);
#if defined(ENABLE_FULL_PRINTING)
// Check to see if print preview has been cancelled.
void OnCheckForCancel(int32_t preview_ui_id,
int preview_request_id,
bool* cancel);
#endif
const int render_process_id_; const int render_process_id_;
scoped_refptr<PrintQueriesQueue> queue_; scoped_refptr<PrintQueriesQueue> queue_;

23
chromium_src/chrome/common/print_messages.cc
View file

@ -14,17 +14,20 @@ PrintMsg_Print_Params::PrintMsg_Print_Params()
margin_top(0), margin_top(0),
margin_left(0), margin_left(0),
dpi(0), dpi(0),
min_shrink(0), scale_factor(1.0f),
max_shrink(0),
desired_dpi(0), desired_dpi(0),
document_cookie(0), document_cookie(0),
selection_only(false), selection_only(false),
supports_alpha_blend(false), supports_alpha_blend(false),
preview_ui_id(-1),
preview_request_id(0),
is_first_request(false),
print_scaling_option(blink::WebPrintScalingOptionSourceSize), print_scaling_option(blink::WebPrintScalingOptionSourceSize),
print_to_pdf(false),
display_header_footer(false),
title(), title(),
url(), url(),
should_print_backgrounds(false) { should_print_backgrounds(false) {}
}
PrintMsg_Print_Params::~PrintMsg_Print_Params() {} PrintMsg_Print_Params::~PrintMsg_Print_Params() {}
@ -35,15 +38,19 @@ void PrintMsg_Print_Params::Reset() {
margin_top = 0; margin_top = 0;
margin_left = 0; margin_left = 0;
dpi = 0; dpi = 0;
min_shrink = 0; scale_factor = 1.0f;
max_shrink = 0;
desired_dpi = 0; desired_dpi = 0;
document_cookie = 0; document_cookie = 0;
selection_only = false; selection_only = false;
supports_alpha_blend = false; supports_alpha_blend = false;
preview_ui_id = -1;
preview_request_id = 0;
is_first_request = false;
print_scaling_option = blink::WebPrintScalingOptionSourceSize; print_scaling_option = blink::WebPrintScalingOptionSourceSize;
title.clear(); print_to_pdf = false;
url.clear(); display_header_footer = false;
title = base::string16();
url = base::string16();
should_print_backgrounds = false; should_print_backgrounds = false;
} }

31
chromium_src/chrome/common/print_messages.h
View file

@ -40,15 +40,18 @@ struct PrintMsg_Print_Params {
int margin_top; int margin_top;
int margin_left; int margin_left;
double dpi; double dpi;
double min_shrink; double scale_factor;
double max_shrink;
int desired_dpi; int desired_dpi;
bool rasterize_pdf;
int document_cookie; int document_cookie;
bool selection_only; bool selection_only;
bool supports_alpha_blend; bool supports_alpha_blend;
int32_t preview_ui_id;
int preview_request_id; int preview_request_id;
bool is_first_request;
blink::WebPrintScalingOption print_scaling_option; blink::WebPrintScalingOption print_scaling_option;
bool print_to_pdf; bool print_to_pdf;
bool display_header_footer;
base::string16 title; base::string16 title;
base::string16 url; base::string16 url;
bool should_print_backgrounds; bool should_print_backgrounds;
@ -95,11 +98,8 @@ IPC_STRUCT_TRAITS_BEGIN(PrintMsg_Print_Params)
// Specifies dots per inch. // Specifies dots per inch.
IPC_STRUCT_TRAITS_MEMBER(dpi) IPC_STRUCT_TRAITS_MEMBER(dpi)
// Minimum shrink factor. See PrintSettings::min_shrink for more information. // Specifies the scale factor in percent
IPC_STRUCT_TRAITS_MEMBER(min_shrink) IPC_STRUCT_TRAITS_MEMBER(scale_factor)
// Maximum shrink factor. See PrintSettings::max_shrink for more information.
IPC_STRUCT_TRAITS_MEMBER(max_shrink)
// Desired apparent dpi on paper. // Desired apparent dpi on paper.
IPC_STRUCT_TRAITS_MEMBER(desired_dpi) IPC_STRUCT_TRAITS_MEMBER(desired_dpi)
@ -113,9 +113,26 @@ IPC_STRUCT_TRAITS_BEGIN(PrintMsg_Print_Params)
// Does the printer support alpha blending? // Does the printer support alpha blending?
IPC_STRUCT_TRAITS_MEMBER(supports_alpha_blend) IPC_STRUCT_TRAITS_MEMBER(supports_alpha_blend)
// *** Parameters below are used only for print preview. ***
// The print preview ui associated with this request.
IPC_STRUCT_TRAITS_MEMBER(preview_ui_id)
// The id of the preview request.
IPC_STRUCT_TRAITS_MEMBER(preview_request_id)
// True if this is the first preview request.
IPC_STRUCT_TRAITS_MEMBER(is_first_request)
// Specifies the page scaling option for preview printing. // Specifies the page scaling option for preview printing.
IPC_STRUCT_TRAITS_MEMBER(print_scaling_option) IPC_STRUCT_TRAITS_MEMBER(print_scaling_option)
// True if print to pdf is requested.
IPC_STRUCT_TRAITS_MEMBER(print_to_pdf)
// Specifies if the header and footer should be rendered.
IPC_STRUCT_TRAITS_MEMBER(display_header_footer)
// Title string to be printed as header if requested by the user. // Title string to be printed as header if requested by the user.
IPC_STRUCT_TRAITS_MEMBER(title) IPC_STRUCT_TRAITS_MEMBER(title)

14
chromium_src/chrome/renderer/printing/print_web_view_helper.cc
View file

@ -1087,16 +1087,16 @@ bool PrintWebViewHelper::UpdatePrintSettings(
SetPrintPagesParams(settings); SetPrintPagesParams(settings);
if (!PrintMsg_Print_Params_IsValid(settings.params)) { if (PrintMsg_Print_Params_IsValid(settings.params))
if (!print_for_preview_) return true;
if (print_for_preview_)
Send(new PrintHostMsg_ShowInvalidPrinterSettingsError(routing_id()));
else
print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS); print_preview_context_.set_error(PREVIEW_ERROR_INVALID_PRINTER_SETTINGS);
return false; return false;
}
return true;
} }
bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebLocalFrame* frame, bool PrintWebViewHelper::GetPrintSettingsFromUser(blink::WebLocalFrame* frame,
const blink::WebNode& node, const blink::WebNode& node,
int expected_pages_count) { int expected_pages_count) {
@ -1170,6 +1170,8 @@ bool PrintWebViewHelper::CopyMetafileDataToSharedMem(
void PrintWebViewHelper::SetPrintPagesParams( void PrintWebViewHelper::SetPrintPagesParams(
const PrintMsg_PrintPages_Params& settings) { const PrintMsg_PrintPages_Params& settings) {
print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings)); print_pages_params_.reset(new PrintMsg_PrintPages_Params(settings));
Send(new PrintHostMsg_DidGetDocumentCookie(routing_id(),
settings.params.document_cookie));
} }
bool PrintWebViewHelper::PreviewPageRendered(int page_number, bool PrintWebViewHelper::PreviewPageRendered(int page_number,