From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Shelley Vohr Date: Fri, 7 Jun 2019 13:59:37 -0700 Subject: printing.patch Add changeset that was previously applied to sources in chromium_src. The majority of changes originally come from these PRs: * https://github.com/electron/electron/pull/1835 * https://github.com/electron/electron/pull/8596 This patch also fixes callback for manual user cancellation and success. diff --git a/BUILD.gn b/BUILD.gn index c7a135b5bc489a5bb462d83904556ac2bcbfd6f5..e6bc49a042a13dc0f5dfdc954bce540a5da177f7 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -983,7 +983,6 @@ if (is_win) { "//media:media_unittests", "//media/midi:midi_unittests", "//net:net_unittests", - "//printing:printing_unittests", "//sql:sql_unittests", "//third_party/breakpad:symupload", "//ui/base:ui_base_unittests", @@ -992,6 +991,10 @@ if (is_win) { "//ui/views:views_unittests", "//url:url_unittests", ] + + if (enable_printing) { + deps += [ "//printing:printing_unittests" ] + } } } diff --git a/chrome/browser/printing/print_job.cc b/chrome/browser/printing/print_job.cc index 163eacc8bb6654880d37111923a87ea5a6134485..565258e9bd4cc52e347e1f4a72ee29ec4a847690 100644 --- a/chrome/browser/printing/print_job.cc +++ b/chrome/browser/printing/print_job.cc @@ -97,6 +97,7 @@ bool PrintWithReducedRasterization(PrefService* prefs) { return base::FeatureList::IsEnabled(features::kPrintWithReducedRasterization); } +#if 0 PrefService* GetPrefsForWebContents(content::WebContents* web_contents) { // TODO(thestig): Figure out why crbug.com/1083911 occurred, which is likely // because `web_contents` was null. As a result, this section has many more @@ -111,6 +112,7 @@ content::WebContents* GetWebContents(content::GlobalRenderFrameHostId rfh_id) { auto* rfh = content::RenderFrameHost::FromID(rfh_id); return rfh ? content::WebContents::FromRenderFrameHost(rfh) : nullptr; } +#endif #endif // BUILDFLAG(IS_WIN) @@ -151,10 +153,8 @@ void PrintJob::Initialize(std::unique_ptr query, #if BUILDFLAG(IS_WIN) pdf_page_mapping_ = PageNumber::GetPages(settings->ranges(), page_count); - PrefService* prefs = GetPrefsForWebContents(GetWebContents(rfh_id_)); - if (prefs && prefs->IsManagedPreference(prefs::kPdfUseSkiaRendererEnabled)) { - use_skia_ = prefs->GetBoolean(prefs::kPdfUseSkiaRendererEnabled); - } + // TODO(codebytere): should we enable this later? + use_skia_ = false; #endif auto new_doc = base::MakeRefCounted(std::move(settings), @@ -405,8 +405,10 @@ void PrintJob::StartPdfToEmfConversion( const PrintSettings& settings = document()->settings(); +#if 0 PrefService* prefs = GetPrefsForWebContents(GetWebContents(rfh_id_)); - bool print_with_reduced_rasterization = PrintWithReducedRasterization(prefs); +#endif + bool print_with_reduced_rasterization = PrintWithReducedRasterization(nullptr); using RenderMode = PdfRenderSettings::Mode; RenderMode mode = print_with_reduced_rasterization @@ -498,8 +500,10 @@ void PrintJob::StartPdfToPostScriptConversion( if (ps_level2) { mode = PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2; } else { +#if 0 PrefService* prefs = GetPrefsForWebContents(GetWebContents(rfh_id_)); - mode = PrintWithPostScriptType42Fonts(prefs) +#endif + mode = PrintWithPostScriptType42Fonts(nullptr) ? PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3_WITH_TYPE42_FONTS : PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3; } diff --git a/chrome/browser/printing/print_view_manager_base.cc b/chrome/browser/printing/print_view_manager_base.cc index c68d3d2f7fdaab62aac24b79e0cf71e0eb84cf72..3084546bee021eb2752335b8d31d48d28a6e5af1 100644 --- a/chrome/browser/printing/print_view_manager_base.cc +++ b/chrome/browser/printing/print_view_manager_base.cc @@ -87,6 +87,20 @@ namespace printing { namespace { +std::string PrintReasonFromPrintStatus(PrintViewManager::PrintStatus status) { + if (status == PrintViewManager::PrintStatus::kInvalid) { + return "Invalid printer settings"; + } else if (status == PrintViewManager::PrintStatus::kCanceled) { + return "Print job canceled"; + } else if (status == PrintViewManager::PrintStatus::kFailed) { + return "Print job failed"; + } + return ""; +} + +using PrintSettingsCallback = + base::OnceCallback)>; + void OnDidGetDefaultPrintSettings( scoped_refptr queue, bool want_pdf_settings, @@ -95,9 +109,9 @@ void OnDidGetDefaultPrintSettings( DCHECK_CURRENTLY_ON(content::BrowserThread::UI); if (printer_query->last_status() != mojom::ResultCode::kSuccess) { - if (!want_pdf_settings) { +#if 0 // Electron does not use Chromium error dialogs ShowPrintErrorDialogForInvalidPrinterError(); - } +#endif std::move(callback).Run(nullptr); return; } @@ -107,9 +121,9 @@ void OnDidGetDefaultPrintSettings( params->document_cookie = printer_query->cookie(); if (!PrintMsgPrintParamsIsValid(*params)) { - if (!want_pdf_settings) { +#if 0 // Electron does not use Chromium error dialogs ShowPrintErrorDialogForInvalidPrinterError(); - } +#endif std::move(callback).Run(nullptr); return; } @@ -121,11 +135,15 @@ void OnDidGetDefaultPrintSettings( void OnDidScriptedPrint( scoped_refptr queue, std::unique_ptr printer_query, - mojom::PrintManagerHost::ScriptedPrintCallback callback) { + mojom::PrintManagerHost::ScriptedPrintCallback callback, + base::OnceCallback cancel_job) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); if (printer_query->last_status() != mojom::ResultCode::kSuccess || !printer_query->settings().dpi()) { + if (printer_query->last_status() == mojom::ResultCode::kCanceled) { + std::move(cancel_job).Run(); + } std::move(callback).Run(nullptr); return; } @@ -182,9 +200,11 @@ PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents) : PrintManager(web_contents), queue_(g_browser_process->print_job_manager()->queue()) { DCHECK(queue_); +#if 0 Profile* profile = Profile::FromBrowserContext(web_contents->GetBrowserContext()); printing_enabled_.Init(prefs::kPrintingEnabled, profile->GetPrefs()); +#endif } PrintViewManagerBase::~PrintViewManagerBase() { @@ -208,12 +228,16 @@ void PrintViewManagerBase::DisableThirdPartyBlocking() { } #endif // BUILDFLAG(IS_WIN) && BUILDFLAG(GOOGLE_CHROME_BRANDING) -bool PrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh) { +bool PrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh, + base::Value::Dict settings, + CompletionCallback callback) { if (!StartPrintCommon(rfh)) { return false; } - GetPrintRenderFrame(rfh)->PrintRequestedPages(); + callback_ = std::move(callback); + + GetPrintRenderFrame(rfh)->PrintRequestedPages(std::move(settings)); for (auto& observer : GetTestObservers()) { observer.OnPrintNow(rfh); @@ -295,7 +319,7 @@ void PrintViewManagerBase::PrintDocument( const gfx::Size& page_size, const gfx::Rect& content_area, const gfx::Point& offsets) { -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 if (content_analysis_before_printing_document_) { std::move(content_analysis_before_printing_document_) .Run(print_data, page_size, content_area, offsets); @@ -342,12 +366,13 @@ void PrintViewManagerBase::OnDidUpdatePrintableArea( } PRINTER_LOG(EVENT) << "Paper printable area updated for vendor id " << print_settings->requested_media().vendor_id; - CompleteUpdatePrintSettings(std::move(job_settings), + CompleteUpdatePrintSettings(nullptr /* printer_query */, std::move(job_settings), std::move(print_settings), std::move(callback)); } #endif void PrintViewManagerBase::CompleteUpdatePrintSettings( + std::unique_ptr printer_query, base::Value::Dict job_settings, std::unique_ptr print_settings, UpdatePrintSettingsCallback callback) { @@ -355,7 +380,8 @@ void PrintViewManagerBase::CompleteUpdatePrintSettings( settings->pages = GetPageRangesFromJobSettings(job_settings); settings->params = mojom::PrintParams::New(); RenderParamsFromPrintSettings(*print_settings, settings->params.get()); - settings->params->document_cookie = PrintSettings::NewCookie(); + settings->params->document_cookie = printer_query ? printer_query->cookie() + : PrintSettings::NewCookie(); if (!PrintMsgPrintParamsIsValid(*settings->params)) { mojom::PrinterType printer_type = static_cast( *job_settings.FindInt(kSettingPrinterType)); @@ -367,6 +393,10 @@ void PrintViewManagerBase::CompleteUpdatePrintSettings( return; } + if (printer_query && printer_query->cookie() && printer_query->settings().dpi()) { + queue_->QueuePrinterQuery(std::move(printer_query)); + } + set_cookie(settings->params->document_cookie); std::move(callback).Run(std::move(settings)); } @@ -436,7 +466,7 @@ void PrintViewManagerBase::StartLocalPrintJob( PrinterHandler::PrintCallback callback) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 // Populating `content_analysis_before_printing_document_` if needed should be // done first in this function's workflow, this way other code can check if // content analysis is going to happen and delay starting `print_job_` to @@ -669,7 +699,7 @@ void PrintViewManagerBase::GetDefaultPrintSettings( #if BUILDFLAG(ENABLE_OOP_PRINTING) if (ShouldPrintJobOop() && -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 !analyzing_content_ && #endif !query_with_ui_client_id().has_value()) { @@ -697,7 +727,7 @@ void PrintViewManagerBase::GetDefaultPrintSettings( // Sometimes it is desired to get the PDF settings as opposed to the settings // of the default system print driver. -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 bool want_pdf_settings = analyzing_content_; #else bool want_pdf_settings = false; @@ -741,10 +771,7 @@ void PrintViewManagerBase::UpdatePrintSettings( // `job_settings` does not yet contain the rasterized PDF dpi, so if the user // has the print preference set, fetch it for use in // `PrintSettingsFromJobSettings()`. - content::BrowserContext* context = - web_contents() ? web_contents()->GetBrowserContext() : nullptr; - PrefService* prefs = - context ? Profile::FromBrowserContext(context)->GetPrefs() : nullptr; + PrefService* prefs = nullptr; if (prefs && prefs->HasPrefPath(prefs::kPrintRasterizePdfDpi)) { int value = prefs->GetInteger(prefs::kPrintRasterizePdfDpi); if (value > 0) @@ -769,8 +796,22 @@ void PrintViewManagerBase::UpdatePrintSettings( } } -#if BUILDFLAG(IS_WIN) - // TODO(crbug.com/40260379): Remove this if the printable areas can be made + std::unique_ptr query = + queue_->CreatePrinterQuery(GetCurrentTargetFrame()->GetGlobalId()); + auto* query_ptr = query.get(); + // We need to clone this before calling SetSettings because some environments + // evaluate job_settings.Clone() first, and some std::move(job_settings) first, + // for the former things work correctly but for the latter the cloned value is null. + auto job_settings_copy = job_settings.Clone(); + query_ptr->SetSettings( + std::move(job_settings_copy), + base::BindOnce(&PrintViewManagerBase::CompleteUpdatePrintSettings, + weak_ptr_factory_.GetWeakPtr(), std::move(query), + std::move(job_settings), std::move(print_settings), + std::move(callback))); + +#if 0 // See https://chromium-review.googlesource.com/412367 + // TODO(crbug.com/1424368): Remove this if the printable areas can be made // fully available from `PrintBackend::GetPrinterSemanticCapsAndDefaults()` // for in-browser queries. if (printer_type == mojom::PrinterType::kLocal) { @@ -791,8 +832,6 @@ void PrintViewManagerBase::UpdatePrintSettings( } #endif - CompleteUpdatePrintSettings(std::move(job_settings), - std::move(print_settings), std::move(callback)); } void PrintViewManagerBase::SetAccessibilityTree( @@ -808,7 +847,7 @@ void PrintViewManagerBase::SetAccessibilityTree( void PrintViewManagerBase::IsPrintingEnabled( IsPrintingEnabledCallback callback) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); - std::move(callback).Run(GetPrintingEnabledBooleanPref()); + std::move(callback).Run(true); } void PrintViewManagerBase::ScriptedPrint(mojom::ScriptedPrintParamsPtr params, @@ -834,7 +873,7 @@ void PrintViewManagerBase::ScriptedPrint(mojom::ScriptedPrintParamsPtr params, return; } #endif -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 std::optional scanning_data = enterprise_data_protection::GetPrintAnalysisData( web_contents(), enterprise_data_protection::PrintScanningContext:: @@ -864,11 +903,9 @@ void PrintViewManagerBase::PrintingFailed(int32_t cookie, // destroyed. In such cases the error notification to the user will // have already been displayed, and a second message should not be // shown. - if (print_job_ && print_job_->document() && - print_job_->document()->cookie() == cookie) { +#if 0 // Electron does not use Chromium error dialogs ShowPrintErrorDialogForGenericError(); - } - +#endif ReleasePrinterQuery(); } @@ -880,15 +917,24 @@ void PrintViewManagerBase::RemoveTestObserver(TestObserver& observer) { test_observers_.RemoveObserver(&observer); } +void PrintViewManagerBase::ShowInvalidPrinterSettingsError() { + if (!callback_.is_null()) { + printing_status_ = PrintStatus::kInvalid; + TerminatePrintJob(true); + } +} + void PrintViewManagerBase::RenderFrameHostStateChanged( content::RenderFrameHost* render_frame_host, content::RenderFrameHost::LifecycleState /*old_state*/, content::RenderFrameHost::LifecycleState new_state) { +#if 0 if (new_state == content::RenderFrameHost::LifecycleState::kActive && render_frame_host->GetProcess()->IsPdf() && !render_frame_host->GetMainFrame()->GetParentOrOuterDocument()) { GetPrintRenderFrame(render_frame_host)->ConnectToPdfRenderer(); } +#endif } void PrintViewManagerBase::RenderFrameDeleted( @@ -936,7 +982,7 @@ void PrintViewManagerBase::SystemDialogCancelled() { #endif bool PrintViewManagerBase::GetPrintingEnabledBooleanPref() const { - return printing_enabled_.GetValue(); + return true; } void PrintViewManagerBase::OnDocDone(int job_id, PrintedDocument* document) { @@ -953,7 +999,12 @@ void PrintViewManagerBase::OnJobDone() { // Printing is done, we don't need it anymore. // print_job_->is_job_pending() may still be true, depending on the order // of object registration. - printing_succeeded_ = true; + printing_status_ = PrintStatus::kSucceeded; + ReleasePrintJob(); +} + +void PrintViewManagerBase::UserInitCanceled() { + printing_status_ = PrintStatus::kCanceled; ReleasePrintJob(); } @@ -962,9 +1013,9 @@ void PrintViewManagerBase::OnCanceling() { } void PrintViewManagerBase::OnFailed() { - if (!canceling_job_) +#if 0 // Electron does not use Chromium error dialogs ShowPrintErrorDialogForGenericError(); - +#endif TerminatePrintJob(true); } @@ -974,7 +1025,7 @@ bool PrintViewManagerBase::RenderAllMissingPagesNow() { // Is the document already complete? if (print_job_->document() && print_job_->document()->IsComplete()) { - printing_succeeded_ = true; + printing_status_ = PrintStatus::kSucceeded; return true; } @@ -1027,7 +1078,10 @@ bool PrintViewManagerBase::SetupNewPrintJob( // Disconnect the current `print_job_`. auto weak_this = weak_ptr_factory_.GetWeakPtr(); - DisconnectFromCurrentPrintJob(); + if (callback_.is_null()) { + // Disconnect the current |print_job_| only when calling window.print() + DisconnectFromCurrentPrintJob(); + } if (!weak_this) return false; @@ -1047,7 +1101,7 @@ bool PrintViewManagerBase::SetupNewPrintJob( #endif print_job_->AddObserver(*this); - printing_succeeded_ = false; + printing_status_ = PrintStatus::kFailed; return true; } @@ -1105,7 +1159,7 @@ void PrintViewManagerBase::ReleasePrintJob() { // Ensure that any residual registration of printing client is released. // This might be necessary in some abnormal cases, such as the associated // render process having terminated. -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 if (!analyzing_content_) { UnregisterSystemPrintClient(); } @@ -1115,6 +1169,11 @@ void PrintViewManagerBase::ReleasePrintJob() { } #endif + if (!callback_.is_null()) { + bool success = printing_status_ == PrintStatus::kSucceeded; + std::move(callback_).Run(success, PrintReasonFromPrintStatus(printing_status_)); + } + if (!print_job_) return; @@ -1122,7 +1181,7 @@ void PrintViewManagerBase::ReleasePrintJob() { // printing_rfh_ should only ever point to a RenderFrameHost with a live // RenderFrame. DCHECK(rfh->IsRenderFrameLive()); - GetPrintRenderFrame(rfh)->PrintingDone(printing_succeeded_); + GetPrintRenderFrame(rfh)->PrintingDone(printing_status_ == PrintStatus::kSucceeded); } print_job_->RemoveObserver(*this); @@ -1164,7 +1223,7 @@ bool PrintViewManagerBase::RunInnerMessageLoop() { } bool PrintViewManagerBase::OpportunisticallyCreatePrintJob(int cookie) { - if (print_job_) + if (print_job_ && print_job_->document()) return true; if (!cookie) { @@ -1187,7 +1246,7 @@ bool PrintViewManagerBase::OpportunisticallyCreatePrintJob(int cookie) { return false; } -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 // Don't start printing if enterprise checks are being performed to check if // printing is allowed, or if content analysis is going to take place right // before starting `print_job_`. @@ -1318,6 +1377,8 @@ void PrintViewManagerBase::CompleteScriptedPrint( auto callback_wrapper = base::BindOnce( &PrintViewManagerBase::ScriptedPrintReply, weak_ptr_factory_.GetWeakPtr(), std::move(callback), render_process_host->GetID()); + auto cancel_job_wrapper = base::BindOnce( + &PrintViewManagerBase::UserInitCanceled, weak_ptr_factory_.GetWeakPtr()); #if BUILDFLAG(IS_WIN) && BUILDFLAG(GOOGLE_CHROME_BRANDING) DisableThirdPartyBlocking(); #endif @@ -1332,10 +1393,10 @@ void PrintViewManagerBase::CompleteScriptedPrint( params->expected_pages_count, params->has_selection, params->margin_type, params->is_scripted, !render_process_host->IsPdf(), base::BindOnce(&OnDidScriptedPrint, queue_, std::move(printer_query), - std::move(callback_wrapper))); + std::move(callback_wrapper), std::move(cancel_job_wrapper))); } -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 void PrintViewManagerBase::CompletePrintDocumentAfterContentAnalysis( scoped_refptr print_data, const gfx::Size& page_size, diff --git a/chrome/browser/printing/print_view_manager_base.h b/chrome/browser/printing/print_view_manager_base.h index 1917f8b94962d7a4c83f139623a5f5d352011627..47ef610c43c4dcfee0cf528eb2e6075b579117ee 100644 --- a/chrome/browser/printing/print_view_manager_base.h +++ b/chrome/browser/printing/print_view_manager_base.h @@ -52,6 +52,8 @@ class PrinterQuery; // rollout. BASE_DECLARE_FEATURE(kCheckPrintRfhIsActive); +using CompletionCallback = base::OnceCallback; + // Base class for managing the print commands for a WebContents. class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { public: @@ -87,7 +89,9 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { // Prints the current document immediately. Since the rendering is // asynchronous, the actual printing will not be completed on the return of // this function. Returns false if printing is impossible at the moment. - virtual bool PrintNow(content::RenderFrameHost* rfh); + virtual bool PrintNow(content::RenderFrameHost* rfh, + base::Value::Dict settings = {}, + CompletionCallback callback = {}); // Like PrintNow(), but for the node under the context menu, instead of the // entire frame. @@ -141,8 +145,10 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { void IsPrintingEnabled(IsPrintingEnabledCallback callback) override; void ScriptedPrint(mojom::ScriptedPrintParamsPtr params, ScriptedPrintCallback callback) override; + void ShowInvalidPrinterSettingsError() override; void PrintingFailed(int32_t cookie, mojom::PrintFailureReason reason) override; + void UserInitCanceled(); // Adds and removes observers for `PrintViewManagerBase` events. The order in // which notifications are sent to observers is undefined. Observers must be @@ -150,6 +156,14 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { void AddTestObserver(TestObserver& observer); void RemoveTestObserver(TestObserver& observer); + enum class PrintStatus { + kSucceeded, + kCanceled, + kFailed, + kInvalid, + kUnknown + }; + protected: #if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) using PrintDocumentCallback = @@ -229,7 +243,7 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { mojom::ScriptedPrintParamsPtr params, ScriptedPrintCallback callback); -#if BUILDFLAG(ENTERPRISE_CONTENT_ANALYSIS) +#if 0 // Helper method bound to `content_analysis_before_printing_document_` when // content analysis should happen right before the document is to be printed. // This method is virtual for testing purposes. @@ -293,6 +307,7 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { bool success); #endif void CompleteUpdatePrintSettings( + std::unique_ptr printer_query, base::Value::Dict job_settings, std::unique_ptr print_settings, UpdatePrintSettingsCallback callback); @@ -387,8 +402,11 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer { // The current RFH that is printing with a system printing dialog. raw_ptr printing_rfh_ = nullptr; + // Respond with success of the print job. + CompletionCallback callback_; + // Indication of success of the print job. - bool printing_succeeded_ = false; + PrintStatus printing_status_ = PrintStatus::kUnknown; // Indication that the job is getting canceled. bool canceling_job_ = false; diff --git a/chrome/browser/printing/printer_query.cc b/chrome/browser/printing/printer_query.cc index 0e48a7582d86c85a826de08af655b29a3ef74fd2..2e67a73611ca2c55ffc002341b0878de7191c932 100644 --- a/chrome/browser/printing/printer_query.cc +++ b/chrome/browser/printing/printer_query.cc @@ -355,17 +355,19 @@ void PrinterQuery::UpdatePrintSettings(base::Value::Dict new_settings, #endif // BUILDFLAG(IS_LINUX) && BUILDFLAG(USE_CUPS) } - mojom::ResultCode result; { #if BUILDFLAG(IS_WIN) // Blocking is needed here because Windows printer drivers are oftentimes // not thread-safe and have to be accessed on the UI thread. base::ScopedAllowBlocking allow_blocking; #endif - result = printing_context_->UpdatePrintSettings(std::move(new_settings)); + // Reset settings from previous print job + printing_context_->ResetSettings(); + mojom::ResultCode result_code = printing_context_->UseDefaultSettings(); + if (result_code == mojom::ResultCode::kSuccess) + result_code = printing_context_->UpdatePrintSettings(std::move(new_settings)); + InvokeSettingsCallback(std::move(callback), result_code); } - - InvokeSettingsCallback(std::move(callback), result); } #if BUILDFLAG(IS_CHROMEOS) diff --git a/components/printing/browser/print_manager.cc b/components/printing/browser/print_manager.cc index 21c81377d32ae8d4185598a7eba88ed1d2063ef0..0767f4e9369e926b1cea99178c1a1975941f1765 100644 --- a/components/printing/browser/print_manager.cc +++ b/components/printing/browser/print_manager.cc @@ -47,6 +47,8 @@ void PrintManager::IsPrintingEnabled(IsPrintingEnabledCallback callback) { std::move(callback).Run(true); } +void PrintManager::ShowInvalidPrinterSettingsError() {} + void PrintManager::PrintingFailed(int32_t cookie, mojom::PrintFailureReason reason) { // Note: Not redundant with cookie checks in the same method in other parts of diff --git a/components/printing/browser/print_manager.h b/components/printing/browser/print_manager.h index ca71560874a0189068dd11fbc039f5673bf6bd96..a8551d95e64da2afbc1685b2df8f1fc377c7117b 100644 --- a/components/printing/browser/print_manager.h +++ b/components/printing/browser/print_manager.h @@ -48,6 +48,7 @@ class PrintManager : public content::WebContentsObserver, DidPrintDocumentCallback callback) override; void IsPrintingEnabled(IsPrintingEnabledCallback callback) override; void DidShowPrintDialog() override; + void ShowInvalidPrinterSettingsError() override; void PrintingFailed(int32_t cookie, mojom::PrintFailureReason reason) override; diff --git a/components/printing/common/print.mojom b/components/printing/common/print.mojom index 3c2fdc9f9a6c60efc4b0afacbfb83eef55917791..8fd9aff538fa03da6c171927c316d4f611c46da1 100644 --- a/components/printing/common/print.mojom +++ b/components/printing/common/print.mojom @@ -303,7 +303,7 @@ union PrintWithParamsResult { interface PrintRenderFrame { // Tells the RenderFrame to switch the CSS to print media type, render every // requested page, and then switch back the CSS to display media type. - PrintRequestedPages(); + PrintRequestedPages(mojo_base.mojom.DictionaryValue settings); // Requests the frame to be printed with specified parameters. This is used // to programmatically produce PDF by request from the browser (e.g. over @@ -392,6 +392,9 @@ interface PrintManagerHost { [Sync] ScriptedPrint(ScriptedPrintParams params) => (PrintPagesParams? settings); + // Tells the browser that there are invalid printer settings. + ShowInvalidPrinterSettingsError(); + // Tells the browser printing failed. PrintingFailed(int32 cookie, PrintFailureReason reason); diff --git a/components/printing/renderer/print_render_frame_helper.cc b/components/printing/renderer/print_render_frame_helper.cc index 1c12ab70d993b742ee73b1235ecfdd3239125e97..b24751087f4015fc6b93518af95b0911529d3c6e 100644 --- a/components/printing/renderer/print_render_frame_helper.cc +++ b/components/printing/renderer/print_render_frame_helper.cc @@ -51,6 +51,7 @@ #include "printing/mojom/print.mojom.h" #include "printing/page_number.h" #include "printing/print_job_constants.h" +#include "printing/print_settings.h" #include "printing/units.h" #include "services/metrics/public/cpp/ukm_source_id.h" #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h" @@ -1224,14 +1225,14 @@ void PrintRenderFrameHelper::ScriptedPrint(bool user_initiated) { } print_in_progress_ = true; - auto weak_this = weak_ptr_factory_.GetWeakPtr(); web_frame->DispatchBeforePrintEvent(/*print_client=*/nullptr); if (!weak_this) { return; } - Print(web_frame, blink::WebNode(), PrintRequestType::kScripted); + Print(web_frame, blink::WebNode(), PrintRequestType::kScripted, + base::Value::Dict()); if (!weak_this) { return; } @@ -1262,12 +1263,14 @@ void PrintRenderFrameHelper::BindPrintRenderFrameReceiver( receivers_.Add(this, std::move(receiver)); } -void PrintRenderFrameHelper::PrintRequestedPages() { - PrintRequestedPagesInternal(/*already_notified_frame=*/false); +void PrintRenderFrameHelper::PrintRequestedPages(base::Value::Dict settings) { + PrintRequestedPagesInternal(/*already_notified_frame=*/false, + std::move(settings)); } void PrintRenderFrameHelper::PrintRequestedPagesInternal( - bool already_notified_frame) { + bool already_notified_frame, + base::Value::Dict settings) { ScopedIPC scoped_ipc(weak_ptr_factory_.GetWeakPtr()); if (ipc_nesting_level_ > kAllowedIpcDepthForPrint) { return; @@ -1284,9 +1287,10 @@ void PrintRenderFrameHelper::PrintRequestedPagesInternal( is_loading_ = frame->WillPrintSoon(); if (is_loading_) { - on_stop_loading_closure_ = base::BindOnce( - &PrintRenderFrameHelper::PrintRequestedPagesInternal, - weak_ptr_factory_.GetWeakPtr(), /*already_notified_frame=*/true); + on_stop_loading_closure_ = + base::BindOnce(&PrintRenderFrameHelper::PrintRequestedPagesInternal, + weak_ptr_factory_.GetWeakPtr(), + /*already_notified_frame=*/true, std::move(settings)); SetupOnStopLoadingTimeout(); return; } @@ -1296,7 +1300,7 @@ void PrintRenderFrameHelper::PrintRequestedPagesInternal( // plugin node and print that instead. auto plugin = delegate_->GetPdfElement(frame); - Print(frame, plugin, PrintRequestType::kRegular); + Print(frame, plugin, PrintRequestType::kRegular, std::move(settings)); if (render_frame_gone_) { return; @@ -1453,6 +1457,8 @@ void PrintRenderFrameHelper::PrintPreview(base::Value::Dict settings) { if (ipc_nesting_level_ > kAllowedIpcDepthForPrint) return; + blink::WebLocalFrame* frame = render_frame()->GetWebFrame(); + print_preview_context_.InitWithFrame(frame); print_preview_context_.OnPrintPreview(); #if BUILDFLAG(IS_CHROMEOS_ASH) @@ -2045,17 +2051,19 @@ void PrintRenderFrameHelper::PrintNode(const blink::WebNode& node) { void PrintRenderFrameHelper::Print(blink::WebLocalFrame* frame, const blink::WebNode& node, - PrintRequestType print_request_type) { + PrintRequestType print_request_type, + base::Value::Dict settings) { // If still not finished with earlier print request simply ignore. if (prep_frame_view_) return; + bool silent = settings.FindBool("silent").value_or(false); FrameReference frame_ref(frame); - if (!InitPrintSettings(frame, node)) { + if (!InitPrintSettings(frame, node, std::move(settings))) { // Browser triggered this code path. It already knows about the failure. notify_browser_of_print_failure_ = false; - + GetPrintManagerHost()->ShowInvalidPrinterSettingsError(); DidFinishPrinting(PrintingResult::kFailPrintInit); return; } @@ -2076,8 +2084,15 @@ void PrintRenderFrameHelper::Print(blink::WebLocalFrame* frame, print_pages_params_->params->print_scaling_option; auto self = weak_ptr_factory_.GetWeakPtr(); - mojom::PrintPagesParamsPtr print_settings = GetPrintSettingsFromUser( + mojom::PrintPagesParamsPtr print_settings; + + if (silent) { + print_settings = mojom::PrintPagesParams::New(); + print_settings->params = print_pages_params_->params->Clone(); + } else { + print_settings = GetPrintSettingsFromUser( frame_ref.GetFrame(), node, expected_page_count, print_request_type); + } // Check if `this` is still valid. if (!self) return; @@ -2338,29 +2353,37 @@ void PrintRenderFrameHelper::IPCProcessed() { } bool PrintRenderFrameHelper::InitPrintSettings(blink::WebLocalFrame* frame, - const blink::WebNode& node) { + const blink::WebNode& node, + base::Value::Dict new_settings) { // Reset to default values. ignore_css_margins_ = false; - mojom::PrintPagesParams settings; - GetPrintManagerHost()->GetDefaultPrintSettings(&settings.params); + mojom::PrintPagesParamsPtr settings; + if (new_settings.empty()) { + settings = mojom::PrintPagesParams::New(); + settings->params = mojom::PrintParams::New(); + GetPrintManagerHost()->GetDefaultPrintSettings(&settings->params); + } else { + GetPrintManagerHost()->UpdatePrintSettings( + std::move(new_settings), &settings); + } // Check if the printer returned any settings, if the settings are null, // assume there are no printer drivers configured. So safely terminate. - if (!settings.params) { + if (!settings || !settings->params) { // Caller will reset `print_pages_params_`. return false; } bool center_on_paper = !IsPrintingPdfFrame(frame, node); - settings.params->print_scaling_option = + settings->params->print_scaling_option = center_on_paper ? mojom::PrintScalingOption::kCenterShrinkToFitPaper : mojom::PrintScalingOption::kSourceSize; - RecordDebugEvent(settings.params->printed_doc_type == + RecordDebugEvent(settings->params->printed_doc_type == mojom::SkiaDocumentType::kMSKP ? DebugEvent::kSetPrintSettings5 : DebugEvent::kSetPrintSettings6); - SetPrintPagesParams(settings); + SetPrintPagesParams(*settings); return true; } diff --git a/components/printing/renderer/print_render_frame_helper.h b/components/printing/renderer/print_render_frame_helper.h index 14de029740ffbebe06d309651c1a2c007d9fb96b..e9bf9c5bef2a9235260e7d6c8d26d41528e38661 100644 --- a/components/printing/renderer/print_render_frame_helper.h +++ b/components/printing/renderer/print_render_frame_helper.h @@ -251,7 +251,7 @@ class PrintRenderFrameHelper mojo::PendingAssociatedReceiver receiver); // printing::mojom::PrintRenderFrame: - void PrintRequestedPages() override; + void PrintRequestedPages(base::Value::Dict settings) override; void PrintWithParams(mojom::PrintPagesParamsPtr params, PrintWithParamsCallback callback) override; #if BUILDFLAG(ENABLE_PRINT_PREVIEW) @@ -318,7 +318,8 @@ class PrintRenderFrameHelper // WARNING: |this| may be gone after this method returns. void Print(blink::WebLocalFrame* frame, const blink::WebNode& node, - PrintRequestType print_request_type); + PrintRequestType print_request_type, + base::Value::Dict settings = {}); // Notification when printing is done - signal tear-down/free resources. void DidFinishPrinting(PrintingResult result); @@ -328,7 +329,8 @@ class PrintRenderFrameHelper // Initialize print page settings with default settings. // Used only for native printing workflow. bool InitPrintSettings(blink::WebLocalFrame* frame, - const blink::WebNode& node); + const blink::WebNode& node, + base::Value::Dict new_settings); // Calculate number of pages in source document. uint32_t CalculateNumberOfPages(blink::WebLocalFrame* frame, @@ -625,7 +627,8 @@ class PrintRenderFrameHelper }; void SetupOnStopLoadingTimeout(); - void PrintRequestedPagesInternal(bool already_notified_frame); + void PrintRequestedPagesInternal(bool already_notified_frame, + base::Value::Dict settings); ScriptingThrottler scripting_throttler_; diff --git a/content/browser/BUILD.gn b/content/browser/BUILD.gn index 06752e1f3dd92761379f582e9c0a85ab6e85e7d0..d0bc1495d7cc915bfc102d6d7bb592136f5bb394 100644 --- a/content/browser/BUILD.gn +++ b/content/browser/BUILD.gn @@ -2973,8 +2973,9 @@ source_set("browser") { "//ppapi/shared_impl", ] - assert(enable_printing) - deps += [ "//printing" ] + if (enable_printing) { + deps += [ "//printing" ] + } if (is_chromeos) { sources += [ diff --git a/printing/printing_context.cc b/printing/printing_context.cc index e9d9b148387313d8f6dd399d69a69272a511e6b4..a97983e9736daffdfeb713ae7b263f146f79ad0b 100644 --- a/printing/printing_context.cc +++ b/printing/printing_context.cc @@ -154,7 +154,6 @@ void PrintingContext::UsePdfSettings() { mojom::ResultCode PrintingContext::UpdatePrintSettings( base::Value::Dict job_settings) { - ResetSettings(); { std::unique_ptr settings = PrintSettingsFromJobSettings(job_settings); diff --git a/printing/printing_context.h b/printing/printing_context.h index 63f170c95050416c595e62f4c460c4cd6b7dbd1c..157e3d046889f9c63fdf0fd5d503890fb82c038d 100644 --- a/printing/printing_context.h +++ b/printing/printing_context.h @@ -206,6 +206,9 @@ class COMPONENT_EXPORT(PRINTING) PrintingContext { bool PrintingAborted() const { return abort_printing_; } + // Reinitializes the settings for object reuse. + void ResetSettings(); + int job_id() const { return job_id_; } #if BUILDFLAG(ENABLE_OOP_PRINTING) @@ -224,9 +227,6 @@ class COMPONENT_EXPORT(PRINTING) PrintingContext { Delegate* delegate, ProcessBehavior process_behavior); - // Reinitializes the settings for object reuse. - void ResetSettings(); - // Does bookkeeping when an error occurs. virtual mojom::ResultCode OnError(); diff --git a/sandbox/policy/mac/sandbox_mac.mm b/sandbox/policy/mac/sandbox_mac.mm index e89fd87753bad3c5663fa53f8dcc4542e7e307e5..2b433a0705234af6f9808ee741a9795d5e251785 100644 --- a/sandbox/policy/mac/sandbox_mac.mm +++ b/sandbox/policy/mac/sandbox_mac.mm @@ -38,6 +38,10 @@ #include "sandbox/policy/mac/utility.sb.h" #include "sandbox/policy/mojom/sandbox.mojom.h" +#if BUILDFLAG(ENABLE_PRINTING) +#include "sandbox/policy/mac/print_backend.sb.h" +#endif + namespace sandbox::policy { base::FilePath GetCanonicalPath(const base::FilePath& path) {