PrintPreview: Implement GetMetafileForCurrentPage() function in PdfMetafileSkia.

printing/pdf_metafile_skia.cc

 // Copyright (c) 2011 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 "base/eintr_wrapper.h"
 #include "base/file_descriptor_posix.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
@@ skipping 33 matching lines @@
   return true;
 }
 bool PdfMetafileSkia::InitFromData(const void* src_buffer,
                                    uint32 src_buffer_size) {
   return data_->pdf_stream_.write(src_buffer, src_buffer_size);
 }
 
 SkDevice* PdfMetafileSkia::StartPageForVectorCanvas(
     const gfx::Size& page_size, const gfx::Rect& content_area,
     const float& scale_factor) {
-  DCHECK(data_->current_page_.get() == NULL);
+  DCHECK (!page_outstanding_);
+  page_outstanding_ = true;
 
   // Adjust for the margins and apply the scale factor.
   SkMatrix transform;
   transform.setTranslate(SkIntToScalar(content_area.x()),
                          SkIntToScalar(content_area.y()));
   transform.preScale(SkFloatToScalar(scale_factor),
                      SkFloatToScalar(scale_factor));
 
   // TODO(ctguil): Refactor: don't create the PDF device explicitly here.
   SkISize pdf_page_size = SkISize::Make(page_size.width(), page_size.height());
@@ skipping 12 matching lines @@
                                 const gfx::Rect& content_area,
                                 const float& scale_factor) {
   NOTREACHED();
   return NULL;
 }
 
 bool PdfMetafileSkia::FinishPage() {
   DCHECK(data_->current_page_.get());
 
   data_->pdf_doc_.appendPage(data_->current_page_);
-  data_->current_page_ = NULL;
+  page_outstanding_ = false;
   return true;
 }
 
 bool PdfMetafileSkia::FinishDocument() {
   // Don't do anything if we've already set the data in InitFromData.
   if (data_->pdf_stream_.getOffset())
     return true;
 
-  if (data_->current_page_.get())
+  if (page_outstanding_)
     FinishPage();
 
+  data_->current_page_ = NULL;
   base::hash_set<SkFontID> font_set;
 
   const SkTDArray<SkPDFPage*>& pages = data_->pdf_doc_.getPages();
   for (int page_number = 0; page_number < pages.count(); page_number++) {
     const SkTDArray<SkPDFFont*>& font_resources =
         pages[page_number]->getFontResources();
     for (int font = 0; font < font_resources.count(); font++) {
       SkFontID font_id = font_resources[font]->typeface()->uniqueID();
       if (font_set.find(font_id) == font_set.end()) {
         font_set.insert(font_id);
@@ skipping 118 matching lines @@
       DPLOG(WARNING) << "close";
       result = false;
     }
   }
   return result;
 }
 #endif
 
 PdfMetafileSkia::PdfMetafileSkia()
     : data_(new PdfMetafileSkiaData),
-      draft_(false) {}
+      draft_(false),
+      page_outstanding_(false) {}
+
+PdfMetafileSkia* PdfMetafileSkia::GetMetafileForCurrentPage() {
+  SkPDFDocument pdf_doc;
+  SkDynamicMemoryWStream pdf_stream;
+  if (!pdf_doc.appendPage(data_->current_page_))
+    return NULL;
+
+  if (!pdf_doc.emitPDF(&pdf_stream))
+    return NULL;
+
+  SkAutoDataUnref data(pdf_stream.copyToData());
+  if (data.size() == 0)
+    return NULL;
+
+  PdfMetafileSkia* metafile = new printing::PdfMetafileSkia;
+  metafile->InitFromData(data.bytes(), data.size());
+  return metafile;
+}
 
 }  // namespace printing