1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "libcef/browser/printing/print_view_manager.h"
6
7 #include "include/internal/cef_types_wrappers.h"
8 #include "libcef/browser/browser_info.h"
9 #include "libcef/browser/browser_info_manager.h"
10 #include "libcef/browser/download_manager_delegate.h"
11 #include "libcef/browser/extensions/extension_web_contents_observer.h"
12 #include "libcef/browser/thread_util.h"
13
14 #include <map>
15 #include <utility>
16
17 #include "base/bind.h"
18 #include "base/lazy_instance.h"
19 #include "base/memory/ptr_util.h"
20 #include "base/memory/ref_counted_memory.h"
21 #include "base/task/post_task.h"
22 #include "chrome/browser/browser_process.h"
23 #include "chrome/browser/printing/print_job_manager.h"
24 #include "chrome/browser/printing/print_preview_dialog_controller.h"
25 #include "chrome/browser/printing/printer_query.h"
26 #include "chrome/browser/profiles/profile.h"
27 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
28 #include "components/printing/common/print.mojom.h"
29 #include "content/browser/download/download_manager_impl.h"
30 #include "content/public/browser/browser_context.h"
31 #include "content/public/browser/browser_task_traits.h"
32 #include "content/public/browser/browser_thread.h"
33 #include "content/public/browser/download_manager.h"
34 #include "content/public/browser/render_frame_host.h"
35 #include "content/public/browser/render_process_host.h"
36 #include "content/public/browser/render_view_host.h"
37 #include "content/public/browser/web_contents.h"
38 #include "content/public/browser/web_contents_observer.h"
39 #include "mojo/public/cpp/bindings/associated_remote.h"
40 #include "printing/metafile_skia.h"
41 #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
42
43 #if defined(OS_LINUX)
44 #include "libcef/browser/printing/print_dialog_linux.h"
45 #endif
46
47 using content::BrowserThread;
48
49 namespace printing {
50
51 namespace {
52
53 const int PREVIEW_UIID = 12345678;
54
55 // Convert CefPdfPrintSettings into base::DictionaryValue.
FillInDictionaryFromPdfPrintSettings(const CefPdfPrintSettings & pdf_settings,int request_id,base::DictionaryValue & print_settings)56 void FillInDictionaryFromPdfPrintSettings(
57 const CefPdfPrintSettings& pdf_settings,
58 int request_id,
59 base::DictionaryValue& print_settings) {
60 // Fixed settings.
61 print_settings.SetIntKey(kSettingPrinterType,
62 static_cast<int>(PrinterType::kPdf));
63 print_settings.SetInteger(kSettingColor,
64 static_cast<int>(mojom::ColorModel::kGray));
65 print_settings.SetInteger(kSettingDuplexMode,
66 static_cast<int>(mojom::DuplexMode::kSimplex));
67 print_settings.SetInteger(kSettingCopies, 1);
68 print_settings.SetBoolean(kSettingCollate, false);
69 print_settings.SetString(kSettingDeviceName, "");
70 print_settings.SetBoolean(kSettingRasterizePdf, false);
71 print_settings.SetBoolean(kSettingPreviewModifiable, false);
72 print_settings.SetInteger(kSettingDpiHorizontal, 0);
73 print_settings.SetInteger(kSettingDpiVertical, 0);
74 print_settings.SetInteger(kSettingPagesPerSheet, 1);
75
76 // User defined settings.
77 print_settings.SetBoolean(kSettingLandscape, !!pdf_settings.landscape);
78 print_settings.SetBoolean(kSettingShouldPrintSelectionOnly,
79 !!pdf_settings.selection_only);
80 print_settings.SetBoolean(kSettingShouldPrintBackgrounds,
81 !!pdf_settings.backgrounds_enabled);
82 print_settings.SetBoolean(kSettingHeaderFooterEnabled,
83 !!pdf_settings.header_footer_enabled);
84 print_settings.SetInteger(kSettingScaleFactor, pdf_settings.scale_factor > 0
85 ? pdf_settings.scale_factor
86 : 100);
87
88 if (pdf_settings.header_footer_enabled) {
89 print_settings.SetString(
90 kSettingHeaderFooterTitle,
91 CefString(&pdf_settings.header_footer_title).ToString16());
92 print_settings.SetString(
93 kSettingHeaderFooterURL,
94 CefString(&pdf_settings.header_footer_url).ToString16());
95 }
96
97 if (pdf_settings.page_width > 0 && pdf_settings.page_height > 0) {
98 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
99 dict->SetInteger(kSettingMediaSizeWidthMicrons, pdf_settings.page_width);
100 dict->SetInteger(kSettingMediaSizeHeightMicrons, pdf_settings.page_height);
101 print_settings.Set(kSettingMediaSize, std::move(dict));
102 }
103
104 auto margin_type = printing::mojom::MarginType::kDefaultMargins;
105 switch (pdf_settings.margin_type) {
106 case PDF_PRINT_MARGIN_NONE:
107 margin_type = printing::mojom::MarginType::kNoMargins;
108 break;
109 case PDF_PRINT_MARGIN_MINIMUM:
110 margin_type = printing::mojom::MarginType::kPrintableAreaMargins;
111 break;
112 case PDF_PRINT_MARGIN_CUSTOM:
113 margin_type = printing::mojom::MarginType::kCustomMargins;
114 break;
115 default:
116 break;
117 }
118
119 print_settings.SetInteger(kSettingMarginsType, static_cast<int>(margin_type));
120 if (margin_type == printing::mojom::MarginType::kCustomMargins) {
121 std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue);
122 dict->SetInteger(kSettingMarginTop, pdf_settings.margin_top);
123 dict->SetInteger(kSettingMarginRight, pdf_settings.margin_right);
124 dict->SetInteger(kSettingMarginBottom, pdf_settings.margin_bottom);
125 dict->SetInteger(kSettingMarginLeft, pdf_settings.margin_left);
126 print_settings.Set(kSettingMarginsCustom, std::move(dict));
127 }
128
129 // Service settings.
130 print_settings.SetInteger(kPreviewUIID, PREVIEW_UIID);
131 print_settings.SetInteger(kPreviewRequestID, request_id);
132 print_settings.SetBoolean(kIsFirstRequest, request_id != 0);
133 }
134
StopWorker(int document_cookie)135 void StopWorker(int document_cookie) {
136 if (document_cookie <= 0)
137 return;
138 scoped_refptr<PrintQueriesQueue> queue =
139 g_browser_process->print_job_manager()->queue();
140 std::unique_ptr<PrinterQuery> printer_query =
141 queue->PopPrinterQuery(document_cookie);
142 if (printer_query.get()) {
143 content::GetIOThreadTaskRunner({})->PostTask(
144 FROM_HERE,
145 base::BindOnce(&PrinterQuery::StopWorker, std::move(printer_query)));
146 }
147 }
148
149 // Write the PDF file to disk.
SavePdfFile(scoped_refptr<base::RefCountedSharedMemoryMapping> data,const base::FilePath & path,const CefPrintViewManager::PdfPrintCallback & callback)150 void SavePdfFile(scoped_refptr<base::RefCountedSharedMemoryMapping> data,
151 const base::FilePath& path,
152 const CefPrintViewManager::PdfPrintCallback& callback) {
153 CEF_REQUIRE_BLOCKING();
154 DCHECK_GT(data->size(), 0U);
155
156 MetafileSkia metafile;
157 metafile.InitFromData(*data);
158
159 base::File file(path,
160 base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE);
161 bool ok = file.IsValid() && metafile.SaveTo(&file);
162
163 if (!callback.is_null()) {
164 content::GetUIThreadTaskRunner({})->PostTask(FROM_HERE,
165 base::Bind(callback, ok));
166 }
167 }
168
169 } // namespace
170
171 struct CefPrintViewManager::PdfPrintState {
172 content::RenderFrameHost* printing_rfh_ = nullptr;
173 base::FilePath output_path_;
174 base::DictionaryValue settings_;
175 PdfPrintCallback callback_;
176 };
177
CefPrintViewManager(content::WebContents * web_contents)178 CefPrintViewManager::CefPrintViewManager(content::WebContents* web_contents)
179 : PrintViewManager(web_contents) {}
180
~CefPrintViewManager()181 CefPrintViewManager::~CefPrintViewManager() {
182 TerminatePdfPrintJob();
183 }
184
PrintToPDF(content::RenderFrameHost * rfh,const base::FilePath & path,const CefPdfPrintSettings & settings,const PdfPrintCallback & callback)185 bool CefPrintViewManager::PrintToPDF(content::RenderFrameHost* rfh,
186 const base::FilePath& path,
187 const CefPdfPrintSettings& settings,
188 const PdfPrintCallback& callback) {
189 DCHECK_CURRENTLY_ON(BrowserThread::UI);
190
191 // Don't start print again while printing is currently in progress.
192 if (pdf_print_state_)
193 return false;
194
195 // Don't print crashed tabs.
196 if (!web_contents() || web_contents()->IsCrashed()) {
197 return false;
198 }
199
200 pdf_print_state_.reset(new PdfPrintState);
201 pdf_print_state_->printing_rfh_ = rfh;
202 pdf_print_state_->output_path_ = path;
203 pdf_print_state_->callback_ = callback;
204
205 FillInDictionaryFromPdfPrintSettings(settings, ++next_pdf_request_id_,
206 pdf_print_state_->settings_);
207
208 auto& print_render_frame = GetPrintRenderFrame(rfh);
209 if (!pdf_print_receiver_.is_bound()) {
210 print_render_frame->SetPrintPreviewUI(
211 pdf_print_receiver_.BindNewEndpointAndPassRemote());
212 }
213
214 print_render_frame->InitiatePrintPreview({}, !!settings.selection_only);
215
216 return true;
217 }
218
GetDefaultPrintSettings(GetDefaultPrintSettingsCallback callback)219 void CefPrintViewManager::GetDefaultPrintSettings(
220 GetDefaultPrintSettingsCallback callback) {
221 #if defined(OS_LINUX)
222 // Send notification to the client.
223 auto browser = CefBrowserHostBase::GetBrowserForContents(web_contents());
224 if (browser) {
225 CefPrintDialogLinux::OnPrintStart(browser);
226 }
227 #endif
228 PrintViewManager::GetDefaultPrintSettings(std::move(callback));
229 }
230
DidShowPrintDialog()231 void CefPrintViewManager::DidShowPrintDialog() {
232 if (pdf_print_state_)
233 return;
234 PrintViewManager::DidShowPrintDialog();
235 }
236
RequestPrintPreview(mojom::RequestPrintPreviewParamsPtr params)237 void CefPrintViewManager::RequestPrintPreview(
238 mojom::RequestPrintPreviewParamsPtr params) {
239 if (!pdf_print_state_) {
240 PrintViewManager::RequestPrintPreview(std::move(params));
241 return;
242 }
243
244 GetPrintRenderFrame(pdf_print_state_->printing_rfh_)
245 ->PrintPreview(pdf_print_state_->settings_.Clone());
246 }
247
CheckForCancel(int32_t preview_ui_id,int32_t request_id,CheckForCancelCallback callback)248 void CefPrintViewManager::CheckForCancel(int32_t preview_ui_id,
249 int32_t request_id,
250 CheckForCancelCallback callback) {
251 if (!pdf_print_state_) {
252 return PrintViewManager::CheckForCancel(preview_ui_id, request_id,
253 std::move(callback));
254 }
255
256 std::move(callback).Run(/*cancel=*/false);
257 }
258
MetafileReadyForPrinting(mojom::DidPreviewDocumentParamsPtr params,int32_t request_id)259 void CefPrintViewManager::MetafileReadyForPrinting(
260 mojom::DidPreviewDocumentParamsPtr params,
261 int32_t request_id) {
262 DCHECK_CURRENTLY_ON(BrowserThread::UI);
263 StopWorker(params->document_cookie);
264
265 if (!pdf_print_state_)
266 return;
267
268 GetPrintRenderFrame(pdf_print_state_->printing_rfh_)
269 ->OnPrintPreviewDialogClosed();
270
271 auto shared_buf = base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(
272 params->content->metafile_data_region);
273 if (!shared_buf) {
274 TerminatePdfPrintJob();
275 return;
276 }
277
278 const base::FilePath output_path = pdf_print_state_->output_path_;
279 const PdfPrintCallback print_callback = pdf_print_state_->callback_;
280
281 // Reset state information.
282 pdf_print_state_.reset();
283 pdf_print_receiver_.reset();
284
285 // Save the PDF file to disk and then execute the callback.
286 CEF_POST_USER_VISIBLE_TASK(
287 base::Bind(&SavePdfFile, shared_buf, output_path, print_callback));
288 }
289
PrintPreviewFailed(int32_t document_cookie,int32_t request_id)290 void CefPrintViewManager::PrintPreviewFailed(int32_t document_cookie,
291 int32_t request_id) {
292 TerminatePdfPrintJob();
293 }
294
PrintPreviewCancelled(int32_t document_cookie,int32_t request_id)295 void CefPrintViewManager::PrintPreviewCancelled(int32_t document_cookie,
296 int32_t request_id) {
297 // Should never be canceled by CheckForCancel().
298 NOTREACHED();
299 }
300
RenderFrameDeleted(content::RenderFrameHost * render_frame_host)301 void CefPrintViewManager::RenderFrameDeleted(
302 content::RenderFrameHost* render_frame_host) {
303 if (pdf_print_state_ &&
304 render_frame_host == pdf_print_state_->printing_rfh_) {
305 TerminatePdfPrintJob();
306 }
307 PrintViewManager::RenderFrameDeleted(render_frame_host);
308 }
309
NavigationStopped()310 void CefPrintViewManager::NavigationStopped() {
311 TerminatePdfPrintJob();
312 PrintViewManager::NavigationStopped();
313 }
314
RenderProcessGone(base::TerminationStatus status)315 void CefPrintViewManager::RenderProcessGone(base::TerminationStatus status) {
316 TerminatePdfPrintJob();
317 PrintViewManager::RenderProcessGone(status);
318 }
319
320 // static
CreateForWebContents(content::WebContents * contents)321 void CefPrintViewManager::CreateForWebContents(content::WebContents* contents) {
322 DCHECK(contents);
323 if (!FromWebContents(contents)) {
324 contents->SetUserData(PrintViewManager::UserDataKey(),
325 base::WrapUnique(new CefPrintViewManager(contents)));
326 }
327 }
328
329 // static
FromWebContents(content::WebContents * contents)330 CefPrintViewManager* CefPrintViewManager::FromWebContents(
331 content::WebContents* contents) {
332 DCHECK(contents);
333 return static_cast<CefPrintViewManager*>(
334 contents->GetUserData(PrintViewManager::UserDataKey()));
335 }
336
337 // static
FromWebContents(const content::WebContents * contents)338 const CefPrintViewManager* CefPrintViewManager::FromWebContents(
339 const content::WebContents* contents) {
340 DCHECK(contents);
341 return static_cast<const CefPrintViewManager*>(
342 contents->GetUserData(PrintViewManager::UserDataKey()));
343 }
344
TerminatePdfPrintJob()345 void CefPrintViewManager::TerminatePdfPrintJob() {
346 DCHECK_CURRENTLY_ON(BrowserThread::UI);
347 if (!pdf_print_state_)
348 return;
349
350 if (!pdf_print_state_->callback_.is_null()) {
351 // Execute the callback.
352 content::GetUIThreadTaskRunner({})->PostTask(
353 FROM_HERE, base::Bind(pdf_print_state_->callback_, false));
354 }
355
356 // Reset state information.
357 pdf_print_state_.reset();
358 pdf_print_receiver_.reset();
359 }
360
361 } // namespace printing
362