[Experimental] Supporting OOPIF printing

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 <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "printing/print_settings.h"
+#include "skia/ext/skia_utils_base.h"
 #include "third_party/skia/include/core/SkDocument.h"
+#include "third_party/skia/include/core/SkImageDeserializer.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkStream.h"
+//#include "third_party/skia/include/core/SkWriteBuffer.h"
 // Note that headers in third_party/skia/src are fragile.  This is
 // an experimental, fragile, and diagnostic-only document type.
 #include "third_party/skia/src/utils/SkMultiPictureDocument.h"
 #include "ui/gfx/geometry/safe_integer_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 #if defined(OS_MACOSX)
 #include "printing/pdf_metafile_cg_mac.h"
 #endif
 
@@ skipping 41 matching lines @@
                                     : SkString(agent.c_str(), agent.size());
   return SkDocument::MakePDF(wStream, SK_ScalarDefaultRasterDPI, metadata,
                              nullptr, false);
 }
 
 }  // namespace
 
 namespace printing {
 
 struct Page {
-  Page(SkSize s, sk_sp<SkPicture> c) : size_(s), content_(std::move(c)) {}
+  Page(SkSize s, sk_sp<SkDrawable> c) : size_(s), content_(std::move(c)) {}
   Page(Page&& that) : size_(that.size_), content_(std::move(that.content_)) {}
   Page(const Page&) = default;
   Page& operator=(const Page&) = default;
   Page& operator=(Page&& that) {
     size_ = that.size_;
     content_ = std::move(that.content_);
     return *this;
   }
   SkSize size_;
-  sk_sp<SkPicture> content_;
+  sk_sp<SkDrawable> content_;
 };
 
 struct PdfMetafileSkiaData {
   SkPictureRecorder recorder_;  // Current recording
 
   std::vector<Page> pages_;
   std::unique_ptr<SkStreamAsset> pdf_data_;
 
   // The scale factor is used because Blink occasionally calls
   // SkCanvas::getTotalMatrix() even though the total matrix is not as
@@ skipping 16 matching lines @@
 // TODO(halcanary): Create a Metafile class that only stores data.
 // Metafile::InitFromData is orthogonal to what the rest of
 // PdfMetafileSkia does.
 bool PdfMetafileSkia::InitFromData(const void* src_buffer,
                                    size_t src_buffer_size) {
   data_->pdf_data_ = base::MakeUnique<SkMemoryStream>(
       src_buffer, src_buffer_size, true /* copy_data? */);
   return true;
 }
 
+bool PdfMetafileSkia::InitFromPageDataBuffer(const char* src_buffer,
+                                             size_t src_buffer_size) {
+  size_t pos = 0;
+  while (pos < src_buffer_size) {
+    size_t size = *((size_t*)(src_buffer + pos));
+    pos += sizeof(size_t);
+    if (pos + size + 2 * sizeof(SkScalar) > src_buffer_size) {
+      return false;
+    }
+    SkScalar width = *((SkScalar*)(src_buffer + pos));
+    pos += sizeof(SkScalar);
+    SkScalar height = *((SkScalar*)(src_buffer + pos));
+    pos += sizeof(SkScalar);
+
+    std::unique_ptr<SkDrawable> d = skia::ReadDrawable(src_buffer + pos, size);
+
+    data_->pages_.emplace_back(SkSize::Make(width, height),
+                               sk_sp<SkDrawable>(d.release()));
+    pos += size;
+  }
+  return true;
+}
+
 void PdfMetafileSkia::StartPage(const gfx::Size& page_size,
                                 const gfx::Rect& content_area,
                                 const float& scale_factor) {
   DCHECK_GT(page_size.width(), 0);
   DCHECK_GT(page_size.height(), 0);
   DCHECK_GT(scale_factor, 0.0f);
   if (data_->recorder_.getRecordingCanvas())
     FinishPage();
   DCHECK(!data_->recorder_.getRecordingCanvas());
 
@@ skipping 22 matching lines @@
     const gfx::Rect& content_area,
     const float& scale_factor) {
   StartPage(page_size, content_area, scale_factor);
   return data_->recorder_.getRecordingCanvas();
 }
 
 bool PdfMetafileSkia::FinishPage() {
   if (!data_->recorder_.getRecordingCanvas())
     return false;
 
-  sk_sp<SkPicture> pic = data_->recorder_.finishRecordingAsPicture();
+  sk_sp<SkDrawable> pic = data_->recorder_.finishRecordingAsDrawable();
   if (data_->scale_factor_ != 1.0f) {
     SkCanvas* canvas = data_->recorder_.beginRecording(data_->size_.width(),
                                                        data_->size_.height());
     canvas->scale(data_->scale_factor_, data_->scale_factor_);
-    canvas->drawPicture(pic);
-    pic = data_->recorder_.finishRecordingAsPicture();
+    canvas->drawDrawable(pic.get());
+    pic = data_->recorder_.finishRecordingAsDrawable();
   }
-  data_->pages_.emplace_back(data_->size_, std::move(pic));
+  data_->pages_.emplace_back(data_->size_, pic);
   return true;
 }
 
+void PdfMetafileSkia::FinishAllPages() {
+  // If we've already set the data in InitFromData, leave it be.
+  if (data_->pdf_data_) {
+    return;
+  }
+
+  if (data_->recorder_.getRecordingCanvas()) {
+    FinishPage();
+  }
+}
+
 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();
 
   SkDynamicMemoryWStream stream;
   sk_sp<SkDocument> doc;
   switch (data_->type_) {
     case PDF_SKIA_DOCUMENT_TYPE:
       doc = MakePdfDocument(&stream);
       break;
     case MSKP_SKIA_DOCUMENT_TYPE:
       doc = SkMakeMultiPictureDocument(&stream);
       break;
   }
 
   for (const Page& page : data_->pages_) {
     SkCanvas* canvas = doc->beginPage(page.size_.width(), page.size_.height());
-    canvas->drawPicture(page.content_);
+    canvas->drawDrawable(page.content_.get());
     doc->endPage();
   }
   doc->close();
 
   data_->pdf_data_.reset(stream.detachAsStream());
   return true;
 }
 
+std::unique_ptr<char[]> PdfMetafileSkia::GetPageDataBuffer(size_t* size) const {
+  struct PageInfo {
+    PageInfo(SkScalar w, SkScalar h, std::vector<char> d)
+        : width(w), height(h), data(std::move(d)) {}
+    SkScalar width;
+    SkScalar height;
+    std::vector<char> data;
+  };
+  std::vector<PageInfo> serialized_pages;
+  size_t total_buf_size = 0;
+  for (size_t i = 0; i < data_->pages_.size(); ++i) {
+    // Flatten each page into buffer.
+    std::vector<char> flattened =
+        skia::WriteDrawable(data_->pages_[i].content_.get());
+    if (!flattened.size() || !flattened.data()) {
+      continue;
+    }
+    total_buf_size += sizeof(size_t) + sizeof(SkScalar) * 2 + flattened.size();
+    serialized_pages.emplace_back(data_->pages_[i].size_.width(),
+                                  data_->pages_[i].size_.height(),
+                                  std::move(flattened));
+  }
+  if (!total_buf_size) {
+    *size = 0;
+    return nullptr;
+  }
+  std::unique_ptr<char[]> buf(new char[total_buf_size]);
+  char* buf_pos = buf.get();
+  for (size_t i = 0; i < serialized_pages.size(); ++i) {
+    size_t size = serialized_pages[i].data.size();
+    memcpy(buf_pos, &size, sizeof(size_t));
+    buf_pos += sizeof(size_t);
+    memcpy(buf_pos, &serialized_pages[i].width, sizeof(SkScalar));
+    buf_pos += sizeof(SkScalar);
+    memcpy(buf_pos, &serialized_pages[i].height, sizeof(SkScalar));
+    buf_pos += sizeof(SkScalar);
+    memcpy(buf_pos, serialized_pages[i].data.data(), size);
+    buf_pos += size;
+  }
+  *size = total_buf_size;
+  return buf;
+}
+
+void PdfMetafileSkia::GetSkp(SkWStream* stream) const {
+  if (data_->pages_.size() >= 1)
+    data_->pages_[0].content_->newPictureSnapshot()->serialize(stream);
+}
+
+void PdfMetafileSkia::ConvertPagesToPdf() {
+  SkDynamicMemoryWStream stream;
+  sk_sp<SkDocument> doc = MakePdfDocument(&stream);
+
+  for (const Page& page : data_->pages_) {
+    SkCanvas* canvas = doc->beginPage(page.size_.width(), page.size_.height());
+    canvas->drawPicture(page.content_->newPictureSnapshot());
+    doc->endPage();
+  }
+  doc->close();
+
+  data_->pdf_data_.reset(stream.detachAsStream());
+}
+
 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 {
   if (!data_->pdf_data_)
     return false;
@@ skipping 92 matching lines @@
   std::unique_ptr<PdfMetafileSkia> metafile(new PdfMetafileSkia(type));
 
   if (data_->pages_.size() == 0)
     return metafile;
 
   if (data_->recorder_.getRecordingCanvas())  // page outstanding
     return metafile;
 
   metafile->data_->pages_.push_back(data_->pages_.back());
 
-  if (!metafile->FinishDocument())  // Generate PDF.
-    metafile.reset();
+  // if (!metafile->FinishDocument())  // Generate PDF.
+  // metafile.reset();
 
   return metafile;
 }
 
 }  // namespace printing