Use SkDocument_PDF_None if pdf support is not enabled.

printing/pdf_metafile_skia.cc

 // Copyright (c) 2012 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 "printing/pdf_metafile_skia.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/containers/hash_tables.h"
@@ skipping 47 matching lines @@
                         void* buffer,
                         size_t size) {
   // Calling duplicate() keeps original asset state unchanged.
   scoped_ptr<SkStreamAsset> assetCopy(asset->duplicate());
   size_t length = assetCopy->getLength();
   if (length > size)
     return false;
   return (length == assetCopy->read(buffer, length));
 }
 
+#if defined(ENABLE_PRINTING) && ENABLE_PRINTING

[slan, 2016/03/28 20:03:44]

Just:

#if defined(ENABLE_PRINTING)

here and below.

[mbjorge, 2016/03/28 20:26:52]

Done

 SkTime::DateTime TimeToSkTime(base::Time time) {
     base::Time::Exploded exploded;
     time.UTCExplode(&exploded);
     SkTime::DateTime skdate;
     skdate.fTimeZoneMinutes = 0;
     skdate.fYear = exploded.year;
     skdate.fMonth = exploded.month;
     skdate.fDayOfWeek = exploded.day_of_week;
     skdate.fDay = exploded.day_of_month;
     skdate.fHour = exploded.hour;
     skdate.fMinute = exploded.minute;
     skdate.fSecond = exploded.second;
     return skdate;
 }
+#endif  // defined(ENABLE_PRINTING) && ENABLE_PRINTING
 
 }  // namespace
 
 namespace printing {
 
 struct PdfMetafileSkiaData {
   SkPictureRecorder recorder_;  // Current recording
 
   std::vector<Page> pages_;
   scoped_ptr<SkStreamAsset> pdf_data_;
@@ skipping 57 matching lines @@
 }
 
 bool PdfMetafileSkia::FinishDocument() {
   // If we've already set the data in InitFromData, leave it be.
   if (data_->pdf_data_)
     return false;
 
   if (data_->recorder_.getRecordingCanvas())
     FinishPage();
 
+#if defined(ENABLE_PRINTING) && ENABLE_PRINTING
   SkDynamicMemoryWStream pdf_stream;
   skia::RefPtr<SkDocument> pdf_doc =
       skia::AdoptRef(SkDocument::CreatePDF(&pdf_stream));
   const std::string& user_agent = GetAgent();
   SkDocument::Attribute info[] = {
       SkDocument::Attribute(SkString("Creator"),
                             user_agent.empty()
                             ? SkString("Chromium")
                             : SkString(user_agent.c_str(), user_agent.size())),
   };
   SkTime::DateTime now = TimeToSkTime(base::Time::Now());
   pdf_doc->setMetadata(info, SK_ARRAY_COUNT(info), &now, &now);
   for (const auto& page : data_->pages_) {
     SkCanvas* canvas = pdf_doc->beginPage(
         page.page_size_.width(), page.page_size_.height(), &page.content_area_);
     // No need to save/restore, since this canvas is not reused after endPage()
     canvas->scale(page.scale_factor_, page.scale_factor_);
     canvas->drawPicture(page.content_);
     pdf_doc->endPage();
   }
   if (!pdf_doc->close())
     return false;
 
   data_->pdf_data_.reset(pdf_stream.detachAsStream());
   return true;
+#else
+// On platforms without printing enabled, SkDocument::CreatePDF does not exist,
+// so just return false.
+  return false;
+#endif  // !defined(ENABLE_PRINTING || !ENABLE_PRINTING
 }
 
 uint32_t PdfMetafileSkia::GetDataSize() const {
   if (!data_->pdf_data_)
     return 0;
   return base::checked_cast<uint32_t>(data_->pdf_data_->getLength());
 }
 
 bool PdfMetafileSkia::GetData(void* dst_buffer,
                               uint32_t dst_buffer_size) const {
@@ skipping 117 matching lines @@
 
   metafile->data_->pages_.push_back(page);
 
   if (!metafile->FinishDocument())  // Generate PDF.
     metafile.reset();
 
   return metafile;
 }
 
 }  // namespace printing