Move metafile printing code from platform canvas to PaintCanvas

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 "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_record.h"
+#include "cc/paint/paint_recorder.h"
 #include "printing/print_settings.h"
 #include "third_party/skia/include/core/SkDocument.h"
-#include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkStream.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 42 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<cc::PaintRecord> 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<cc::PaintRecord> content_;
 };
 
 struct PdfMetafileSkiaData {
-  SkPictureRecorder recorder_;  // Current recording
+  cc::PaintRecorder 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
+  // PaintCanvas::getTotalMatrix() even though the total matrix is not as
   // meaningful for a vector canvas as for a raster canvas.
   float scale_factor_;
   SkSize size_;
   SkiaDocumentType type_;
 
 #if defined(OS_MACOSX)
   PdfMetafileCg pdf_cg_;
 #endif
 };
 
@@ skipping 17 matching lines @@
                                 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());
 
   float inverse_scale = 1.0 / scale_factor;
-  SkCanvas* canvas = data_->recorder_.beginRecording(
+  cc::PaintCanvas* canvas = data_->recorder_.beginRecording(
       inverse_scale * page_size.width(), inverse_scale * page_size.height());
   // Recording canvas is owned by the data_->recorder_.  No ref() necessary.
   if (content_area != gfx::Rect(page_size)) {
     canvas->scale(inverse_scale, inverse_scale);
     SkRect sk_content_area = gfx::RectToSkRect(content_area);
     canvas->clipRect(sk_content_area);
     canvas->translate(sk_content_area.x(), sk_content_area.y());
     canvas->scale(scale_factor, scale_factor);
   }
 
   data_->size_ = gfx::SizeFToSkSize(gfx::SizeF(page_size));
   data_->scale_factor_ = scale_factor;
   // We scale the recording canvas's size so that
   // canvas->getTotalMatrix() returns a value that ignores the scale
   // factor.  We store the scale factor and re-apply it later.
   // http://crbug.com/469656
 }
 
-SkCanvas* PdfMetafileSkia::GetVectorCanvasForNewPage(
+cc::PaintCanvas* PdfMetafileSkia::GetVectorCanvasForNewPage(
     const gfx::Size& page_size,
     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<cc::PaintRecord> pic = data_->recorder_.finishRecordingAsPicture();
   if (data_->scale_factor_ != 1.0f) {
-    SkCanvas* canvas = data_->recorder_.beginRecording(data_->size_.width(),
-                                                       data_->size_.height());
+    cc::PaintCanvas* 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();
   }
   data_->pages_.emplace_back(data_->size_, std::move(pic));
   return true;
 }
 
 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());
+    cc::PaintCanvas* canvas(
+        doc->beginPage(page.size_.width(), page.size_.height()));
     canvas->drawPicture(page.content_);
     doc->endPage();
   }
   doc->close();
 
   data_->pdf_data_.reset(stream.detachAsStream());
   return true;
 }
 
 uint32_t PdfMetafileSkia::GetDataSize() const {
@@ skipping 90 matching lines @@
 }
 
 PdfMetafileSkia::PdfMetafileSkia(SkiaDocumentType type)
     : data_(new PdfMetafileSkiaData) {
   data_->type_ = type;
 }
 
 std::unique_ptr<PdfMetafileSkia> PdfMetafileSkia::GetMetafileForCurrentPage(
     SkiaDocumentType type) {
   // If we only ever need the metafile for the last page, should we
-  // only keep a handle on one SkPicture?
+  // only keep a handle on one PaintRecord?
   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();
 
   return metafile;
 }
 
 }  // namespace printing