| // Copyright 2014 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/protocol/page_handler.h" |
| |
| #include "base/base64.h" |
| #include "content/public/browser/web_contents.h" |
| #include "printing/units.h" |
| |
| namespace headless { |
| namespace protocol { |
| |
| #if BUILDFLAG(ENABLE_PRINTING) |
| namespace { |
| |
| // The max and min value should match the ones in scaling_settings.html. |
| // Update both files at the same time. |
| const double kScaleMaxVal = 200; |
| const double kScaleMinVal = 10; |
| |
| void PDFCreated(std::unique_ptr<PageHandler::PrintToPDFCallback> callback, |
| HeadlessPrintManager::PrintResult print_result, |
| const std::string& data) { |
| std::unique_ptr<base::DictionaryValue> response; |
| if (print_result == HeadlessPrintManager::PRINT_SUCCESS) { |
| std::string base_64_data; |
| base::Base64Encode(data, &base_64_data); |
| callback->sendSuccess(base_64_data); |
| } else { |
| callback->sendFailure(Response::Error( |
| HeadlessPrintManager::PrintResultToString(print_result))); |
| } |
| } |
| |
| } // namespace |
| #endif // BUILDFLAG(ENABLE_PRINTING) |
| |
| PageHandler::PageHandler(base::WeakPtr<HeadlessBrowserImpl> browser, |
| content::WebContents* web_contents) |
| : DomainHandler(Page::Metainfo::domainName, browser), |
| web_contents_(web_contents) { |
| DCHECK(web_contents_); |
| } |
| |
| PageHandler::~PageHandler() = default; |
| |
| void PageHandler::Wire(UberDispatcher* dispatcher) { |
| Page::Dispatcher::wire(dispatcher, this); |
| } |
| |
| void PageHandler::PrintToPDF(Maybe<bool> landscape, |
| Maybe<bool> display_header_footer, |
| Maybe<bool> print_background, |
| Maybe<double> scale, |
| Maybe<double> paper_width, |
| Maybe<double> paper_height, |
| Maybe<double> margin_top, |
| Maybe<double> margin_bottom, |
| Maybe<double> margin_left, |
| Maybe<double> margin_right, |
| Maybe<String> page_ranges, |
| Maybe<bool> ignore_invalid_page_ranges, |
| Maybe<String> header_template, |
| Maybe<String> footer_template, |
| Maybe<bool> prefer_css_page_size, |
| std::unique_ptr<PrintToPDFCallback> callback) { |
| #if BUILDFLAG(ENABLE_PRINTING) |
| HeadlessPrintSettings settings; |
| settings.landscape = landscape.fromMaybe(false); |
| settings.display_header_footer = display_header_footer.fromMaybe(false); |
| settings.should_print_backgrounds = print_background.fromMaybe(false); |
| settings.scale = scale.fromMaybe(1.0); |
| if (settings.scale > kScaleMaxVal / 100 || |
| settings.scale < kScaleMinVal / 100) { |
| callback->sendFailure( |
| Response::InvalidParams("scale is outside [0.1 - 2] range")); |
| return; |
| } |
| settings.page_ranges = page_ranges.fromMaybe(""); |
| settings.ignore_invalid_page_ranges = |
| ignore_invalid_page_ranges.fromMaybe(false); |
| |
| double paper_width_in_inch = |
| paper_width.fromMaybe(printing::kLetterWidthInch); |
| double paper_height_in_inch = |
| paper_height.fromMaybe(printing::kLetterHeightInch); |
| if (paper_width_in_inch <= 0) { |
| callback->sendFailure( |
| Response::InvalidParams("paperWidth is zero or negative")); |
| return; |
| } |
| if (paper_height_in_inch <= 0) { |
| callback->sendFailure( |
| Response::InvalidParams("paperHeight is zero or negative")); |
| return; |
| } |
| settings.paper_size_in_points = |
| gfx::Size(paper_width_in_inch * printing::kPointsPerInch, |
| paper_height_in_inch * printing::kPointsPerInch); |
| |
| // Set default margin to 1.0cm = ~2/5 of an inch. |
| static constexpr double kDefaultMarginInMM = 10.0; |
| static constexpr double kMMPerInch = printing::kMicronsPerMil; |
| static constexpr double kDefaultMarginInInch = |
| kDefaultMarginInMM / kMMPerInch; |
| double margin_top_in_inch = margin_top.fromMaybe(kDefaultMarginInInch); |
| double margin_right_in_inch = margin_right.fromMaybe(kDefaultMarginInInch); |
| double margin_bottom_in_inch = margin_bottom.fromMaybe(kDefaultMarginInInch); |
| double margin_left_in_inch = margin_left.fromMaybe(kDefaultMarginInInch); |
| |
| settings.header_template = header_template.fromMaybe(""); |
| settings.footer_template = footer_template.fromMaybe(""); |
| |
| if (margin_top_in_inch < 0) { |
| callback->sendFailure(Response::InvalidParams("marginTop is negative")); |
| return; |
| } |
| if (margin_bottom_in_inch < 0) { |
| callback->sendFailure(Response::InvalidParams("marginBottom is negative")); |
| return; |
| } |
| if (margin_left_in_inch < 0) { |
| callback->sendFailure(Response::InvalidParams("marginLeft is negative")); |
| return; |
| } |
| if (margin_right_in_inch < 0) { |
| callback->sendFailure(Response::InvalidParams("marginRight is negative")); |
| return; |
| } |
| settings.margins_in_points.top = |
| margin_top_in_inch * printing::kPointsPerInch; |
| settings.margins_in_points.bottom = |
| margin_bottom_in_inch * printing::kPointsPerInch; |
| settings.margins_in_points.left = |
| margin_left_in_inch * printing::kPointsPerInch; |
| settings.margins_in_points.right = |
| margin_right_in_inch * printing::kPointsPerInch; |
| settings.prefer_css_page_size = prefer_css_page_size.fromMaybe(false); |
| |
| HeadlessPrintManager::FromWebContents(web_contents_) |
| ->GetPDFContents(web_contents_->GetMainFrame(), settings, |
| base::BindOnce(&PDFCreated, std::move(callback))); |
| #else |
| callback->sendFailure(Response::Error("Printing is not enabled")); |
| return; |
| #endif // BUILDFLAG(ENABLE_PRINTING) |
| } |
| |
| } // namespace protocol |
| } // namespace headless |