Index: headless/lib/browser/headless_print_manager.cc |
diff --git a/headless/lib/browser/headless_print_manager.cc b/headless/lib/browser/headless_print_manager.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..6e6a1b4cb19ae09e43089a285a27fbcd7f7bef52 |
--- /dev/null |
+++ b/headless/lib/browser/headless_print_manager.cc |
@@ -0,0 +1,209 @@ |
+// Copyright 2017 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "headless/lib/browser/headless_print_manager.h" |
+ |
+#include <utility> |
+#include <vector> |
+ |
+#include "base/base64.h" |
+#include "components/printing/browser/print_manager_utils.h" |
+#include "components/printing/common/print_messages.h" |
+#include "printing/pdf_metafile_skia.h" |
+#include "printing/print_settings.h" |
+#include "printing/units.h" |
+ |
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(printing::HeadlessPrintManager); |
+ |
+namespace printing { |
+ |
+namespace { |
+ |
+// TODO(jzfeng): let the print settings to be configurable. |
+const double kTopMarginInInch = 0.25; |
+const double kBottomMarginInInch = 0.56; |
+const double kLeftMarginInInch = 0.25; |
+const double kRightMarginInInch = 0.25; |
+ |
+PrintSettings GetDefaultPDFPrinterSettings() { |
+ int dpi = kDefaultPdfDpi; |
+ gfx::Size physical_size_device_units; |
+ gfx::Rect printable_area_device_units; |
+ double page_width_in_pixel = kLetterWidthInch * dpi; |
+ double page_height_in_pixel = kLetterHeightInch * dpi; |
+ physical_size_device_units.SetSize(static_cast<int>(page_width_in_pixel), |
+ static_cast<int>(page_height_in_pixel)); |
+ printable_area_device_units.SetRect( |
+ static_cast<int>(kLeftMarginInInch * dpi), |
+ static_cast<int>(kTopMarginInInch * dpi), |
+ page_width_in_pixel - (kLeftMarginInInch + kRightMarginInInch) * dpi, |
+ page_height_in_pixel - (kTopMarginInInch + kBottomMarginInInch) * dpi); |
+ |
+ PrintSettings settings; |
+ settings.set_dpi(dpi); |
+ settings.SetPrinterPrintableArea(physical_size_device_units, |
+ printable_area_device_units, true); |
+ settings.set_should_print_backgrounds(true); |
+ return settings; |
+} |
+ |
+} // namespace |
+ |
+void HeadlessPrintManager::Reset() { |
Lei Zhang
2017/03/29 05:30:16
Can you put these in the same order as they are de
jzfeng
2017/03/30 03:04:57
Done.
|
+ printing_rfh_ = nullptr; |
+ data_.clear(); |
+ is_active_ = false; |
+#if !defined(OS_MACOSX) |
+ expecting_first_page_ = true; |
+#endif |
+ number_pages_ = 0; |
+} |
+ |
+HeadlessPrintManager::HeadlessPrintManager(content::WebContents* web_contents) |
+ : PrintManager(web_contents) { |
+ Reset(); |
+} |
+ |
+HeadlessPrintManager::~HeadlessPrintManager() {} |
+ |
+// static |
+std::string HeadlessPrintManager::PrintResultToErrMsg(PrintResult result) { |
Eric Seckler
2017/03/29 11:21:20
nit: PrintResultToString
jzfeng
2017/03/30 03:04:57
Done.
|
+ switch (result) { |
+ case kPrintSuccess: |
+ return ""; // no error message |
+ case kPrintingFailed: |
+ return "PrintingFailed"; |
+ case kInvalidPrinterSettings: |
+ return "ShowInvalidPrinterSettingsError"; |
+ case kInvalidMemoryHandle: |
+ return "Invalid memory handle"; |
+ case kMetafileMapError: |
+ return "Map to SharedMemory error"; |
+ case kUnexpectedValidMemoryHandle: |
+ return "Unexpected valide memory handle"; |
+ case kMetafileInvalidHeader: |
+ return "Invalid metafile header"; |
+ case kMetafileGetDataError: |
+ return "Get data from metafile error"; |
+ case kDuplicatedPrintingError: |
+ return "The previous printing job hasn't finished"; |
+ default: |
+ NOTREACHED(); |
+ return "Unknown PrintResult"; |
+ } |
+} |
+ |
+// static |
+std::unique_ptr<base::DictionaryValue> |
+HeadlessPrintManager::PDFContentsToDictionaryValue(const std::string& data) { |
+ std::string base_64_data; |
+ base::Base64Encode(data, &base_64_data); |
+ auto result = base::MakeUnique<base::DictionaryValue>(); |
+ result->SetString("data", base_64_data); |
+ return result; |
+} |
+ |
+void HeadlessPrintManager::GetPDFContents(content::RenderFrameHost* rfh, |
+ const GetPDFCallback& callback) { |
Lei Zhang
2017/03/29 05:30:15
Add DCHECK(callback);
jzfeng
2017/03/30 03:04:57
Done.
|
+ if (is_active_) { |
+ callback.Run(kDuplicatedPrintingError, ""); |
+ return; |
+ } |
+ is_active_ = true; |
+ printing_rfh_ = rfh; |
+ callback_ = callback; |
+ rfh->Send(new PrintMsg_PrintPages(rfh->GetRoutingID())); |
+} |
+ |
+bool HeadlessPrintManager::OnMessageReceived( |
+ const IPC::Message& message, |
+ content::RenderFrameHost* render_frame_host) { |
+ bool handled = true; |
+ IPC_BEGIN_MESSAGE_MAP(HeadlessPrintManager, message) |
+ IPC_MESSAGE_HANDLER(PrintHostMsg_ShowInvalidPrinterSettingsError, |
+ OnShowInvalidPrinterSettingsError) |
+ IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage) |
+ IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_GetDefaultPrintSettings, |
+ OnGetDefaultPrintSettings) |
+ IPC_MESSAGE_UNHANDLED(handled = false) |
+ IPC_END_MESSAGE_MAP() |
+ return handled || PrintManager::OnMessageReceived(message, render_frame_host); |
+} |
+ |
+void HeadlessPrintManager::OnGetDefaultPrintSettings(IPC::Message* reply_msg) { |
+ PrintMsg_Print_Params print_params; |
+ RenderParamsFromPrintSettings(GetDefaultPDFPrinterSettings(), &print_params); |
+ print_params.document_cookie = PrintSettings::NewCookie(); |
+ PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(reply_msg, |
+ print_params); |
+ printing_rfh_->Send(reply_msg); |
+} |
+ |
+void HeadlessPrintManager::OnShowInvalidPrinterSettingsError() { |
+ ReleaseJob(kInvalidPrinterSettings); |
+} |
+ |
+void HeadlessPrintManager::OnPrintingFailed(int cookie) { |
+ ReleaseJob(kPrintingFailed); |
+} |
+ |
+void HeadlessPrintManager::OnDidPrintPage( |
+ const PrintHostMsg_DidPrintPage_Params& params) { |
+#if defined(OS_MACOSX) |
+ const bool metafile_must_be_valid = true; |
+#else |
+ const bool metafile_must_be_valid = expecting_first_page_; |
+ expecting_first_page_ = false; |
+#endif |
+ |
+ // Only used when |metafile_must_be_valid| is true. |
+ std::unique_ptr<base::SharedMemory> shared_buf; |
+ if (metafile_must_be_valid) { |
+ if (!base::SharedMemory::IsHandleValid(params.metafile_data_handle)) { |
+ ReleaseJob(kInvalidMemoryHandle); |
+ return; |
+ } |
+ shared_buf = |
+ base::MakeUnique<base::SharedMemory>(params.metafile_data_handle, true); |
+ if (!shared_buf->Map(params.data_size)) { |
+ ReleaseJob(kMetafileMapError); |
+ return; |
+ } |
+ } else { |
+ if (base::SharedMemory::IsHandleValid(params.metafile_data_handle)) { |
+ base::SharedMemory::CloseHandle(params.metafile_data_handle); |
+ ReleaseJob(kUnexpectedValidMemoryHandle); |
+ return; |
+ } |
+ } |
+ |
+ auto metafile = base::MakeUnique<PdfMetafileSkia>(PDF_SKIA_DOCUMENT_TYPE); |
+ if (metafile_must_be_valid) { |
+ if (!metafile->InitFromData(shared_buf->memory(), params.data_size)) { |
+ ReleaseJob(kMetafileInvalidHeader); |
+ return; |
+ } |
+ std::vector<char> buffer; |
+ if (!metafile->GetDataAsVector(&buffer)) { |
+ ReleaseJob(kMetafileGetDataError); |
+ return; |
+ } |
+ data_ = std::string(buffer.data(), buffer.size()); |
Eric Seckler
2017/03/29 11:21:19
This seems to override whatever is in data_. What
jzfeng
2017/03/30 03:04:57
You are right. This is a temporary solution. Looks
Lei Zhang
2017/04/06 08:08:42
Under normal operations, you should get 1 per page
|
+ } |
+ |
+ if (--number_pages_ == 0) |
+ ReleaseJob(kPrintSuccess); |
+} |
+ |
+void HeadlessPrintManager::ReleaseJob(PrintResult result) { |
+ if (result == kPrintSuccess) |
+ callback_.Run(result, std::move(data_)); |
+ else |
+ callback_.Run(result, ""); |
Eric Seckler
2017/03/29 11:21:19
nit: std::string()
jzfeng
2017/03/30 03:04:57
Done.
|
+ printing_rfh_->Send(new PrintMsg_PrintingDone(printing_rfh_->GetRoutingID(), |
+ result == kPrintSuccess)); |
+ Reset(); |
+} |
+ |
+} // namespace printing |