add print to pdf 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/base64.h"

[Eric Seckler, 2017/03/29 11:21:19]

nit: unnecessary?

[jzfeng, 2017/03/30 03:04:57]

Done.

 #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_print_manager.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/public/devtools/domains/target.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace headless {
 
 namespace {
 const char kIdParam[] = "id";
 const char kResultParam[] = "result";
 const char kErrorParam[] = "error";
 const char kErrorCodeParam[] = "code";
 const char kErrorMessageParam[] = "message";
 
 // 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)
-    result.reset(new base::DictionaryValue());
+    result = base::MakeUnique<base::DictionaryValue>();
 
-  std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  auto response = base::MakeUnique<base::DictionaryValue>();
   response->SetInteger(kIdParam, command_id);
   response->Set(kResultParam, std::move(result));
   return response;
 }
 
 std::unique_ptr<base::DictionaryValue> CreateErrorResponse(
     int command_id,
     int error_code,
     const std::string& error_message) {
-  std::unique_ptr<base::DictionaryValue> error_object(
-      new base::DictionaryValue());
+  auto error_object = base::MakeUnique<base::DictionaryValue>();
   error_object->SetInteger(kErrorCodeParam, error_code);
   error_object->SetString(kErrorMessageParam, error_message);
 
-  std::unique_ptr<base::DictionaryValue> response(new base::DictionaryValue());
+  auto response = base::MakeUnique<base::DictionaryValue>();
+  response->SetInteger(kIdParam, command_id);
   response->Set(kErrorParam, std::move(error_object));
   return response;
 }
 
 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()));
 }
+
+void PDFCreated(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::kPrintSuccess) {
+    response = CreateSuccessResponse(
+        command_id,
+        printing::HeadlessPrintManager::PDFContentsToDictionaryValue(data));
+  } else {
+    response = CreateErrorResponse(
+        command_id, kErrorServerError,
+        printing::HeadlessPrintManager::PrintResultToErrMsg(print_result));
+  }
+  callback.Run(std::move(response));
+}
+
 }  // namespace
 
 HeadlessDevToolsManagerDelegate::HeadlessDevToolsManagerDelegate(
     base::WeakPtr<HeadlessBrowserImpl> browser)
     : browser_(std::move(browser)) {
   command_map_["Target.createTarget"] =
       &HeadlessDevToolsManagerDelegate::CreateTarget;
   command_map_["Target.closeTarget"] =
       &HeadlessDevToolsManagerDelegate::CloseTarget;
   command_map_["Target.createBrowserContext"] =
       &HeadlessDevToolsManagerDelegate::CreateBrowserContext;
   command_map_["Target.disposeBrowserContext"] =
       &HeadlessDevToolsManagerDelegate::DisposeBrowserContext;
+
+  async_command_map_["Page.printToPDF"] =
+      &HeadlessDevToolsManagerDelegate::PrintToPDF;
 }
 
 HeadlessDevToolsManagerDelegate::~HeadlessDevToolsManagerDelegate() {}
 
 base::DictionaryValue* HeadlessDevToolsManagerDelegate::HandleCommand(
     content::DevToolsAgentHost* agent_host,
     base::DictionaryValue* command) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!browser_)
     return nullptr;
 
   int id;
   std::string method;
   if (!command->GetInteger("id", &id) ||
       !command->GetString("method", &method)) {
     return nullptr;
   }
   auto find_it = command_map_.find(method);
   if (find_it == command_map_.end())
     return nullptr;
   CommandMemberFnPtr command_fn_ptr = find_it->second;
   const base::DictionaryValue* params = nullptr;
   command->GetDictionary("params", &params);
   std::unique_ptr<base::DictionaryValue> cmd_result(
-      ((this)->*command_fn_ptr)(id, params));
+      (this->*command_fn_ptr)(id, params));
   return cmd_result.release();
 }
 
+bool HeadlessDevToolsManagerDelegate::HandleAsyncCommand(
+    content::DevToolsAgentHost* agent_host,
+    base::DictionaryValue* command,
+    const CommandCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (!browser_)
+    return false;
+
+  int id;
+  std::string method;
+  if (!command->GetInteger("id", &id) ||
+      !command->GetString("method", &method)) {
+    return false;
+  }
+  auto find_it = async_command_map_.find(method);
+  if (find_it == async_command_map_.end())
+    return false;
+  AsyncCommandMemberFnPtr async_command_fn_ptr = find_it->second;
+  const base::DictionaryValue* params = nullptr;
+  command->GetDictionary("params", &params);
+  (this->*async_command_fn_ptr)(agent_host, id, params, callback);
+  return true;
+}
+
 scoped_refptr<content::DevToolsAgentHost>
 HeadlessDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
   HeadlessBrowserContext* context = browser_->GetDefaultBrowserContext();
   HeadlessWebContentsImpl* web_contents_impl = HeadlessWebContentsImpl::From(
       context->CreateWebContentsBuilder()
           .SetInitialURL(url)
           .SetWindowSize(browser_->options()->window_size)
           .Build());
   return content::DevToolsAgentHost::GetOrCreateFor(
       web_contents_impl->web_contents());
 }
 
 std::string HeadlessDevToolsManagerDelegate::GetDiscoveryPageHTML() {
   return ResourceBundle::GetSharedInstance()
       .GetRawDataResource(IDR_HEADLESS_LIB_DEVTOOLS_DISCOVERY_PAGE)
       .as_string();
 }
 
 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,
+    CommandCallback callback) {
+  content::WebContents* web_contents = agent_host->GetWebContents();
+  content::RenderFrameHost* rfh = web_contents->GetMainFrame();
+
+  printing::HeadlessPrintManager::FromWebContents(web_contents)
+      ->GetPDFContents(rfh, base::Bind(&PDFCreated, callback, command_id));
+}
+
 std::unique_ptr<base::DictionaryValue>
 HeadlessDevToolsManagerDelegate::CreateTarget(
     int command_id,
     const base::DictionaryValue* params) {
   std::string url;
   std::string browser_context_id;
   int width = browser_->options()->window_size.width();
   int height = browser_->options()->window_size.height();
   if (!params || !params->GetString("url", &url))
     return CreateInvalidParamResponse(command_id, "url");
@@ skipping 86 matching lines @@
 
   std::unique_ptr<base::Value> result(
       target::DisposeBrowserContextResult::Builder()
           .SetSuccess(success)
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
 }  // namespace headless