OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 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 "headless/lib/browser/headless_print_manager.h" |
| 6 |
| 7 #include <utility> |
| 8 #include <vector> |
| 9 |
| 10 #include "base/base64.h" |
| 11 #include "components/printing/browser/print_manager_utils.h" |
| 12 #include "components/printing/common/print_messages.h" |
| 13 #include "printing/pdf_metafile_skia.h" |
| 14 #include "printing/print_settings.h" |
| 15 #include "printing/units.h" |
| 16 |
| 17 DEFINE_WEB_CONTENTS_USER_DATA_KEY(printing::HeadlessPrintManager); |
| 18 |
| 19 namespace printing { |
| 20 |
| 21 namespace { |
| 22 |
| 23 // TODO(jzfeng): let the print settings to be configurable. |
| 24 const double kTopMarginInInch = 0.25; |
| 25 const double kBottomMarginInInch = 0.56; |
| 26 const double kLeftMarginInInch = 0.25; |
| 27 const double kRightMarginInInch = 0.25; |
| 28 |
| 29 PrintSettings GetDefaultPDFPrinterSettings() { |
| 30 #if defined(OS_MACOSX) |
| 31 // On the Mac, the printable area is in points, use kPointsPerInch to compute |
| 32 // its bounds. |
| 33 int dpi = kPointsPerInch; |
| 34 #else |
| 35 int dpi = kDefaultPdfDpi; |
| 36 #endif |
| 37 gfx::Size physical_size_device_units; |
| 38 gfx::Rect printable_area_device_units; |
| 39 double page_width_in_pixel = kLetterWidthInch * dpi; |
| 40 double page_height_in_pixel = kLetterHeightInch * dpi; |
| 41 physical_size_device_units.SetSize(static_cast<int>(page_width_in_pixel), |
| 42 static_cast<int>(page_height_in_pixel)); |
| 43 printable_area_device_units.SetRect( |
| 44 static_cast<int>(kLeftMarginInInch * dpi), |
| 45 static_cast<int>(kTopMarginInInch * dpi), |
| 46 page_width_in_pixel - (kLeftMarginInInch + kRightMarginInInch) * dpi, |
| 47 page_height_in_pixel - (kTopMarginInInch + kBottomMarginInInch) * dpi); |
| 48 |
| 49 PrintSettings settings; |
| 50 settings.set_dpi(dpi); |
| 51 settings.SetPrinterPrintableArea(physical_size_device_units, |
| 52 printable_area_device_units, true); |
| 53 settings.set_should_print_backgrounds(true); |
| 54 return settings; |
| 55 } |
| 56 |
| 57 } // namespace |
| 58 |
| 59 HeadlessPrintManager::HeadlessPrintManager(content::WebContents* web_contents) |
| 60 : PrintManager(web_contents) { |
| 61 Reset(); |
| 62 } |
| 63 |
| 64 HeadlessPrintManager::~HeadlessPrintManager() {} |
| 65 |
| 66 // static |
| 67 std::string HeadlessPrintManager::PrintResultToString(PrintResult result) { |
| 68 switch (result) { |
| 69 case PRINT_SUCCESS: |
| 70 return std::string(); // no error message |
| 71 case PRINTING_FAILED: |
| 72 return "Printing failed"; |
| 73 case INVALID_PRINTER_SETTINGS: |
| 74 return "Show invalid printer settings error"; |
| 75 case INVALID_MEMORY_HANDLE: |
| 76 return "Invalid memory handle"; |
| 77 case METAFILE_MAP_ERROR: |
| 78 return "Map to shared memory error"; |
| 79 case UNEXPECTED_VALID_MEMORY_HANDLE: |
| 80 return "Unexpected valide memory handle"; |
| 81 case METAFILE_INVALID_HEADER: |
| 82 return "Invalid metafile header"; |
| 83 case METAFILE_GET_DATA_ERROR: |
| 84 return "Get data from metafile error"; |
| 85 case SIMULTANEOUS_PRINT_ACTIVE: |
| 86 return "The previous printing job hasn't finished"; |
| 87 default: |
| 88 NOTREACHED(); |
| 89 return "Unknown PrintResult"; |
| 90 } |
| 91 } |
| 92 |
| 93 // static |
| 94 std::unique_ptr<base::DictionaryValue> |
| 95 HeadlessPrintManager::PDFContentsToDictionaryValue(const std::string& data) { |
| 96 std::string base_64_data; |
| 97 base::Base64Encode(data, &base_64_data); |
| 98 auto result = base::MakeUnique<base::DictionaryValue>(); |
| 99 result->SetString("data", base_64_data); |
| 100 return result; |
| 101 } |
| 102 |
| 103 void HeadlessPrintManager::GetPDFContents(content::RenderFrameHost* rfh, |
| 104 const GetPDFCallback& callback) { |
| 105 DCHECK(callback); |
| 106 |
| 107 if (callback_) { |
| 108 callback.Run(SIMULTANEOUS_PRINT_ACTIVE, std::string()); |
| 109 return; |
| 110 } |
| 111 printing_rfh_ = rfh; |
| 112 callback_ = callback; |
| 113 rfh->Send(new PrintMsg_PrintPages(rfh->GetRoutingID())); |
| 114 } |
| 115 |
| 116 bool HeadlessPrintManager::OnMessageReceived( |
| 117 const IPC::Message& message, |
| 118 content::RenderFrameHost* render_frame_host) { |
| 119 bool handled = true; |
| 120 IPC_BEGIN_MESSAGE_MAP(HeadlessPrintManager, message) |
| 121 IPC_MESSAGE_HANDLER(PrintHostMsg_ShowInvalidPrinterSettingsError, |
| 122 OnShowInvalidPrinterSettingsError) |
| 123 IPC_MESSAGE_HANDLER(PrintHostMsg_DidPrintPage, OnDidPrintPage) |
| 124 IPC_MESSAGE_HANDLER_DELAY_REPLY(PrintHostMsg_GetDefaultPrintSettings, |
| 125 OnGetDefaultPrintSettings) |
| 126 IPC_MESSAGE_UNHANDLED(handled = false) |
| 127 IPC_END_MESSAGE_MAP() |
| 128 return handled || PrintManager::OnMessageReceived(message, render_frame_host); |
| 129 } |
| 130 |
| 131 void HeadlessPrintManager::OnGetDefaultPrintSettings(IPC::Message* reply_msg) { |
| 132 PrintMsg_Print_Params print_params; |
| 133 RenderParamsFromPrintSettings(GetDefaultPDFPrinterSettings(), &print_params); |
| 134 print_params.document_cookie = PrintSettings::NewCookie(); |
| 135 PrintHostMsg_GetDefaultPrintSettings::WriteReplyParams(reply_msg, |
| 136 print_params); |
| 137 printing_rfh_->Send(reply_msg); |
| 138 } |
| 139 |
| 140 void HeadlessPrintManager::OnShowInvalidPrinterSettingsError() { |
| 141 ReleaseJob(INVALID_PRINTER_SETTINGS); |
| 142 } |
| 143 |
| 144 void HeadlessPrintManager::OnPrintingFailed(int cookie) { |
| 145 ReleaseJob(PRINTING_FAILED); |
| 146 } |
| 147 |
| 148 void HeadlessPrintManager::OnDidPrintPage( |
| 149 const PrintHostMsg_DidPrintPage_Params& params) { |
| 150 if (!callback_) { |
| 151 DLOG(ERROR) |
| 152 << "Unexpected PrintHostMsg_DidPrintPage message from the renderer"; |
| 153 return; |
| 154 } |
| 155 |
| 156 const bool metafile_must_be_valid = expecting_first_page_; |
| 157 expecting_first_page_ = false; |
| 158 |
| 159 if (metafile_must_be_valid) { |
| 160 if (!base::SharedMemory::IsHandleValid(params.metafile_data_handle)) { |
| 161 ReleaseJob(INVALID_MEMORY_HANDLE); |
| 162 return; |
| 163 } |
| 164 auto shared_buf = |
| 165 base::MakeUnique<base::SharedMemory>(params.metafile_data_handle, true); |
| 166 if (!shared_buf->Map(params.data_size)) { |
| 167 ReleaseJob(METAFILE_MAP_ERROR); |
| 168 return; |
| 169 } |
| 170 auto metafile = base::MakeUnique<PdfMetafileSkia>(PDF_SKIA_DOCUMENT_TYPE); |
| 171 if (!metafile->InitFromData(shared_buf->memory(), params.data_size)) { |
| 172 ReleaseJob(METAFILE_INVALID_HEADER); |
| 173 return; |
| 174 } |
| 175 std::vector<char> buffer; |
| 176 if (!metafile->GetDataAsVector(&buffer)) { |
| 177 ReleaseJob(METAFILE_GET_DATA_ERROR); |
| 178 return; |
| 179 } |
| 180 data_ = std::string(buffer.data(), buffer.size()); |
| 181 } else { |
| 182 if (base::SharedMemory::IsHandleValid(params.metafile_data_handle)) { |
| 183 base::SharedMemory::CloseHandle(params.metafile_data_handle); |
| 184 ReleaseJob(UNEXPECTED_VALID_MEMORY_HANDLE); |
| 185 return; |
| 186 } |
| 187 } |
| 188 |
| 189 if (--number_pages_ == 0) |
| 190 ReleaseJob(PRINT_SUCCESS); |
| 191 } |
| 192 |
| 193 void HeadlessPrintManager::Reset() { |
| 194 printing_rfh_ = nullptr; |
| 195 callback_.Reset(); |
| 196 data_.clear(); |
| 197 expecting_first_page_ = true; |
| 198 number_pages_ = 0; |
| 199 } |
| 200 |
| 201 void HeadlessPrintManager::ReleaseJob(PrintResult result) { |
| 202 if (!callback_) { |
| 203 DLOG(ERROR) << "ReleaseJob is called when callback_ is null. Check whether " |
| 204 "ReleaseJob is called more than once."; |
| 205 return; |
| 206 } |
| 207 |
| 208 if (result == PRINT_SUCCESS) |
| 209 callback_.Run(result, std::move(data_)); |
| 210 else |
| 211 callback_.Run(result, std::string()); |
| 212 printing_rfh_->Send(new PrintMsg_PrintingDone(printing_rfh_->GetRoutingID(), |
| 213 result == PRINT_SUCCESS)); |
| 214 Reset(); |
| 215 } |
| 216 |
| 217 } // namespace printing |
OLD | NEW |