printing/pdf_metafile_skia.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "printing/pdf_metafile_skia.h"
   6
   7 #include "base/containers/hash_tables.h"
   8 #include "base/files/file_util.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/numerics/safe_conversions.h"
  11 #include "base/posix/eintr_wrapper.h"
  12 #include "skia/ext/refptr.h"
  13 #include "skia/ext/vector_platform_device_skia.h"
  14 #include "third_party/skia/include/core/SkData.h"
  15 #include "third_party/skia/include/core/SkRefCnt.h"
  16 #include "third_party/skia/include/core/SkScalar.h"
  17 #include "third_party/skia/include/core/SkStream.h"
  18 #include "third_party/skia/include/core/SkTypeface.h"
  19 #include "third_party/skia/include/pdf/SkPDFDevice.h"
  20 #include "third_party/skia/include/pdf/SkPDFDocument.h"
  21 #include "ui/gfx/point.h"
  22 #include "ui/gfx/rect.h"
  23 #include "ui/gfx/size.h"
  24
  25 #if defined(OS_MACOSX)
  26 #include "printing/pdf_metafile_cg_mac.h"
  27 #endif
  28
  29 #if defined(OS_POSIX)
  30 #include "base/file_descriptor_posix.h"
  31 #endif
  32
  33 namespace printing {
  34
  35 struct PdfMetafileSkiaData {
  36   skia::RefPtr<SkPDFDevice> current_page_;
  37   SkPDFDocument pdf_doc_;
  38   SkDynamicMemoryWStream pdf_stream_;
  39 #if defined(OS_MACOSX)
  40   PdfMetafileCg pdf_cg_;
  41 #endif
  42 };
  43
  44 PdfMetafileSkia::~PdfMetafileSkia() {}
  45
  46 bool PdfMetafileSkia::Init() {
  47   return true;
  48 }
  49 bool PdfMetafileSkia::InitFromData(const void* src_buffer,
  50                                    uint32 src_buffer_size) {
  51   return data_->pdf_stream_.write(src_buffer, src_buffer_size);
  52 }
  53
  54 SkBaseDevice* PdfMetafileSkia::StartPageForVectorCanvas(
  55     const gfx::Size& page_size, const gfx::Rect& content_area,
  56     const float& scale_factor) {
  57   DCHECK(!page_outstanding_);
  58   page_outstanding_ = true;
  59
  60   // Adjust for the margins and apply the scale factor.
  61   SkMatrix transform;
  62   transform.setTranslate(SkIntToScalar(content_area.x()),
  63                          SkIntToScalar(content_area.y()));
  64   transform.preScale(SkFloatToScalar(scale_factor),
  65                      SkFloatToScalar(scale_factor));
  66
  67   SkISize pdf_page_size = SkISize::Make(page_size.width(), page_size.height());
  68   SkISize pdf_content_size =
  69       SkISize::Make(content_area.width(), content_area.height());
  70   skia::RefPtr<SkPDFDevice> pdf_device =
  71       skia::AdoptRef(new skia::VectorPlatformDeviceSkia(
  72           pdf_page_size, pdf_content_size, transform));
  73   data_->current_page_ = pdf_device;
  74   return pdf_device.get();
  75 }
  76
  77 bool PdfMetafileSkia::StartPage(const gfx::Size& page_size,
  78                                 const gfx::Rect& content_area,
  79                                 const float& scale_factor) {
  80   NOTREACHED();
  81   return false;
  82 }
  83
  84 bool PdfMetafileSkia::FinishPage() {
  85   DCHECK(data_->current_page_.get());
  86
  87   data_->pdf_doc_.appendPage(data_->current_page_.get());
  88   page_outstanding_ = false;
  89   return true;
  90 }
  91
  92 bool PdfMetafileSkia::FinishDocument() {
  93   // Don't do anything if we've already set the data in InitFromData.
  94   if (data_->pdf_stream_.getOffset())
  95     return true;
  96
  97   if (page_outstanding_)
  98     FinishPage();
  99
 100   data_->current_page_.clear();
 101
 102   int font_counts[SkAdvancedTypefaceMetrics::kOther_Font + 2];
 103   data_->pdf_doc_.getCountOfFontTypes(font_counts);
 104   for (int type = 0;
 105        type <= SkAdvancedTypefaceMetrics::kOther_Font + 1;
 106        type++) {
 107     for (int count = 0; count < font_counts[type]; count++) {
 108       UMA_HISTOGRAM_ENUMERATION(
 109           "PrintPreview.FontType", type,
 110           SkAdvancedTypefaceMetrics::kOther_Font + 2);
 111     }
 112   }
 113
 114   return data_->pdf_doc_.emitPDF(&data_->pdf_stream_);
 115 }
 116
 117 uint32 PdfMetafileSkia::GetDataSize() const {
 118   return base::checked_cast<uint32>(data_->pdf_stream_.getOffset());
 119 }
 120
 121 bool PdfMetafileSkia::GetData(void* dst_buffer,
 122                               uint32 dst_buffer_size) const {
 123   if (dst_buffer_size < GetDataSize())
 124     return false;
 125
 126   SkAutoDataUnref data(data_->pdf_stream_.copyToData());
 127   memcpy(dst_buffer, data->bytes(), dst_buffer_size);
 128   return true;
 129 }
 130
 131 gfx::Rect PdfMetafileSkia::GetPageBounds(unsigned int page_number) const {
 132   // TODO(vandebo) add a method to get the page size for a given page to
 133   // SkPDFDocument.
 134   NOTIMPLEMENTED();
 135   return gfx::Rect();
 136 }
 137
 138 unsigned int PdfMetafileSkia::GetPageCount() const {
 139   // TODO(vandebo) add a method to get the number of pages to SkPDFDocument.
 140   NOTIMPLEMENTED();
 141   return 0;
 142 }
 143
 144 gfx::NativeDrawingContext PdfMetafileSkia::context() const {
 145   NOTREACHED();
 146   return NULL;
 147 }
 148
 149 #if defined(OS_WIN)
 150 bool PdfMetafileSkia::Playback(gfx::NativeDrawingContext hdc,
 151                                const RECT* rect) const {
 152   NOTREACHED();
 153   return false;
 154 }
 155
 156 bool PdfMetafileSkia::SafePlayback(gfx::NativeDrawingContext hdc) const {
 157   NOTREACHED();
 158   return false;
 159 }
 160
 161 #elif defined(OS_MACOSX)
 162 /* TODO(caryclark): The set up of PluginInstance::PrintPDFOutput may result in
 163    rasterized output.  Even if that flow uses PdfMetafileCg::RenderPage,
 164    the drawing of the PDF into the canvas may result in a rasterized output.
 165    PDFMetafileSkia::RenderPage should be not implemented as shown and instead
 166    should do something like the following CL in PluginInstance::PrintPDFOutput:
 167 http://codereview.chromium.org/7200040/diff/1/webkit/plugins/ppapi/ppapi_plugin_instance.cc
 168 */
 169 bool PdfMetafileSkia::RenderPage(unsigned int page_number,
 170                                  CGContextRef context,
 171                                  const CGRect rect,
 172                                  const MacRenderPageParams& params) const {
 173   DCHECK_GT(data_->pdf_stream_.getOffset(), 0U);
 174   if (data_->pdf_cg_.GetDataSize() == 0) {
 175     SkAutoDataUnref data(data_->pdf_stream_.copyToData());
 176     data_->pdf_cg_.InitFromData(data->bytes(), data->size());
 177   }
 178   return data_->pdf_cg_.RenderPage(page_number, context, rect, params);
 179 }
 180 #endif
 181
 182 #if defined(OS_CHROMEOS) || defined(OS_ANDROID)
 183 bool PdfMetafileSkia::SaveToFD(const base::FileDescriptor& fd) const {
 184   DCHECK_GT(data_->pdf_stream_.getOffset(), 0U);
 185
 186   if (fd.fd < 0) {
 187     DLOG(ERROR) << "Invalid file descriptor!";
 188     return false;
 189   }
 190   base::File file(fd.fd);
 191   SkAutoDataUnref data(data_->pdf_stream_.copyToData());
 192   bool result =
 193       file.WriteAtCurrentPos(reinterpret_cast<const char*>(data->data()),
 194                              GetDataSize()) == static_cast<int>(GetDataSize());
 195   DLOG_IF(ERROR, !result) << "Failed to save file with fd " << fd.fd;
 196
 197   if (!fd.auto_close)
 198     file.TakePlatformFile();
 199   return result;
 200 }
 201 #endif
 202
 203 PdfMetafileSkia::PdfMetafileSkia()
 204     : data_(new PdfMetafileSkiaData),
 205       page_outstanding_(false) {
 206 }
 207
 208 scoped_ptr<PdfMetafileSkia> PdfMetafileSkia::GetMetafileForCurrentPage() {
 209   scoped_ptr<PdfMetafileSkia> metafile;
 210   SkPDFDocument pdf_doc(SkPDFDocument::kDraftMode_Flags);
 211   if (!pdf_doc.appendPage(data_->current_page_.get()))
 212     return metafile.Pass();
 213
 214   SkDynamicMemoryWStream pdf_stream;
 215   if (!pdf_doc.emitPDF(&pdf_stream))
 216     return metafile.Pass();
 217
 218   SkAutoDataUnref data_copy(pdf_stream.copyToData());
 219   if (data_copy->size() == 0)
 220     return scoped_ptr<PdfMetafileSkia>();
 221
 222   metafile.reset(new PdfMetafileSkia);
 223   if (!metafile->InitFromData(data_copy->bytes(),
 224                               base::checked_cast<uint32>(data_copy->size()))) {
 225     metafile.reset();
 226   }
 227   return metafile.Pass();
 228 }
 229
 230 }  // namespace printing