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 "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"
 #include "ui/base/resource/resource_bundle.h"
 
-#if BUILDFLAG(ENABLE_BASIC_PRINTING)
-#include "headless/lib/browser/headless_print_manager.h"
-#endif
-
 namespace headless {
 
 namespace {
 const char kIdParam[] = "id";
 const char kResultParam[] = "result";
 const char kErrorParam[] = "error";
 const char kErrorCodeParam[] = "code";
 const char kErrorMessageParam[] = "message";
 
+// 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;
+
 // JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
 enum Error {
   kErrorInvalidParam = -32602,
   kErrorServerError = -32000
 };
 
 std::unique_ptr<base::DictionaryValue> CreateSuccessResponse(
     int command_id,
     std::unique_ptr<base::Value> result) {
   if (!result)
@@ skipping 42 matching lines @@
     response = CreateErrorResponse(
         command_id, kErrorServerError,
         printing::HeadlessPrintManager::PrintResultToString(print_result));
   }
   callback.Run(std::move(response));
 }
 #endif
 
 }  // namespace
 
+#if BUILDFLAG(ENABLE_BASIC_PRINTING)
+std::unique_ptr<base::DictionaryValue> ParsePrintSettings(
+    int command_id,
+    const base::DictionaryValue* params,
+    printing::HeadlessPrintSettings* settings) {
+  const double kMMToInch = 1 / 25.4;
+  // we can safely ignore the return values of the following Get methods since
+  // the defaults are already set in |settings|.
+  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 > kScaleMaxVal / 100 ||
+      settings->scale < kScaleMinVal / 100)
+    return CreateInvalidParamResponse(command_id, "scale");
+  params->GetString("pageRanges", &settings->page_ranges);
+
+  std::string paper_type = "NA_LETTER";
+  params->GetString("paperType", &paper_type);
+  if (paper_type == "NA_LETTER") {
+    settings->paper_type = printing::HeadlessPrintSettings::NA_LETTER;
+  } else if (paper_type == "NA_LEGAL") {
+    settings->paper_type = printing::HeadlessPrintSettings::NA_LEGAL;
+  } else if (paper_type == "ISO_A4") {
+    settings->paper_type = printing::HeadlessPrintSettings::ISO_A4;
+  } else if (paper_type == "ISO_A3") {
+    settings->paper_type = printing::HeadlessPrintSettings::ISO_A3;
+  } else if (paper_type == "CUSTOM") {
+    settings->paper_type = printing::HeadlessPrintSettings::CUSTOM;
+    if (!params->GetDouble("paperWidth", &settings->paper_width_in_inch))
+      return CreateInvalidParamResponse(command_id, "paperWidth");
+    if (!params->GetDouble("paperHeight", &settings->paper_height_in_inch))
+      return CreateInvalidParamResponse(command_id, "paperHeight");
+  } else {
+    return CreateInvalidParamResponse(command_id, "paperType");
+  }
+
+  bool custom_margin = false;
+  if (params->GetDouble("marginTop", &settings->margin_top_in_inch))
+    custom_margin = true;
+  if (params->GetDouble("marginBottom", &settings->margin_bottom_in_inch))
+    custom_margin = true;
+  if (params->GetDouble("marginLeft", &settings->margin_left_in_inch))
+    custom_margin = true;
+  if (params->GetDouble("marginRight", &settings->margin_right_in_inch))
+    custom_margin = true;
+  if (custom_margin) {
+    settings->margin_type = printing::CUSTOM_MARGINS;
+  } else {
+    settings->margin_type = printing::DEFAULT_MARGINS;
+  }
+
+  std::string unit = "INCH";
+  if (params->GetString("unit", &unit) && unit != "MM" && unit != "INCH")
+    return CreateInvalidParamResponse(command_id, "unit");
+  if (unit == "MM") {
+    settings->paper_width_in_inch *= kMMToInch;
+    settings->paper_height_in_inch *= kMMToInch;
+    settings->margin_top_in_inch *= kMMToInch;
+    settings->margin_bottom_in_inch *= kMMToInch;
+    settings->margin_left_in_inch *= kMMToInch;
+    settings->margin_right_in_inch *= kMMToInch;
+  }
+
+  return nullptr;
+}
+#endif
+
 HeadlessDevToolsManagerDelegate::HeadlessDevToolsManagerDelegate(
     base::WeakPtr<HeadlessBrowserImpl> browser)
     : browser_(std::move(browser)) {
   command_map_["Target.createTarget"] = base::Bind(
       &HeadlessDevToolsManagerDelegate::CreateTarget, base::Unretained(this));
   command_map_["Target.closeTarget"] = base::Bind(
       &HeadlessDevToolsManagerDelegate::CloseTarget, base::Unretained(this));
   command_map_["Target.createBrowserContext"] =
       base::Bind(&HeadlessDevToolsManagerDelegate::CreateBrowserContext,
                  base::Unretained(this));
@@ skipping 75 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;
+  std::unique_ptr<base::DictionaryValue> response =
+      ParsePrintSettings(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