make headless lib complie when enable_basic_printing is set to false

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_print_manager.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";
 
 // JSON RPC 2.0 spec: http://www.jsonrpc.org/specification#error_object
@@ skipping 29 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)
 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));
   } else {
     response = CreateErrorResponse(
         command_id, kErrorServerError,
         printing::HeadlessPrintManager::PrintResultToString(print_result));
   }
   callback.Run(std::move(response));
 }
+#endif
 
 }  // namespace
 
 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));
@@ skipping 78 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) {
+#if !BUILDFLAG(ENABLE_BASIC_PRINTING)

[Lei Zhang, 2017/04/10 17:38:41]

Maybe remove the '!' and swap the two bodies of code?

[jzfeng, 2017/04/10 18:32:27]

Done.

+  DCHECK(callback);
+  callback.Run(CreateErrorResponse(command_id, kErrorServerError,
+                                   "Can't print to pdf. Please set "
+                                   "enable_basic_printing to true in "
+                                   "args.gn"));

[Lei Zhang, 2017/04/10 17:38:41]

Just say something like "printing is not enabled" - end users do not know
anything about Chromium build settings.

[jzfeng, 2017/04/10 18:32:27]

Done.

+#else
   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));
+#endif
 }
 
 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();
@@ skipping 88 matching lines @@
 
   std::unique_ptr<base::Value> result(
       target::DisposeBrowserContextResult::Builder()
           .SetSuccess(success)
           .Build()
           ->Serialize());
   return CreateSuccessResponse(command_id, std::move(result));
 }
 
 }  // namespace headless