add customized printing setting for headless

headless/lib/browser/headless_devtools_manager_delegate.cc

 // Copyright 2016 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_devtools_manager_delegate.h"
 
 #include <string>
 #include <utility>
 
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_frontend_host.h"
 #include "content/public/browser/web_contents.h"
 #include "headless/grit/headless_lib_resources.h"
 #include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_browser_impl.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/public/devtools/domains/target.h"
 #include "printing/features/features.h"
@@ skipping 46 matching lines @@
 
 std::unique_ptr<base::DictionaryValue> CreateInvalidParamResponse(
     int command_id,
     const std::string& param) {
   return CreateErrorResponse(
       command_id, kErrorInvalidParam,
       base::StringPrintf("Missing or invalid '%s' parameter", param.c_str()));
 }
 
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
+std::unique_ptr<base::DictionaryValue> ParsePrintParams(
+    int command_id,
+    const base::DictionaryValue* params,
+    printing::HeadlessPrintSettings* settings) {
+  params->GetInteger("dpi", &settings->dpi);
+  params->GetBoolean("landscape", &settings->landscape);
+  params->GetBoolean("displayHeaderFooter", &settings->display_header_footer);
+  params->GetBoolean("printBackgrounds", &settings->should_print_backgrounds);
+  params->GetDouble("scale", &settings->scale);
+  if (settings->scale < 0)
+    return CreateInvalidParamResponse(command_id, "scale");
+
+  std::string paper_type;
+  if (params->GetString("paperType", &paper_type)) {
+    if (paper_type == "letter")
+      settings->paper_type = printing::HeadlessPrintSettings::LETTER;
+    else if (paper_type == "legal")
+      settings->paper_type = printing::HeadlessPrintSettings::LEGAL;
+    else if (paper_type == "A4")
+      settings->paper_type = printing::HeadlessPrintSettings::A4;
+    else if (paper_type == "A3")
+      settings->paper_type = printing::HeadlessPrintSettings::A3;
+    else
+      return CreateInvalidParamResponse(command_id, "paperType");
+  }
+
+  std::string margin_type;
+  if (params->GetString("marginType", &margin_type)) {
+    if (margin_type == "defaultMargin") {
+      settings->margin_type = printing::DEFAULT_MARGINS;
+    } else if (margin_type == "noMargin") {
+      settings->margin_type = printing::NO_MARGINS;
+    } else if (margin_type == "customMargin") {
+      settings->margin_type = printing::CUSTOM_MARGINS;
+      if (!params->GetDouble("marginTop", &settings->margin_top_in_inch))
+        return CreateInvalidParamResponse(command_id, "marginTop");
+      if (!params->GetDouble("marginBottom",
+                             &settings->margin_bottom_in_inch)) {
+        return CreateInvalidParamResponse(command_id, "marginBottom");
+      }
+      if (!params->GetDouble("marginLeft", &settings->margin_left_in_inch))
+        return CreateInvalidParamResponse(command_id, "marginLeft");
+      if (!params->GetDouble("marginRight", &settings->margin_right_in_inch)) {
+        return CreateInvalidParamResponse(command_id, "marginRight");
+      }
+    } else {
+      return CreateInvalidParamResponse(command_id, "marginType");
+    }
+  }
+
+  std::string page_ranges;
+  if (params->GetString("pageRanges", &page_ranges)) {
+    for (const auto& range_string :
+         base::SplitStringPiece(page_ranges, ",", base::TRIM_WHITESPACE,
+                                base::SPLIT_WANT_NONEMPTY)) {
+      auto tokens = base::SplitStringPiece(
+          range_string, "-", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+      if (tokens.size() > 2 || tokens.empty())
+        return CreateInvalidParamResponse(command_id, "pageRanges");
+      printing::PageRange range;
+      base::StringToInt(tokens[0], &range.from);
+      if (tokens.size() == 2)
+        base::StringToInt(tokens[1], &range.to);
+      else
+        range.to = range.from;
+      if (range.from < 1 || range.from > range.to)
+        return CreateInvalidParamResponse(command_id, "pageRanges");
+
+      // Page numbers are 1-based in the dictionary.
+      // Page numbers are 0-based for the print settings.
+      range.from--;
+      range.to--;
+      settings->page_ranges.push_back(range);
+    }
+  }
+
+  return nullptr;
+}
+
 void PDFCreated(
     const content::DevToolsManagerDelegate::CommandCallback& callback,
     int command_id,
     printing::HeadlessPrintManager::PrintResult print_result,
     const std::string& data) {
   std::unique_ptr<base::DictionaryValue> response;
   if (print_result == printing::HeadlessPrintManager::PRINT_SUCCESS) {
     response = CreateSuccessResponse(
         command_id,
         printing::HeadlessPrintManager::PDFContentsToDictionaryValue(data));
@@ skipping 96 matching lines @@
 std::string HeadlessDevToolsManagerDelegate::GetFrontendResource(
     const std::string& path) {
   return content::DevToolsFrontendHost::GetFrontendResource(path).as_string();
 }
 
 void HeadlessDevToolsManagerDelegate::PrintToPDF(
     content::DevToolsAgentHost* agent_host,
     int command_id,
     const base::DictionaryValue* params,
     const CommandCallback& callback) {
+  DCHECK(callback);
+
 #if BUILDFLAG(ENABLE_BASIC_PRINTING)
+#if !BUILDFLAG(ENABLE_PRINT_PREVIEW)
+  LOG(WARNING)
+      << "Print preview is not enabled. Some print settings may not work";
+#endif
   content::WebContents* web_contents = agent_host->GetWebContents();
   content::RenderFrameHost* rfh = web_contents->GetMainFrame();
 
+  printing::HeadlessPrintSettings settings;
+  auto response = ParsePrintParams(command_id, params, &settings);
+  if (response) {
+    callback.Run(std::move(response));
+    return;
+  }
   printing::HeadlessPrintManager::FromWebContents(web_contents)
-      ->GetPDFContents(rfh, base::Bind(&PDFCreated, callback, command_id));
+      ->GetPDFContents(rfh, settings,
+                       base::Bind(&PDFCreated, callback, command_id));
 #else
-  DCHECK(callback);
   callback.Run(CreateErrorResponse(command_id, kErrorServerError,
                                    "Printing is not enabled"));
 #endif
 }
 
 std::unique_ptr<base::DictionaryValue>
 HeadlessDevToolsManagerDelegate::CreateTarget(
     int command_id,
     const base::DictionaryValue* params) {
   std::string url;
@@ skipping 91 matching lines @@
 
   std::unique_ptr<base::Value> result(
       target::DisposeBrowserContextResult::Builder()
           .SetSuccess(success)
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
 }  // namespace headless