From d2501577f2df0764eda66614ddf429e230062562 Mon Sep 17 00:00:00 2001
From: enne <enne@chromium.org>
Date: Thu, 9 Mar 2017 11:59:17 -0800
Subject: [PATCH] Make cc/paint have concrete types

This changes PaintCanvas, PaintFlags, PaintSurface, and PaintRecorder
to all be real types (that forward to Skia types internally).  PaintShader
is left as-is for now.  This will force callers to use the correct
types in the rest of Chromium as the internals of these classes are
rewritten in future patches.

This code also changes a number of callers elsewhere in the codebase
that want to wrap an SkCanvas in a PaintCanvas.  As SkCanvas has no
constructor that takes an SkCanvas*, this change had to wait for this
final conversion patch.

In general, if code wants to raster directly into a bitmap with local
code, it should use Skia directly.  If code wants to raster into a bitmap
with paint callers, it can wrap that bitmap in a PaintCanvas.  Similarly,
if code wants to go into an accelerated SkSurface, it should wrap that
surface's canvas in a PaintCanvas (as blink html canvas code does).

BUG=671433

CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_trusty_blink_rel;master.tryserver.chromium.linux:linux_layout_tests_slimming_paint_v2

Review-Url: https://codereview.chromium.org/2690583002
Cr-Commit-Position: refs/heads/master@{#455840}
---
 ash/common/shelf/overflow_button.cc           |   2 +-
 ash/common/shelf/shelf_button.cc              |   4 +-
 cc/layers/painted_overlay_scrollbar_layer.cc  |  14 +-
 cc/paint/BUILD.gn                             |   9 +-
 cc/paint/paint_canvas.cc                      |  44 +-
 cc/paint/paint_canvas.h                       | 434 +++++++++++++++++-
 cc/paint/paint_flags.h                        | 204 +++++++-
 cc/paint/paint_recorder.cc                    |  12 +
 cc/paint/paint_recorder.h                     |  61 ++-
 cc/paint/paint_shader.h                       |   3 +-
 cc/paint/paint_surface.cc                     |  14 +
 cc/paint/paint_surface.h                      |  49 +-
 .../child/browser_font_resource_trusted.cc    |   9 +-
 .../gpu/gpu_benchmarking_extension.cc         |   2 +-
 .../skcanvas_video_renderer_unittest.cc       |   8 +-
 printing/pdf_metafile_skia.cc                 |   4 +-
 .../compositing/CompositedLayerMapping.cpp    |   2 +-
 .../compositing/PaintLayerCompositor.cpp      |   2 +-
 .../Source/core/paint/SVGShapePainter.cpp     |   2 +-
 .../Source/core/svg/graphics/SVGImageTest.cpp |   2 +-
 .../Source/platform/exported/WebFont.cpp      |   2 +-
 .../exported/WebScrollbarThemePainter.cpp     |  20 +-
 .../platform/graphics/Canvas2DLayerBridge.cpp |  71 +--
 .../platform/graphics/Canvas2DLayerBridge.h   |   7 +-
 .../graphics/DeferredImageDecoderTest.cpp     |  10 +-
 .../platform/graphics/GraphicsContext.cpp     |  20 +-
 .../graphics/RecordingImageBufferSurface.cpp  |   4 +-
 .../UnacceleratedImageBufferSurface.cpp       |  20 +-
 .../UnacceleratedImageBufferSurface.h         |   4 +-
 .../gpu/AcceleratedImageBufferSurface.cpp     |   8 +-
 .../gpu/AcceleratedImageBufferSurface.h       |   7 +-
 .../platform/graphics/paint/PaintCanvas.h     |   1 -
 .../WebKit/Source/web/PageWidgetDelegate.cpp  |   3 +-
 .../WebKit/Source/web/WebLocalFrameImpl.cpp   |   4 +-
 ui/gfx/paint_vector_icon_unittest.cc          |  11 +-
 35 files changed, 931 insertions(+), 142 deletions(-)
 create mode 100644 cc/paint/paint_recorder.cc
 create mode 100644 cc/paint/paint_surface.cc

diff --git a/ash/common/shelf/overflow_button.cc b/ash/common/shelf/overflow_button.cc
index ccb585c6cc785a..b254012be91dc3 100644
--- a/ash/common/shelf/overflow_button.cc
+++ b/ash/common/shelf/overflow_button.cc
@@ -100,7 +100,7 @@ std::unique_ptr<views::InkDropMask> OverflowButton::CreateInkDropMask() const {
 void OverflowButton::PaintBackground(gfx::Canvas* canvas,
                                      const gfx::Rect& bounds) {
   cc::PaintFlags flags;
-  flags.setFlags(cc::PaintFlags::kAntiAlias_Flag);
+  flags.setAntiAlias(true);
   flags.setColor(background_color_);
   canvas->DrawRoundRect(bounds, kOverflowButtonCornerRadius, flags);
 }
diff --git a/ash/common/shelf/shelf_button.cc b/ash/common/shelf/shelf_button.cc
index d5d32ff71833d2..e77571e1e77cf2 100644
--- a/ash/common/shelf/shelf_button.cc
+++ b/ash/common/shelf/shelf_button.cc
@@ -154,13 +154,13 @@ class ShelfButton::AppStatusIndicatorView
     // Fill the center.
     cc::PaintFlags flags;
     flags.setColor(kIndicatorColor);
-    flags.setFlags(cc::PaintFlags::kAntiAlias_Flag);
+    flags.setAntiAlias(true);
     canvas->DrawCircle(center, dsf * kIndicatorRadiusDip - kStrokeWidthPx,
                        flags);
 
     // Stroke the border.
     flags.setColor(SkColorSetA(SK_ColorBLACK, 0x4D));
-    flags.setStyle(SkPaint::kStroke_Style);
+    flags.setStyle(cc::PaintFlags::kStroke_Style);
     canvas->DrawCircle(
         center, dsf * kIndicatorRadiusDip - kStrokeWidthPx / 2.0f, flags);
   }
diff --git a/cc/layers/painted_overlay_scrollbar_layer.cc b/cc/layers/painted_overlay_scrollbar_layer.cc
index ab8643ecac019f..eea22c63051043 100644
--- a/cc/layers/painted_overlay_scrollbar_layer.cc
+++ b/cc/layers/painted_overlay_scrollbar_layer.cc
@@ -148,16 +148,16 @@ bool PaintedOverlayScrollbarLayer::PaintThumbIfNeeded() {
 
   SkBitmap skbitmap;
   skbitmap.allocN32Pixels(paint_rect.width(), paint_rect.height());
-  SkCanvas skcanvas(skbitmap);
+  PaintCanvas canvas(skbitmap);
 
   SkRect content_skrect = RectToSkRect(paint_rect);
-  SkPaint paint;
-  paint.setAntiAlias(false);
-  paint.setBlendMode(SkBlendMode::kClear);
-  skcanvas.drawRect(content_skrect, paint);
-  skcanvas.clipRect(content_skrect);
+  PaintFlags flags;
+  flags.setAntiAlias(false);
+  flags.setBlendMode(SkBlendMode::kClear);
+  canvas.drawRect(content_skrect, flags);
+  canvas.clipRect(content_skrect);
 
-  scrollbar_->PaintPart(&skcanvas, THUMB, paint_rect);
+  scrollbar_->PaintPart(&canvas, THUMB, paint_rect);
   // Make sure that the pixels are no longer mutable to unavoid unnecessary
   // allocation and copying.
   skbitmap.setImmutable();
diff --git a/cc/paint/BUILD.gn b/cc/paint/BUILD.gn
index a37d4a6dae577f..58cdaf410505e7 100644
--- a/cc/paint/BUILD.gn
+++ b/cc/paint/BUILD.gn
@@ -12,16 +12,23 @@ cc_component("paint") {
     "paint_export.h",
     "paint_flags.h",
     "paint_record.h",
+    "paint_recorder.cc",
     "paint_recorder.h",
     "paint_shader.h",
+    "paint_surface.cc",
     "paint_surface.h",
   ]
 
   defines = [ "CC_PAINT_IMPLEMENTATION=1" ]
 
   # cc/paint is intended to be a separate component from cc that can be
-  # included in Blink.  This component should never include //base.
+  # included in Blink.  This component should never publicly include
+  # anything that Blink core wouldn't include (e.g. base).
   public_deps = [
     "//skia",
   ]
+
+  deps = [
+    "//base",
+  ]
 }
diff --git a/cc/paint/paint_canvas.cc b/cc/paint/paint_canvas.cc
index 53dab8fb45b7af..d3a8b57183aaa1 100644
--- a/cc/paint/paint_canvas.cc
+++ b/cc/paint/paint_canvas.cc
@@ -4,7 +4,12 @@
 
 #include "cc/paint/paint_canvas.h"
 
+#include "base/memory/ptr_util.h"
+#include "cc/paint/paint_record.h"
+#include "cc/paint/paint_recorder.h"
+#include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkMetaData.h"
+#include "third_party/skia/include/utils/SkNWayCanvas.h"
 
 #if defined(OS_MACOSX)
 namespace {
@@ -14,25 +19,20 @@ const char kIsPreviewMetafileKey[] = "CrIsPreviewMetafile";
 
 namespace cc {
 
-PaintCanvasPassThrough::PaintCanvasPassThrough(SkCanvas* canvas)
-    : SkNWayCanvas(canvas->getBaseLayerSize().width(),
-                   canvas->getBaseLayerSize().height()) {
-  SkIRect raster_bounds;
-  canvas->getDeviceClipBounds(&raster_bounds);
-  clipRect(SkRect::MakeFromIRect(raster_bounds));
-  setMatrix(canvas->getTotalMatrix());
-  addCanvas(canvas);
-}
+PaintCanvas::PaintCanvas(SkCanvas* canvas) : canvas_(canvas) {}
+
+PaintCanvas::PaintCanvas(const SkBitmap& bitmap)
+    : canvas_(new SkCanvas(bitmap)), owned_(canvas_) {}
 
-PaintCanvasPassThrough::PaintCanvasPassThrough(int width, int height)
-    : SkNWayCanvas(width, height) {}
+PaintCanvas::PaintCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props)
+    : canvas_(new SkCanvas(bitmap, props)), owned_(canvas_) {}
 
-PaintCanvasPassThrough::~PaintCanvasPassThrough() = default;
+PaintCanvas::~PaintCanvas() = default;
 
 bool ToPixmap(PaintCanvas* canvas, SkPixmap* output) {
   SkImageInfo info;
   size_t row_bytes;
-  void* pixels = canvas->accessTopLayerPixels(&info, &row_bytes);
+  void* pixels = canvas->canvas_->accessTopLayerPixels(&info, &row_bytes);
   if (!pixels) {
     output->reset();
     return false;
@@ -57,4 +57,22 @@ bool IsPreviewMetafile(PaintCanvas* canvas) {
 }
 #endif
 
+void PaintCanvasAnnotateRectWithURL(PaintCanvas* canvas,
+                                    const SkRect& rect,
+                                    SkData* data) {
+  SkAnnotateRectWithURL(canvas->canvas_, rect, data);
+}
+
+void PaintCanvasAnnotateNamedDestination(PaintCanvas* canvas,
+                                         const SkPoint& point,
+                                         SkData* data) {
+  SkAnnotateNamedDestination(canvas->canvas_, point, data);
+}
+
+void PaintCanvasAnnotateLinkToDestination(PaintCanvas* canvas,
+                                          const SkRect& rect,
+                                          SkData* data) {
+  SkAnnotateLinkToDestination(canvas->canvas_, rect, data);
+}
+
 }  // namespace cc
diff --git a/cc/paint/paint_canvas.h b/cc/paint/paint_canvas.h
index 649096cf8ea9b8..f4379bcb580774 100644
--- a/cc/paint/paint_canvas.h
+++ b/cc/paint/paint_canvas.h
@@ -5,26 +5,430 @@
 #ifndef CC_PAINT_PAINT_CANVAS_H_
 #define CC_PAINT_PAINT_CANVAS_H_
 
+#include <memory>
+
+#include "base/compiler_specific.h"
+#include "base/logging.h"
+#include "base/macros.h"
 #include "build/build_config.h"
 #include "cc/paint/paint_export.h"
+#include "cc/paint/paint_flags.h"
+#include "cc/paint/paint_record.h"
 #include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/utils/SkNWayCanvas.h"
 #include "third_party/skia/include/utils/SkNoDrawCanvas.h"
 
 namespace cc {
 
-using PaintCanvas = SkCanvas;
-using PaintCanvasNoDraw = SkNoDrawCanvas;
-using PaintCanvasAutoRestore = SkAutoCanvasRestore;
+class PaintFlags;
 
-class CC_PAINT_EXPORT PaintCanvasPassThrough : public SkNWayCanvas {
+class CC_PAINT_EXPORT PaintCanvas {
  public:
-  explicit PaintCanvasPassThrough(SkCanvas* canvas);
-  PaintCanvasPassThrough(int width, int height);
-  ~PaintCanvasPassThrough() override;
+  // TODO(enne): remove all constructors but the one that takes an SkCanvas
+  // and a future one that will take a PaintOpBuffer to build a PaintRecord.
+  explicit PaintCanvas(SkCanvas* canvas);
+  explicit PaintCanvas(const SkBitmap& bitmap);
+  explicit PaintCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props);
+  ~PaintCanvas();
+
+  ALWAYS_INLINE SkMetaData& getMetaData() { return canvas_->getMetaData(); }
+  ALWAYS_INLINE SkImageInfo imageInfo() const { return canvas_->imageInfo(); }
+  ALWAYS_INLINE bool getProps(SkSurfaceProps* props) const {
+    return canvas_->getProps(props);
+  }
+  // TODO(enne): It would be nice to get rid of flush() entirely, as it
+  // doesn't really make sense for recording.  However, this gets used by
+  // SkCanvasVideoRenderer which takes a PaintCanvas to paint both
+  // software and hardware video.  This is super entangled with ImageBuffer
+  // and canvas/video painting in Blink where the same paths are used for
+  // both recording and gpu work.
+  ALWAYS_INLINE void flush() { canvas_->flush(); }
+
+  ALWAYS_INLINE SkISize getBaseLayerSize() const {
+    return canvas_->getBaseLayerSize();
+  }
+  ALWAYS_INLINE bool peekPixels(SkPixmap* pixmap) {
+    return canvas_->peekPixels(pixmap);
+  }
+  ALWAYS_INLINE bool readPixels(const SkImageInfo& dest_info,
+                                void* dest_pixels,
+                                size_t dest_row_bytes,
+                                int src_x,
+                                int src_y) {
+    return canvas_->readPixels(dest_info, dest_pixels, dest_row_bytes, src_x,
+                               src_y);
+  }
+  ALWAYS_INLINE bool readPixels(SkBitmap* bitmap, int src_x, int src_y) {
+    return canvas_->readPixels(bitmap, src_x, src_y);
+  }
+  ALWAYS_INLINE bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
+    return canvas_->readPixels(srcRect, bitmap);
+  }
+  ALWAYS_INLINE bool writePixels(const SkImageInfo& info,
+                                 const void* pixels,
+                                 size_t row_bytes,
+                                 int x,
+                                 int y) {
+    return canvas_->writePixels(info, pixels, row_bytes, x, y);
+  }
+  ALWAYS_INLINE int save() { return canvas_->save(); }
+  ALWAYS_INLINE int saveLayer(const SkRect* bounds, const PaintFlags* flags) {
+    return canvas_->saveLayer(bounds, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE int saveLayer(const SkRect& bounds, const PaintFlags* flags) {
+    return canvas_->saveLayer(bounds, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE int saveLayerPreserveLCDTextRequests(const SkRect* bounds,
+                                                     const PaintFlags* flags) {
+    return canvas_->saveLayerPreserveLCDTextRequests(bounds, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE int saveLayerAlpha(const SkRect* bounds, U8CPU alpha) {
+    return canvas_->saveLayerAlpha(bounds, alpha);
+  }
+
+  ALWAYS_INLINE void restore() { canvas_->restore(); }
+  ALWAYS_INLINE int getSaveCount() const { return canvas_->getSaveCount(); }
+  ALWAYS_INLINE void restoreToCount(int save_count) {
+    canvas_->restoreToCount(save_count);
+  }
+  ALWAYS_INLINE void translate(SkScalar dx, SkScalar dy) {
+    canvas_->translate(dx, dy);
+  }
+  ALWAYS_INLINE void scale(SkScalar sx, SkScalar sy) { canvas_->scale(sx, sy); }
+  ALWAYS_INLINE void rotate(SkScalar degrees) { canvas_->rotate(degrees); }
+  ALWAYS_INLINE void rotate(SkScalar degrees, SkScalar px, SkScalar py) {
+    canvas_->rotate(degrees, px, py);
+  }
+  ALWAYS_INLINE void skew(SkScalar sx, SkScalar sy) { canvas_->skew(sx, sy); }
+  ALWAYS_INLINE void concat(const SkMatrix& matrix) { canvas_->concat(matrix); }
+  ALWAYS_INLINE void setMatrix(const SkMatrix& matrix) {
+    canvas_->setMatrix(matrix);
+  }
+  ALWAYS_INLINE void resetMatrix() { canvas_->resetMatrix(); }
+  ALWAYS_INLINE void clipRect(const SkRect& rect,
+                              SkClipOp op,
+                              bool do_anti_alias = false) {
+    canvas_->clipRect(rect, op, do_anti_alias);
+  }
+  ALWAYS_INLINE void clipRect(const SkRect& rect, bool do_anti_alias = false) {
+    canvas_->clipRect(rect, do_anti_alias);
+  }
+  ALWAYS_INLINE void clipRRect(const SkRRect& rrect,
+                               SkClipOp op,
+                               bool do_anti_alias) {
+    canvas_->clipRRect(rrect, op, do_anti_alias);
+  }
+  ALWAYS_INLINE void clipRRect(const SkRRect& rrect, SkClipOp op) {
+    canvas_->clipRRect(rrect, op);
+  }
+  ALWAYS_INLINE void clipRRect(const SkRRect& rrect,
+                               bool do_anti_alias = false) {
+    canvas_->clipRRect(rrect, do_anti_alias);
+  }
+  ALWAYS_INLINE void clipPath(const SkPath& path,
+                              SkClipOp op,
+                              bool do_anti_alias) {
+    canvas_->clipPath(path, op, do_anti_alias);
+  }
+  ALWAYS_INLINE void clipPath(const SkPath& path, SkClipOp op) {
+    canvas_->clipPath(path, op);
+  }
+  ALWAYS_INLINE void clipPath(const SkPath& path, bool do_anti_alias = false) {
+    canvas_->clipPath(path, do_anti_alias);
+  }
+  ALWAYS_INLINE void clipRegion(const SkRegion& device_region,
+                                SkClipOp op = SkClipOp::kIntersect) {
+    canvas_->clipRegion(device_region, op);
+  }
+  ALWAYS_INLINE bool quickReject(const SkRect& rect) const {
+    return canvas_->quickReject(rect);
+  }
+  ALWAYS_INLINE bool quickReject(const SkPath& path) const {
+    return canvas_->quickReject(path);
+  }
+  ALWAYS_INLINE SkRect getLocalClipBounds() const {
+    return canvas_->getLocalClipBounds();
+  }
+  ALWAYS_INLINE bool getLocalClipBounds(SkRect* bounds) const {
+    return canvas_->getLocalClipBounds(bounds);
+  }
+  ALWAYS_INLINE SkIRect getDeviceClipBounds() const {
+    return canvas_->getDeviceClipBounds();
+  }
+  ALWAYS_INLINE bool getDeviceClipBounds(SkIRect* bounds) const {
+    return canvas_->getDeviceClipBounds(bounds);
+  }
+  ALWAYS_INLINE void drawColor(SkColor color,
+                               SkBlendMode mode = SkBlendMode::kSrcOver) {
+    canvas_->drawColor(color, mode);
+  }
+  ALWAYS_INLINE void clear(SkColor color) { canvas_->clear(color); }
+  ALWAYS_INLINE void discard() { canvas_->discard(); }
+
+  ALWAYS_INLINE void drawLine(SkScalar x0,
+                              SkScalar y0,
+                              SkScalar x1,
+                              SkScalar y1,
+                              const PaintFlags& flags) {
+    canvas_->drawLine(x0, y0, x1, y1, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawRect(const SkRect& rect, const PaintFlags& flags) {
+    canvas_->drawRect(rect, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawIRect(const SkIRect& rect, const PaintFlags& flags) {
+    canvas_->drawIRect(rect, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawOval(const SkRect& oval, const PaintFlags& flags) {
+    canvas_->drawOval(oval, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawRRect(const SkRRect& rrect, const PaintFlags& flags) {
+    canvas_->drawRRect(rrect, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawDRRect(const SkRRect& outer,
+                                const SkRRect& inner,
+                                const PaintFlags& flags) {
+    canvas_->drawDRRect(outer, inner, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawCircle(SkScalar cx,
+                                SkScalar cy,
+                                SkScalar radius,
+                                const PaintFlags& flags) {
+    canvas_->drawCircle(cx, cy, radius, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawArc(const SkRect& oval,
+                             SkScalar start_angle,
+                             SkScalar sweep_angle,
+                             bool use_center,
+                             const PaintFlags& flags) {
+    canvas_->drawArc(oval, start_angle, sweep_angle, use_center,
+                     ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawRoundRect(const SkRect& rect,
+                                   SkScalar rx,
+                                   SkScalar ry,
+                                   const PaintFlags& flags) {
+    canvas_->drawRoundRect(rect, rx, ry, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawPath(const SkPath& path, const PaintFlags& flags) {
+    canvas_->drawPath(path, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawImage(const SkImage* image,
+                               SkScalar left,
+                               SkScalar top,
+                               const PaintFlags* flags = nullptr) {
+    canvas_->drawImage(image, left, top, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawImage(const sk_sp<SkImage>& image,
+                               SkScalar left,
+                               SkScalar top,
+                               const PaintFlags* flags = nullptr) {
+    canvas_->drawImage(image, left, top, ToSkPaint(flags));
+  }
+
+  enum SrcRectConstraint {
+    kStrict_SrcRectConstraint = SkCanvas::kStrict_SrcRectConstraint,
+    kFast_SrcRectConstraint = SkCanvas::kFast_SrcRectConstraint,
+  };
+
+  ALWAYS_INLINE void drawImageRect(
+      const SkImage* image,
+      const SkRect& src,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawImageRect(
+        image, src, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+  ALWAYS_INLINE void drawImageRect(
+      const SkImage* image,
+      const SkIRect& isrc,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawImageRect(
+        image, isrc, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+  ALWAYS_INLINE void drawImageRect(
+      const SkImage* image,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawImageRect(
+        image, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+  ALWAYS_INLINE void drawImageRect(
+      const sk_sp<SkImage>& image,
+      const SkRect& src,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawImageRect(
+        image, src, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+  ALWAYS_INLINE void drawImageRect(
+      const sk_sp<SkImage>& image,
+      const SkIRect& isrc,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint cons = kStrict_SrcRectConstraint) {
+    canvas_->drawImageRect(image, isrc, dst, ToSkPaint(flags),
+                           static_cast<SkCanvas::SrcRectConstraint>(cons));
+  }
+  ALWAYS_INLINE void drawImageRect(
+      const sk_sp<SkImage>& image,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint cons = kStrict_SrcRectConstraint) {
+    canvas_->drawImageRect(image, dst, ToSkPaint(flags),
+                           static_cast<SkCanvas::SrcRectConstraint>(cons));
+  }
+  ALWAYS_INLINE void drawBitmap(const SkBitmap& bitmap,
+                                SkScalar left,
+                                SkScalar top,
+                                const PaintFlags* flags = nullptr) {
+    canvas_->drawBitmap(bitmap, left, top, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawBitmapRect(
+      const SkBitmap& bitmap,
+      const SkRect& src,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawBitmapRect(
+        bitmap, src, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+  ALWAYS_INLINE void drawBitmapRect(
+      const SkBitmap& bitmap,
+      const SkIRect& isrc,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawBitmapRect(
+        bitmap, isrc, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+  ALWAYS_INLINE void drawBitmapRect(
+      const SkBitmap& bitmap,
+      const SkRect& dst,
+      const PaintFlags* flags,
+      SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+    canvas_->drawBitmapRect(
+        bitmap, dst, ToSkPaint(flags),
+        static_cast<SkCanvas::SrcRectConstraint>(constraint));
+  }
+
+  ALWAYS_INLINE void drawText(const void* text,
+                              size_t byte_length,
+                              SkScalar x,
+                              SkScalar y,
+                              const PaintFlags& flags) {
+    canvas_->drawText(text, byte_length, x, y, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawPosText(const void* text,
+                                 size_t byte_length,
+                                 const SkPoint pos[],
+                                 const PaintFlags& flags) {
+    canvas_->drawPosText(text, byte_length, pos, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawTextBlob(const SkTextBlob* blob,
+                                  SkScalar x,
+                                  SkScalar y,
+                                  const PaintFlags& flags) {
+    canvas_->drawTextBlob(blob, x, y, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawTextBlob(const sk_sp<SkTextBlob>& blob,
+                                  SkScalar x,
+                                  SkScalar y,
+                                  const PaintFlags& flags) {
+    canvas_->drawTextBlob(blob, x, y, ToSkPaint(flags));
+  }
+
+  ALWAYS_INLINE void drawPicture(const PaintRecord* record) {
+    canvas_->drawPicture(ToSkPicture(record));
+  }
+  ALWAYS_INLINE void drawPicture(const PaintRecord* record,
+                                 const SkMatrix* matrix,
+                                 const PaintFlags* flags) {
+    canvas_->drawPicture(ToSkPicture(record), matrix, ToSkPaint(flags));
+  }
+  ALWAYS_INLINE void drawPicture(sk_sp<PaintRecord> record) {
+    drawPicture(record.get());
+  }
+
+  ALWAYS_INLINE bool isClipEmpty() const { return canvas_->isClipEmpty(); }
+  ALWAYS_INLINE bool isClipRect() const { return canvas_->isClipRect(); }
+  ALWAYS_INLINE const SkMatrix& getTotalMatrix() const {
+    return canvas_->getTotalMatrix();
+  }
+
+  // For GraphicsContextCanvas only.  Maybe this could be rewritten?
+  ALWAYS_INLINE void temporary_internal_describeTopLayer(SkMatrix* matrix,
+                                                         SkIRect* clip_bounds) {
+    return canvas_->temporary_internal_describeTopLayer(matrix, clip_bounds);
+  }
+
+ protected:
+  friend class PaintSurface;
+  friend class PaintRecorder;
+  friend CC_PAINT_EXPORT void PaintCanvasAnnotateRectWithURL(
+      PaintCanvas* canvas,
+      const SkRect& rect,
+      SkData* data);
+  friend CC_PAINT_EXPORT void PaintCanvasAnnotateNamedDestination(
+      PaintCanvas* canvas,
+      const SkPoint& point,
+      SkData* data);
+  friend CC_PAINT_EXPORT void PaintCanvasAnnotateLinkToDestination(
+      PaintCanvas* canvas,
+      const SkRect& rect,
+      SkData* data);
+  friend CC_PAINT_EXPORT bool ToPixmap(PaintCanvas* canvas, SkPixmap* output);
+
+ private:
+  SkCanvas* canvas_;
+  std::unique_ptr<SkCanvas> owned_;
+
+  DISALLOW_COPY_AND_ASSIGN(PaintCanvas);
 };
 
-// TODO(enne): Move all these functions into PaintCanvas.
+class CC_PAINT_EXPORT PaintCanvasAutoRestore {
+ public:
+  ALWAYS_INLINE PaintCanvasAutoRestore(PaintCanvas* canvas, bool save)
+      : canvas_(canvas) {
+    if (canvas_) {
+      save_count_ = canvas_->getSaveCount();
+      if (save) {
+        canvas_->save();
+      }
+    }
+  }
+
+  ALWAYS_INLINE ~PaintCanvasAutoRestore() {
+    if (canvas_) {
+      canvas_->restoreToCount(save_count_);
+    }
+  }
+
+  ALWAYS_INLINE void restore() {
+    if (canvas_) {
+      canvas_->restoreToCount(save_count_);
+      canvas_ = nullptr;
+    }
+  }
+
+ private:
+  PaintCanvas* canvas_ = nullptr;
+  int save_count_ = 0;
+};
+
+// TODO(enne): Move all these functions into PaintCanvas.  These are only
+// separate now to make the transition to concrete types easier by keeping
+// the base PaintCanvas type equivalent to the SkCanvas interface and
+// all these helper functions potentially operating on both.
 
 // PaintCanvas equivalent of skia::GetWritablePixels.
 CC_PAINT_EXPORT bool ToPixmap(PaintCanvas* canvas, SkPixmap* output);
@@ -36,6 +440,18 @@ CC_PAINT_EXPORT void SetIsPreviewMetafile(PaintCanvas* canvas, bool is_preview);
 CC_PAINT_EXPORT bool IsPreviewMetafile(PaintCanvas* canvas);
 #endif
 
+CC_PAINT_EXPORT void PaintCanvasAnnotateRectWithURL(PaintCanvas* canvas,
+                                                    const SkRect& rect,
+                                                    SkData* data);
+
+CC_PAINT_EXPORT void PaintCanvasAnnotateNamedDestination(PaintCanvas* canvas,
+                                                         const SkPoint& point,
+                                                         SkData* data);
+
+CC_PAINT_EXPORT void PaintCanvasAnnotateLinkToDestination(PaintCanvas* canvas,
+                                                          const SkRect& rect,
+                                                          SkData* data);
+
 }  // namespace cc
 
 #endif  // CC_PAINT_PAINT_CANVAS_H_
diff --git a/cc/paint/paint_flags.h b/cc/paint/paint_flags.h
index aa112452121ec0..b7e96c68e2ec48 100644
--- a/cc/paint/paint_flags.h
+++ b/cc/paint/paint_flags.h
@@ -5,14 +5,212 @@
 #ifndef CC_PAINT_PAINT_FLAGS_H_
 #define CC_PAINT_PAINT_FLAGS_H_
 
+#include "base/compiler_specific.h"
+#include "cc/paint/paint_export.h"
+#include "cc/paint/paint_shader.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkColorFilter.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
+#include "third_party/skia/include/core/SkImageFilter.h"
+#include "third_party/skia/include/core/SkMaskFilter.h"
 #include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkPathEffect.h"
+#include "third_party/skia/include/core/SkTypeface.h"
 
 namespace cc {
 
-using PaintFlags = SkPaint;
+class CC_PAINT_EXPORT PaintFlags {
+ public:
+  enum Style {
+    kFill_Style = SkPaint::kFill_Style,
+    kStroke_Style = SkPaint::kStroke_Style,
+    kStrokeAndFill_Style = SkPaint::kStrokeAndFill_Style,
+  };
+  ALWAYS_INLINE Style getStyle() const {
+    return static_cast<Style>(paint_.getStyle());
+  }
+  ALWAYS_INLINE void setStyle(Style style) {
+    paint_.setStyle(static_cast<SkPaint::Style>(style));
+  }
+  ALWAYS_INLINE SkColor getColor() const { return paint_.getColor(); }
+  ALWAYS_INLINE void setColor(SkColor color) { paint_.setColor(color); }
+  ALWAYS_INLINE void setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
+    paint_.setARGB(a, r, g, b);
+  }
+  ALWAYS_INLINE uint8_t getAlpha() const { return paint_.getAlpha(); }
+  ALWAYS_INLINE void setAlpha(U8CPU a) { paint_.setAlpha(a); }
+  ALWAYS_INLINE void setBlendMode(SkBlendMode mode) {
+    paint_.setBlendMode(mode);
+  }
+  ALWAYS_INLINE SkBlendMode getBlendMode() const {
+    return paint_.getBlendMode();
+  }
+  ALWAYS_INLINE bool isSrcOver() const { return paint_.isSrcOver(); }
+  ALWAYS_INLINE bool isAntiAlias() const { return paint_.isAntiAlias(); }
+  ALWAYS_INLINE void setAntiAlias(bool aa) { paint_.setAntiAlias(aa); }
+  ALWAYS_INLINE bool isVerticalText() const { return paint_.isVerticalText(); }
+  ALWAYS_INLINE void setVerticalText(bool vertical) {
+    paint_.setVerticalText(vertical);
+  }
+  ALWAYS_INLINE bool isSubpixelText() const { return paint_.isSubpixelText(); }
+  ALWAYS_INLINE void setSubpixelText(bool subpixel_text) {
+    paint_.setSubpixelText(subpixel_text);
+  }
+  ALWAYS_INLINE bool isLCDRenderText() const {
+    return paint_.isLCDRenderText();
+  }
+  ALWAYS_INLINE void setLCDRenderText(bool lcd_text) {
+    paint_.setLCDRenderText(lcd_text);
+  }
+  enum Hinting {
+    kNo_Hinting = SkPaint::kNo_Hinting,
+    kSlight_Hinting = SkPaint::kSlight_Hinting,
+    kNormal_Hinting = SkPaint::kNormal_Hinting,  //!< this is the default
+    kFull_Hinting = SkPaint::kFull_Hinting
+  };
+  ALWAYS_INLINE Hinting getHinting() const {
+    return static_cast<Hinting>(paint_.getHinting());
+  }
+  ALWAYS_INLINE void setHinting(Hinting hinting_level) {
+    paint_.setHinting(static_cast<SkPaint::Hinting>(hinting_level));
+  }
+  ALWAYS_INLINE bool isAutohinted() const { return paint_.isAutohinted(); }
+  ALWAYS_INLINE void setAutohinted(bool use_auto_hinter) {
+    paint_.setAutohinted(use_auto_hinter);
+  }
+  ALWAYS_INLINE bool isDither() const { return paint_.isDither(); }
+  ALWAYS_INLINE void setDither(bool dither) { paint_.setDither(dither); }
+  enum TextEncoding {
+    kUTF8_TextEncoding = SkPaint::kUTF8_TextEncoding,
+    kUTF16_TextEncoding = SkPaint::kUTF16_TextEncoding,
+    kUTF32_TextEncoding = SkPaint::kUTF32_TextEncoding,
+    kGlyphID_TextEncoding = SkPaint::kGlyphID_TextEncoding
+  };
+  ALWAYS_INLINE TextEncoding getTextEncoding() const {
+    return static_cast<TextEncoding>(paint_.getTextEncoding());
+  }
+  ALWAYS_INLINE void setTextEncoding(TextEncoding encoding) {
+    paint_.setTextEncoding(static_cast<SkPaint::TextEncoding>(encoding));
+  }
+  ALWAYS_INLINE SkScalar getTextSize() const { return paint_.getTextSize(); }
+  ALWAYS_INLINE void setTextSize(SkScalar textSize) {
+    paint_.setTextSize(textSize);
+  }
+  ALWAYS_INLINE void setFilterQuality(SkFilterQuality quality) {
+    paint_.setFilterQuality(quality);
+  }
+  ALWAYS_INLINE SkFilterQuality getFilterQuality() const {
+    return paint_.getFilterQuality();
+  }
+  ALWAYS_INLINE SkScalar getStrokeWidth() const {
+    return paint_.getStrokeWidth();
+  }
+  ALWAYS_INLINE void setStrokeWidth(SkScalar width) {
+    paint_.setStrokeWidth(width);
+  }
+  ALWAYS_INLINE SkScalar getStrokeMiter() const {
+    return paint_.getStrokeMiter();
+  }
+  ALWAYS_INLINE void setStrokeMiter(SkScalar miter) {
+    paint_.setStrokeMiter(miter);
+  }
+  enum Cap {
+    kButt_Cap = SkPaint::kButt_Cap,    //!< begin/end contours with no extension
+    kRound_Cap = SkPaint::kRound_Cap,  //!< begin/end contours with a
+                                       //! semi-circle extension
+    kSquare_Cap = SkPaint::kSquare_Cap,  //!< begin/end contours with a half
+                                         //! square extension
+    kLast_Cap = kSquare_Cap,
+    kDefault_Cap = kButt_Cap
+  };
+  ALWAYS_INLINE Cap getStrokeCap() const {
+    return static_cast<Cap>(paint_.getStrokeCap());
+  }
+  ALWAYS_INLINE void setStrokeCap(Cap cap) {
+    paint_.setStrokeCap(static_cast<SkPaint::Cap>(cap));
+  }
+  enum Join {
+    kMiter_Join = SkPaint::kMiter_Join,
+    kRound_Join = SkPaint::kRound_Join,
+    kBevel_Join = SkPaint::kBevel_Join,
+    kLast_Join = kBevel_Join,
+    kDefault_Join = kMiter_Join
+  };
+  ALWAYS_INLINE Join getStrokeJoin() const {
+    return static_cast<Join>(paint_.getStrokeJoin());
+  }
+  ALWAYS_INLINE void setStrokeJoin(Join join) {
+    paint_.setStrokeJoin(static_cast<SkPaint::Join>(join));
+  }
+  ALWAYS_INLINE SkTypeface* getTypeface() const { return paint_.getTypeface(); }
+  ALWAYS_INLINE void setTypeface(sk_sp<SkTypeface> typeface) {
+    paint_.setTypeface(std::move(typeface));
+  }
+  ALWAYS_INLINE SkColorFilter* getColorFilter() const {
+    return paint_.getColorFilter();
+  }
+  ALWAYS_INLINE void setColorFilter(sk_sp<SkColorFilter> filter) {
+    paint_.setColorFilter(std::move(filter));
+  }
+  ALWAYS_INLINE SkMaskFilter* getMaskFilter() const {
+    return paint_.getMaskFilter();
+  }
+  ALWAYS_INLINE void setMaskFilter(sk_sp<SkMaskFilter> mask) {
+    paint_.setMaskFilter(std::move(mask));
+  }
+  ALWAYS_INLINE PaintShader* getShader() const { return paint_.getShader(); }
+  ALWAYS_INLINE void setShader(sk_sp<PaintShader> shader) {
+    paint_.setShader(std::move(shader));
+  }
+  ALWAYS_INLINE SkPathEffect* getPathEffect() const {
+    return paint_.getPathEffect();
+  }
+  ALWAYS_INLINE void setPathEffect(sk_sp<SkPathEffect> effect) {
+    paint_.setPathEffect(std::move(effect));
+  }
+  ALWAYS_INLINE bool getFillPath(const SkPath& src,
+                                 SkPath* dst,
+                                 const SkRect* cullRect = nullptr,
+                                 SkScalar resScale = 1) const {
+    return paint_.getFillPath(src, dst, cullRect, resScale);
+  }
+  ALWAYS_INLINE sk_sp<SkImageFilter> refImageFilter() const {
+    return paint_.refImageFilter();
+  }
+  ALWAYS_INLINE SkImageFilter* getImageFilter() const {
+    return paint_.getImageFilter();
+  }
+  void setImageFilter(sk_sp<SkImageFilter> filter) {
+    paint_.setImageFilter(std::move(filter));
+  }
+  ALWAYS_INLINE SkDrawLooper* getDrawLooper() const {
+    return paint_.getDrawLooper();
+  }
+  ALWAYS_INLINE SkDrawLooper* getLooper() const { return paint_.getLooper(); }
+  ALWAYS_INLINE void setLooper(sk_sp<SkDrawLooper> looper) {
+    paint_.setLooper(std::move(looper));
+  }
+  ALWAYS_INLINE bool canComputeFastBounds() const {
+    return paint_.canComputeFastBounds();
+  }
+  ALWAYS_INLINE const SkRect& computeFastBounds(const SkRect& orig,
+                                                SkRect* storage) const {
+    return paint_.computeFastBounds(orig, storage);
+  }
 
-inline const SkPaint& ToSkPaint(const PaintFlags& flags) {
-  return flags;
+ private:
+  friend const SkPaint& ToSkPaint(const PaintFlags& flags);
+  friend const SkPaint* ToSkPaint(const PaintFlags* flags);
+
+  SkPaint paint_;
+};
+
+ALWAYS_INLINE const SkPaint& ToSkPaint(const PaintFlags& flags) {
+  return flags.paint_;
+}
+
+ALWAYS_INLINE const SkPaint* ToSkPaint(const PaintFlags* flags) {
+  return &flags->paint_;
 }
 
 }  // namespace cc
diff --git a/cc/paint/paint_recorder.cc b/cc/paint/paint_recorder.cc
new file mode 100644
index 00000000000000..672f0712725d4f
--- /dev/null
+++ b/cc/paint/paint_recorder.cc
@@ -0,0 +1,12 @@
+// Copyright 2017 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 "cc/paint/paint_recorder.h"
+
+namespace cc {
+
+PaintRecorder::PaintRecorder() = default;
+PaintRecorder::~PaintRecorder() = default;
+
+}  // namespace cc
diff --git a/cc/paint/paint_recorder.h b/cc/paint/paint_recorder.h
index be866fddf1df1d..752dadd1a0d2b5 100644
--- a/cc/paint/paint_recorder.h
+++ b/cc/paint/paint_recorder.h
@@ -5,10 +5,67 @@
 #ifndef CC_PAINT_PAINT_RECORDER_H_
 #define CC_PAINT_PAINT_RECORDER_H_
 
+#include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/optional.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_record.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 
 namespace cc {
-using PaintRecorder = SkPictureRecorder;
-}
+
+class CC_PAINT_EXPORT PaintRecorder {
+ public:
+  PaintRecorder();
+  ~PaintRecorder();
+
+  ALWAYS_INLINE PaintCanvas* beginRecording(const SkRect& bounds) {
+    uint32_t record_flags = 0;
+    canvas_.emplace(recorder_.beginRecording(bounds, nullptr, record_flags));
+    return getRecordingCanvas();
+  }
+
+  ALWAYS_INLINE PaintCanvas* beginRecording(
+      SkScalar width,
+      SkScalar height,
+      SkBBHFactory* rtree_factory = nullptr) {
+    uint32_t record_flags = 0;
+    canvas_.emplace(
+        recorder_.beginRecording(width, height, rtree_factory, record_flags));
+    return getRecordingCanvas();
+  }
+
+  // Only valid between between and finish recording.
+  ALWAYS_INLINE PaintCanvas* getRecordingCanvas() {
+    return canvas_.has_value() ? &canvas_.value() : nullptr;
+  }
+
+  ALWAYS_INLINE sk_sp<PaintRecord> finishRecordingAsPicture(
+      uint32_t end_flags = 0) {
+    sk_sp<SkPicture> picture = recorder_.finishRecordingAsPicture(end_flags);
+    // Some users (e.g. printing) use the existence of the recording canvas
+    // to know if recording is finished, so reset it here.
+    canvas_.reset();
+    return sk_ref_sp(static_cast<PaintRecord*>(picture.get()));
+  }
+
+  ALWAYS_INLINE sk_sp<PaintRecord> finishRecordingAsPictureWithCull(
+      const SkRect& cull_rect,
+      uint32_t end_flags = 0) {
+    sk_sp<SkPicture> picture =
+        recorder_.finishRecordingAsPictureWithCull(cull_rect, end_flags);
+    canvas_.reset();
+    return sk_ref_sp(static_cast<PaintRecord*>(picture.get()));
+  }
+
+ private:
+  SkPictureRecorder recorder_;
+  base::Optional<PaintCanvas> canvas_;
+
+  DISALLOW_COPY_AND_ASSIGN(PaintRecorder);
+};
+
+}  // namespace cc
 
 #endif  // CC_PAINT_PAINT_RECORDER_H_
diff --git a/cc/paint/paint_shader.h b/cc/paint/paint_shader.h
index f519703eb88c1d..f9448691cb8244 100644
--- a/cc/paint/paint_shader.h
+++ b/cc/paint/paint_shader.h
@@ -35,7 +35,8 @@ inline sk_sp<PaintShader> MakePaintShaderRecord(sk_sp<PaintRecord> record,
                                                 SkShader::TileMode ty,
                                                 const SkMatrix* local_matrix,
                                                 const SkRect* tile) {
-  return SkShader::MakePictureShader(record, tx, ty, local_matrix, tile);
+  return SkShader::MakePictureShader(ToSkPicture(record), tx, ty, local_matrix,
+                                     tile);
 }
 
 }  // namespace cc
diff --git a/cc/paint/paint_surface.cc b/cc/paint/paint_surface.cc
new file mode 100644
index 00000000000000..a46220ebafd7e1
--- /dev/null
+++ b/cc/paint/paint_surface.cc
@@ -0,0 +1,14 @@
+// Copyright 2017 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 "cc/paint/paint_surface.h"
+
+namespace cc {
+
+PaintSurface::PaintSurface(sk_sp<SkSurface> surface)
+    : surface_(std::move(surface)) {}
+
+PaintSurface::~PaintSurface() = default;
+
+}  // namespace cc
diff --git a/cc/paint/paint_surface.h b/cc/paint/paint_surface.h
index 34165bf16ed70e..471901732aab3f 100644
--- a/cc/paint/paint_surface.h
+++ b/cc/paint/paint_surface.h
@@ -5,10 +5,55 @@
 #ifndef CC_PAINT_PAINT_SURFACE_H_
 #define CC_PAINT_PAINT_SURFACE_H_
 
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/optional.h"
+#include "cc/paint/paint_canvas.h"
+#include "cc/paint/paint_export.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 namespace cc {
-using PaintSurface = SkSurface;
-}
+
+class CC_PAINT_EXPORT PaintSurface : public SkRefCntBase {
+ public:
+  explicit PaintSurface(sk_sp<SkSurface> surface);
+  ~PaintSurface() override;
+
+  // TODO(enne): this interface matches SkSurface for simplicity.
+  // However, this should really be changed to make the SkSurface ctor
+  // public and have that be the only constructor.  This will also
+  // clean up a bunch of code where there's an SkSurface and a PaintCanvas,
+  // such as for canvas in Blink.
+  static sk_sp<PaintSurface> MakeRaster(const SkImageInfo& info,
+                                        const SkSurfaceProps* props = nullptr) {
+    sk_sp<SkSurface> s = SkSurface::MakeRaster(info, props);
+    return sk_make_sp<PaintSurface>(std::move(s));
+  }
+  static sk_sp<PaintSurface> MakeRasterN32Premul(
+      int width,
+      int height,
+      const SkSurfaceProps* props = nullptr) {
+    sk_sp<SkSurface> s = SkSurface::MakeRasterN32Premul(width, height, props);
+    return sk_make_sp<PaintSurface>(std::move(s));
+  }
+
+  int width() const { return surface_->width(); }
+  int height() const { return surface_->height(); }
+  uint32_t generationID() { return surface_->generationID(); }
+
+  PaintCanvas* getCanvas() {
+    if (!canvas_.has_value())
+      canvas_.emplace(surface_->getCanvas());
+    return &canvas_.value();
+  }
+
+ private:
+  const sk_sp<SkSurface> surface_;
+  base::Optional<PaintCanvas> canvas_;
+
+  DISALLOW_COPY_AND_ASSIGN(PaintSurface);
+};
+
+}  // namespace cc
 
 #endif  // CC_PAINT_PAINT_SURFACE_H_
diff --git a/content/child/browser_font_resource_trusted.cc b/content/child/browser_font_resource_trusted.cc
index 9c9480b51a3e83..3ceca36ac59169 100644
--- a/content/child/browser_font_resource_trusted.cc
+++ b/content/child/browser_font_resource_trusted.cc
@@ -341,11 +341,12 @@ PP_Bool BrowserFontResource_Trusted::DrawTextAt(
       return result;
 
     SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
-    SkCanvas temp_canvas(bm, props);
+    cc::PaintCanvas temp_canvas(bm, props);
 
     DrawTextToCanvas(&temp_canvas, *text, position, color, clip);
   } else {
-    DrawTextToCanvas(canvas, *text, position, color, clip);
+    cc::PaintCanvas temp_canvas(canvas);
+    DrawTextToCanvas(&temp_canvas, *text, position, color, clip);
   }
 
   if (needs_unmapping)
@@ -414,7 +415,7 @@ int32_t BrowserFontResource_Trusted::PixelOffsetForCharacter(
 }
 
 void BrowserFontResource_Trusted::DrawTextToCanvas(
-    SkCanvas* destination,
+    cc::PaintCanvas* destination,
     const PP_BrowserFont_Trusted_TextRun& text,
     const PP_Point* position,
     uint32_t color,
@@ -424,7 +425,7 @@ void BrowserFontResource_Trusted::DrawTextToCanvas(
                              static_cast<float>(position->y));
   WebRect web_clip;
   if (!clip) {
-    // Use entire canvas. SkCanvas doesn't have a size on it, so we just use
+    // Use entire canvas. PaintCanvas doesn't have a size on it, so we just use
     // the current clip bounds.
     SkRect skclip = destination->getLocalClipBounds();
     web_clip = WebRect(skclip.fLeft, skclip.fTop, skclip.fRight - skclip.fLeft,
diff --git a/content/renderer/gpu/gpu_benchmarking_extension.cc b/content/renderer/gpu/gpu_benchmarking_extension.cc
index 1cabf083f5f5f9..23b97719452349 100644
--- a/content/renderer/gpu/gpu_benchmarking_extension.cc
+++ b/content/renderer/gpu/gpu_benchmarking_extension.cc
@@ -475,7 +475,7 @@ static void PrintDocument(blink::WebFrame* frame, SkDocument* doc) {
   int page_count = frame->printBegin(params);
   for (int i = 0; i < page_count; ++i) {
     SkCanvas* sk_canvas = doc->beginPage(kPageWidth, kPageHeight);
-    cc::PaintCanvasPassThrough canvas(sk_canvas);
+    cc::PaintCanvas canvas(sk_canvas);
     cc::PaintCanvasAutoRestore auto_restore(&canvas, true);
     canvas.translate(kMarginLeft, kMarginTop);
 
diff --git a/media/renderers/skcanvas_video_renderer_unittest.cc b/media/renderers/skcanvas_video_renderer_unittest.cc
index 1eb3e9e28c940e..b85ffffb40b08b 100644
--- a/media/renderers/skcanvas_video_renderer_unittest.cc
+++ b/media/renderers/skcanvas_video_renderer_unittest.cc
@@ -674,9 +674,9 @@ TEST_F(SkCanvasVideoRendererTest, CorrectFrameSizeToVisibleRect) {
       GrContext::Create(kOpenGL_GrBackend,
                         reinterpret_cast<GrBackendContext>(glInterface.get())));
 
-  sk_sp<cc::PaintSurface> surface = cc::PaintSurface::MakeRenderTarget(
-      grContext.get(), SkBudgeted::kYes, imInfo);
-  cc::PaintCanvas* canvas = surface->getCanvas();
+  sk_sp<SkSurface> surface =
+      SkSurface::MakeRenderTarget(grContext.get(), SkBudgeted::kYes, imInfo);
+  cc::PaintCanvas canvas(surface->getCanvas());
 
   TestGLES2Interface gles2;
   Context3D context_3d(&gles2, grContext.get());
@@ -696,7 +696,7 @@ TEST_F(SkCanvasVideoRendererTest, CorrectFrameSizeToVisibleRect) {
 
   gfx::RectF visible_rect(visible_size.width(), visible_size.height());
   cc::PaintFlags flags;
-  renderer_.Paint(video_frame, canvas, visible_rect, flags, VIDEO_ROTATION_0,
+  renderer_.Paint(video_frame, &canvas, visible_rect, flags, VIDEO_ROTATION_0,
                   context_3d);
 
   EXPECT_EQ(fWidth / 2, renderer_.LastImageDimensionsForTesting().width());
diff --git a/printing/pdf_metafile_skia.cc b/printing/pdf_metafile_skia.cc
index 6b548afd76b08c..beac575bc7426c 100644
--- a/printing/pdf_metafile_skia.cc
+++ b/printing/pdf_metafile_skia.cc
@@ -200,9 +200,9 @@ bool PdfMetafileSkia::FinishDocument() {
   }
 
   for (const Page& page : data_->pages_) {
-    cc::PaintCanvas* canvas(
+    cc::PaintCanvas canvas(
         doc->beginPage(page.size_.width(), page.size_.height()));
-    canvas->drawPicture(page.content_);
+    canvas.drawPicture(page.content_);
     doc->endPage();
   }
   doc->close();
diff --git a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
index 043fc9e1600990..3e2f9593c55f7b 100644
--- a/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
+++ b/third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp
@@ -3287,7 +3287,7 @@ void CompositedLayerMapping::paintScrollableArea(
   DrawingRecorder drawingRecorder(context, *graphicsLayer,
                                   DisplayItem::kScrollbarCompositedScrollbar,
                                   layerBounds);
-  builder.endRecording()->playback(context.canvas());
+  context.canvas()->drawPicture(builder.endRecording());
 }
 
 bool CompositedLayerMapping::isScrollableAreaLayer(
diff --git a/third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.cpp b/third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.cpp
index bbec9cc709b2b9..1ff1e8c85c2f33 100644
--- a/third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.cpp
+++ b/third_party/WebKit/Source/core/layout/compositing/PaintLayerCompositor.cpp
@@ -950,7 +950,7 @@ void PaintLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer,
   DrawingRecorder drawingRecorder(context, *graphicsLayer,
                                   DisplayItem::kScrollbarCompositedScrollbar,
                                   layerBounds);
-  builder.endRecording()->playback(context.canvas());
+  context.canvas()->drawPicture(builder.endRecording());
 }
 
 Scrollbar* PaintLayerCompositor::graphicsLayerToScrollbar(
diff --git a/third_party/WebKit/Source/core/paint/SVGShapePainter.cpp b/third_party/WebKit/Source/core/paint/SVGShapePainter.cpp
index 9788f111d6d8a0..09c7b1cf7abd35 100644
--- a/third_party/WebKit/Source/core/paint/SVGShapePainter.cpp
+++ b/third_party/WebKit/Source/core/paint/SVGShapePainter.cpp
@@ -228,7 +228,7 @@ void SVGShapePainter::paintMarkers(const PaintInfo& paintInfo,
       markerPaintInfo.m_cullRect.m_rect = LayoutRect::infiniteIntRect();
 
       paintMarker(markerPaintInfo, *marker, markerPosition, strokeWidth);
-      builder.endRecording()->playback(paintInfo.context.canvas());
+      paintInfo.context.canvas()->drawPicture(builder.endRecording());
     }
   }
 }
diff --git a/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp b/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp
index e455c7f8bd2d29..8a59d93099a9ad 100644
--- a/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp
+++ b/third_party/WebKit/Source/core/svg/graphics/SVGImageTest.cpp
@@ -30,7 +30,7 @@ class SVGImageTest : public ::testing::Test {
   void pumpFrame() {
     Image* image = m_image.get();
     std::unique_ptr<SkCanvas> nullCanvas = SkMakeNullCanvas();
-    PaintCanvasPassThrough canvas(nullCanvas.get());
+    PaintCanvas canvas(nullCanvas.get());
     PaintFlags flags;
     FloatRect dummyRect(0, 0, 100, 100);
     image->draw(&canvas, flags, dummyRect, dummyRect,
diff --git a/third_party/WebKit/Source/platform/exported/WebFont.cpp b/third_party/WebKit/Source/platform/exported/WebFont.cpp
index 2899dd5bdfc423..caa24c41236da0 100644
--- a/third_party/WebKit/Source/platform/exported/WebFont.cpp
+++ b/third_party/WebKit/Source/platform/exported/WebFont.cpp
@@ -101,7 +101,7 @@ void WebFont::drawText(WebCanvas* canvas,
     context.restore();
   }
 
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 int WebFont::calculateWidth(const WebTextRun& run) const {
diff --git a/third_party/WebKit/Source/platform/exported/WebScrollbarThemePainter.cpp b/third_party/WebKit/Source/platform/exported/WebScrollbarThemePainter.cpp
index 7dce90e628cf7f..29b9fef396bcfa 100644
--- a/third_party/WebKit/Source/platform/exported/WebScrollbarThemePainter.cpp
+++ b/third_party/WebKit/Source/platform/exported/WebScrollbarThemePainter.cpp
@@ -54,7 +54,7 @@ void WebScrollbarThemePainter::paintScrollbarBackground(WebCanvas* canvas,
   PaintRecordBuilder builder(intRect);
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintScrollbarBackground(builder.context(), *m_scrollbar);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintTrackBackground(WebCanvas* canvas,
@@ -63,7 +63,7 @@ void WebScrollbarThemePainter::paintTrackBackground(WebCanvas* canvas,
   PaintRecordBuilder builder(intRect);
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintTrackBackground(builder.context(), *m_scrollbar, intRect);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
   if (!m_theme->shouldRepaintAllPartsOnInvalidation())
     m_scrollbar->clearTrackNeedsRepaint();
 }
@@ -75,7 +75,7 @@ void WebScrollbarThemePainter::paintBackTrackPart(WebCanvas* canvas,
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintTrackPiece(builder.context(), *m_scrollbar, intRect,
                            BackTrackPart);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintForwardTrackPart(WebCanvas* canvas,
@@ -85,7 +85,7 @@ void WebScrollbarThemePainter::paintForwardTrackPart(WebCanvas* canvas,
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintTrackPiece(builder.context(), *m_scrollbar, intRect,
                            ForwardTrackPart);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintBackButtonStart(WebCanvas* canvas,
@@ -95,7 +95,7 @@ void WebScrollbarThemePainter::paintBackButtonStart(WebCanvas* canvas,
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintButton(builder.context(), *m_scrollbar, intRect,
                        BackButtonStartPart);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintBackButtonEnd(WebCanvas* canvas,
@@ -105,7 +105,7 @@ void WebScrollbarThemePainter::paintBackButtonEnd(WebCanvas* canvas,
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintButton(builder.context(), *m_scrollbar, intRect,
                        BackButtonEndPart);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintForwardButtonStart(WebCanvas* canvas,
@@ -115,7 +115,7 @@ void WebScrollbarThemePainter::paintForwardButtonStart(WebCanvas* canvas,
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintButton(builder.context(), *m_scrollbar, intRect,
                        ForwardButtonStartPart);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintForwardButtonEnd(WebCanvas* canvas,
@@ -125,7 +125,7 @@ void WebScrollbarThemePainter::paintForwardButtonEnd(WebCanvas* canvas,
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintButton(builder.context(), *m_scrollbar, intRect,
                        ForwardButtonEndPart);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintTickmarks(WebCanvas* canvas,
@@ -134,7 +134,7 @@ void WebScrollbarThemePainter::paintTickmarks(WebCanvas* canvas,
   PaintRecordBuilder builder(intRect);
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintTickmarks(builder.context(), *m_scrollbar, intRect);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
 }
 
 void WebScrollbarThemePainter::paintThumb(WebCanvas* canvas,
@@ -143,7 +143,7 @@ void WebScrollbarThemePainter::paintThumb(WebCanvas* canvas,
   PaintRecordBuilder builder(intRect);
   builder.context().setDeviceScaleFactor(m_deviceScaleFactor);
   m_theme->paintThumb(builder.context(), *m_scrollbar, intRect);
-  builder.endRecording()->playback(canvas);
+  canvas->drawPicture(builder.endRecording());
   if (!m_theme->shouldRepaintAllPartsOnInvalidation())
     m_scrollbar->clearThumbNeedsRepaint();
 }
diff --git a/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp b/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp
index 7129cc32c4f599..046285877acd3f 100644
--- a/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp
+++ b/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp
@@ -82,13 +82,13 @@ struct Canvas2DLayerBridge::ImageInfo : public RefCounted<ImageInfo> {
 };
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
 
-static sk_sp<PaintSurface> createSkSurface(GrContext* gr,
-                                           const IntSize& size,
-                                           int msaaSampleCount,
-                                           OpacityMode opacityMode,
-                                           sk_sp<SkColorSpace> colorSpace,
-                                           SkColorType colorType,
-                                           bool* surfaceIsAccelerated) {
+static sk_sp<SkSurface> createSkSurface(GrContext* gr,
+                                        const IntSize& size,
+                                        int msaaSampleCount,
+                                        OpacityMode opacityMode,
+                                        sk_sp<SkColorSpace> colorSpace,
+                                        SkColorType colorType,
+                                        bool* surfaceIsAccelerated) {
   if (gr)
     gr->resetContext();
 
@@ -97,18 +97,18 @@ static sk_sp<PaintSurface> createSkSurface(GrContext* gr,
   SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), colorType,
                                        alphaType, colorSpace);
   SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
-  sk_sp<PaintSurface> surface;
+  sk_sp<SkSurface> surface;
 
   if (gr) {
     *surfaceIsAccelerated = true;
-    surface = PaintSurface::MakeRenderTarget(
+    surface = SkSurface::MakeRenderTarget(
         gr, SkBudgeted::kNo, info, msaaSampleCount,
         Opaque == opacityMode ? 0 : &disableLCDProps);
   }
 
   if (!surface) {
     *surfaceIsAccelerated = false;
-    surface = PaintSurface::MakeRaster(
+    surface = SkSurface::MakeRaster(
         info, Opaque == opacityMode ? 0 : &disableLCDProps);
   }
 
@@ -174,7 +174,7 @@ void Canvas2DLayerBridge::startRecording() {
   DCHECK(m_isDeferralEnabled);
   m_recorder = WTF::wrapUnique(new PaintRecorder);
   PaintCanvas* canvas =
-      m_recorder->beginRecording(m_size.width(), m_size.height(), nullptr);
+      m_recorder->beginRecording(m_size.width(), m_size.height());
   // Always save an initial frame, to support resetting the top level matrix
   // and clip.
   canvas->save();
@@ -189,6 +189,11 @@ void Canvas2DLayerBridge::setLoggerForTesting(std::unique_ptr<Logger> logger) {
   m_logger = std::move(logger);
 }
 
+void Canvas2DLayerBridge::ResetSurface() {
+  m_surfacePaintCanvas.reset();
+  m_surface.reset();
+}
+
 bool Canvas2DLayerBridge::shouldAccelerate(AccelerationHint hint) const {
   bool accelerate;
   if (m_softwareRenderingWhileHidden)
@@ -497,8 +502,8 @@ void Canvas2DLayerBridge::hibernate() {
   }
 
   TRACE_EVENT0("blink", "Canvas2DLayerBridge::hibernate");
-  sk_sp<PaintSurface> tempHibernationSurface =
-      PaintSurface::MakeRasterN32Premul(m_size.width(), m_size.height());
+  sk_sp<SkSurface> tempHibernationSurface =
+      SkSurface::MakeRasterN32Premul(m_size.width(), m_size.height());
   if (!tempHibernationSurface) {
     m_logger->reportHibernationEvent(HibernationAbortedDueToAllocationFailure);
     return;
@@ -512,12 +517,12 @@ void Canvas2DLayerBridge::hibernate() {
   // a surface, and we have an early exit at the top of this function for when
   // 'this' does not already have a surface.
   DCHECK(!m_haveRecordedDrawCommands);
-  PaintFlags copyPaint;
+  SkPaint copyPaint;
   copyPaint.setBlendMode(SkBlendMode::kSrc);
   m_surface->draw(tempHibernationSurface->getCanvas(), 0, 0,
                   &copyPaint);  // GPU readback
   m_hibernationImage = tempHibernationSurface->makeImageSnapshot();
-  m_surface.reset();  // destroy the GPU-backed buffer
+  ResetSurface();
   m_layer->clearTexture();
 #if USE_IOSURFACE_FOR_2D_CANVAS
   clearCHROMIUMImageCache();
@@ -542,7 +547,7 @@ void Canvas2DLayerBridge::reportSurfaceCreationFailure() {
   }
 }
 
-PaintSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
+SkSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
   if (m_surface)
     return m_surface.get();
 
@@ -563,11 +568,13 @@ PaintSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
       wantAcceleration ? m_contextProvider->grContext() : nullptr, m_size,
       m_msaaSampleCount, m_opacityMode, skSurfaceColorSpace(), m_colorType,
       &surfaceIsAccelerated);
+  m_surfacePaintCanvas =
+      WTF::wrapUnique(new PaintCanvas(m_surface->getCanvas()));
 
   if (m_surface) {
     // Always save an initial frame, to support resetting the top level matrix
     // and clip.
-    m_surface->getCanvas()->save();
+    m_surfacePaintCanvas->save();
   } else {
     reportSurfaceCreationFailure();
   }
@@ -593,7 +600,7 @@ PaintSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
         m_logger->reportHibernationEvent(HibernationEndedWithFallbackToSW);
     }
 
-    PaintFlags copyPaint;
+    SkPaint copyPaint;
     copyPaint.setBlendMode(SkBlendMode::kSrc);
     m_surface->getCanvas()->drawImage(m_hibernationImage.get(), 0, 0,
                                       &copyPaint);
@@ -603,7 +610,7 @@ PaintSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
       m_imageBuffer->updateGPUMemoryUsage();
 
     if (m_imageBuffer && !m_isDeferralEnabled)
-      m_imageBuffer->resetCanvas(m_surface->getCanvas());
+      m_imageBuffer->resetCanvas(m_surfacePaintCanvas.get());
   }
 
   return m_surface.get();
@@ -611,8 +618,8 @@ PaintSurface* Canvas2DLayerBridge::getOrCreateSurface(AccelerationHint hint) {
 
 PaintCanvas* Canvas2DLayerBridge::canvas() {
   if (!m_isDeferralEnabled) {
-    PaintSurface* s = getOrCreateSurface();
-    return s ? s->getCanvas() : nullptr;
+    getOrCreateSurface();
+    return m_surfacePaintCanvas.get();
   }
   return m_recorder->getRecordingCanvas();
 }
@@ -644,9 +651,9 @@ void Canvas2DLayerBridge::disableDeferral(DisableDeferralReason reason) {
   m_isDeferralEnabled = false;
   m_recorder.reset();
   // install the current matrix/clip stack onto the immediate canvas
-  PaintSurface* surface = getOrCreateSurface();
-  if (m_imageBuffer && surface)
-    m_imageBuffer->resetCanvas(surface->getCanvas());
+  getOrCreateSurface();
+  if (m_imageBuffer && m_surfacePaintCanvas)
+    m_imageBuffer->resetCanvas(m_surfacePaintCanvas.get());
 }
 
 void Canvas2DLayerBridge::setImageBuffer(ImageBuffer* imageBuffer) {
@@ -666,7 +673,7 @@ void Canvas2DLayerBridge::beginDestruction() {
   m_imageBuffer = nullptr;
   m_destructionInProgress = true;
   setIsHidden(true);
-  m_surface.reset();
+  ResetSurface();
 
   if (m_layer && m_accelerationMode != DisableAcceleration) {
     GraphicsLayer::unregisterContentsLayer(m_layer->layer());
@@ -711,20 +718,20 @@ void Canvas2DLayerBridge::setIsHidden(bool hidden) {
   }
   if (!isHidden() && m_softwareRenderingWhileHidden) {
     flushRecordingOnly();
-    PaintFlags copyPaint;
+    SkPaint copyPaint;
     copyPaint.setBlendMode(SkBlendMode::kSrc);
 
-    sk_sp<PaintSurface> oldSurface = std::move(m_surface);
-    m_surface.reset();
+    sk_sp<SkSurface> oldSurface = std::move(m_surface);
+    ResetSurface();
 
     m_softwareRenderingWhileHidden = false;
-    PaintSurface* newSurface =
+    SkSurface* newSurface =
         getOrCreateSurface(PreferAccelerationAfterVisibilityChange);
     if (newSurface) {
       if (oldSurface)
         oldSurface->draw(newSurface->getCanvas(), 0, 0, &copyPaint);
       if (m_imageBuffer && !m_isDeferralEnabled) {
-        m_imageBuffer->resetCanvas(m_surface->getCanvas());
+        m_imageBuffer->resetCanvas(m_surfacePaintCanvas.get());
       }
     }
   }
@@ -826,7 +833,7 @@ bool Canvas2DLayerBridge::checkSurfaceValid() {
     return false;
   if (m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() !=
       GL_NO_ERROR) {
-    m_surface.reset();
+    ResetSurface();
     for (auto mailboxInfo = m_mailboxes.begin();
          mailboxInfo != m_mailboxes.end(); ++mailboxInfo) {
       if (mailboxInfo->m_image)
@@ -856,7 +863,7 @@ bool Canvas2DLayerBridge::restoreSurface() {
   if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
     GrContext* grCtx = m_contextProvider->grContext();
     bool surfaceIsAccelerated;
-    sk_sp<PaintSurface> surface(createSkSurface(
+    sk_sp<SkSurface> surface(createSkSurface(
         grCtx, m_size, m_msaaSampleCount, m_opacityMode, skSurfaceColorSpace(),
         m_colorType, &surfaceIsAccelerated));
     if (!m_surface)
diff --git a/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.h b/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.h
index 20b09b98396a41..7d77d0fa8ac4da 100644
--- a/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.h
+++ b/third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.h
@@ -178,6 +178,8 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
   void setLoggerForTesting(std::unique_ptr<Logger>);
 
  private:
+  void ResetSurface();
+
 #if USE_IOSURFACE_FOR_2D_CANVAS
   // All information associated with a CHROMIUM image.
   struct ImageInfo;
@@ -205,7 +207,7 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
   void flushRecordingOnly();
   void reportSurfaceCreationFailure();
 
-  PaintSurface* getOrCreateSurface(AccelerationHint = PreferAcceleration);
+  SkSurface* getOrCreateSurface(AccelerationHint = PreferAcceleration);
   bool shouldAccelerate(AccelerationHint) const;
 
   // Returns the GL filter associated with |m_filterQuality|.
@@ -242,7 +244,8 @@ class PLATFORM_EXPORT Canvas2DLayerBridge
   void resetSkiaTextureBinding();
 
   std::unique_ptr<PaintRecorder> m_recorder;
-  sk_sp<PaintSurface> m_surface;
+  sk_sp<SkSurface> m_surface;
+  std::unique_ptr<PaintCanvas> m_surfacePaintCanvas;
   sk_sp<SkImage> m_hibernationImage;
   int m_initialSurfaceSaveCount;
   std::unique_ptr<WebExternalTextureLayer> m_layer;
diff --git a/third_party/WebKit/Source/platform/graphics/DeferredImageDecoderTest.cpp b/third_party/WebKit/Source/platform/graphics/DeferredImageDecoderTest.cpp
index 70a05909c28840..1587d4834bc432 100644
--- a/third_party/WebKit/Source/platform/graphics/DeferredImageDecoderTest.cpp
+++ b/third_party/WebKit/Source/platform/graphics/DeferredImageDecoderTest.cpp
@@ -148,7 +148,7 @@ TEST_F(DeferredImageDecoderTest, drawIntoPaintRecord) {
   EXPECT_EQ(1, image->height());
 
   PaintRecorder recorder;
-  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
+  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100);
   tempCanvas->drawImage(image.get(), 0, 0);
   sk_sp<PaintRecord> record = recorder.finishRecordingAsPicture();
   EXPECT_EQ(0, m_decodeRequestCount);
@@ -172,7 +172,7 @@ TEST_F(DeferredImageDecoderTest, drawIntoPaintRecordProgressive) {
   sk_sp<SkImage> image = m_lazyDecoder->createFrameAtIndex(0);
   ASSERT_TRUE(image);
   PaintRecorder recorder;
-  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
+  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100);
   tempCanvas->drawImage(image.get(), 0, 0);
   m_surface->getCanvas()->drawPicture(recorder.finishRecordingAsPicture());
 
@@ -180,7 +180,7 @@ TEST_F(DeferredImageDecoderTest, drawIntoPaintRecordProgressive) {
   m_lazyDecoder->setData(m_data, true);
   image = m_lazyDecoder->createFrameAtIndex(0);
   ASSERT_TRUE(image);
-  tempCanvas = recorder.beginRecording(100, 100, 0, 0);
+  tempCanvas = recorder.beginRecording(100, 100);
   tempCanvas->drawImage(image.get(), 0, 0);
   m_surface->getCanvas()->drawPicture(recorder.finishRecordingAsPicture());
 
@@ -203,7 +203,7 @@ TEST_F(DeferredImageDecoderTest, decodeOnOtherThread) {
   EXPECT_EQ(1, image->height());
 
   PaintRecorder recorder;
-  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
+  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100);
   tempCanvas->drawImage(image.get(), 0, 0);
   sk_sp<PaintRecord> record = recorder.finishRecordingAsPicture();
   EXPECT_EQ(0, m_decodeRequestCount);
@@ -303,7 +303,7 @@ TEST_F(DeferredImageDecoderTest, decodedSize) {
 
   // The following code should not fail any assert.
   PaintRecorder recorder;
-  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100, 0, 0);
+  PaintCanvas* tempCanvas = recorder.beginRecording(100, 100);
   tempCanvas->drawImage(image.get(), 0, 0);
   sk_sp<PaintRecord> record = recorder.finishRecordingAsPicture();
   EXPECT_EQ(0, m_decodeRequestCount);
diff --git a/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp b/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp
index cb688e1b62f47a..bdbf4456a64439 100644
--- a/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp
+++ b/third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp
@@ -82,7 +82,7 @@ GraphicsContext::GraphicsContext(PaintController& paintController,
   if (contextDisabled()) {
     DEFINE_STATIC_LOCAL(SkCanvas*, nullSkCanvas,
                         (SkMakeNullCanvas().release()));
-    DEFINE_STATIC_LOCAL(PaintCanvasPassThrough, nullCanvas, (nullSkCanvas));
+    DEFINE_STATIC_LOCAL(PaintCanvas, nullCanvas, (nullSkCanvas));
     m_canvas = &nullCanvas;
   }
 }
@@ -267,7 +267,7 @@ void GraphicsContext::beginRecording(const FloatRect& bounds) {
     return;
 
   DCHECK(!m_canvas);
-  m_canvas = m_paintRecorder.beginRecording(bounds, nullptr);
+  m_canvas = m_paintRecorder.beginRecording(bounds);
   if (m_hasMetaData)
     m_canvas->getMetaData() = m_metaData;
 }
@@ -276,7 +276,7 @@ namespace {
 
 sk_sp<PaintRecord> createEmptyPaintRecord() {
   PaintRecorder recorder;
-  recorder.beginRecording(SkRect::MakeEmpty(), nullptr);
+  recorder.beginRecording(SkRect::MakeEmpty());
   return recorder.finishRecordingAsPicture();
 }
 
@@ -571,7 +571,7 @@ sk_sp<PaintRecord> recordMarker(
   PaintFlags flags;
   flags.setAntiAlias(true);
   flags.setColor(color);
-  flags.setStyle(SkPaint::kStroke_Style);
+  flags.setStyle(PaintFlags::kStroke_Style);
   flags.setStrokeWidth(kH * 1 / 2);
 
   PaintRecorder recorder;
@@ -656,9 +656,9 @@ void GraphicsContext::drawLineForDocumentMarker(const FloatPoint& pt,
 
   PaintFlags flags;
   flags.setAntiAlias(true);
-  flags.setShader(WrapSkShader(SkShader::MakePictureShader(
-      sk_ref_sp(marker), SkShader::kRepeat_TileMode, SkShader::kClamp_TileMode,
-      &localMatrix, nullptr)));
+  flags.setShader(WrapSkShader(
+      MakePaintShaderRecord(sk_ref_sp(marker), SkShader::kRepeat_TileMode,
+                            SkShader::kClamp_TileMode, &localMatrix, nullptr)));
 
   // Apply the origin translation as a global transform.  This ensures that the
   // shader local matrix depends solely on zoom => Skia can reuse the same
@@ -1260,7 +1260,7 @@ void GraphicsContext::setURLForRect(const KURL& link, const IntRect& destRect) {
   DCHECK(m_canvas);
 
   sk_sp<SkData> url(SkData::MakeWithCString(link.getString().utf8().data()));
-  SkAnnotateRectWithURL(m_canvas, destRect, url.get());
+  PaintCanvasAnnotateRectWithURL(m_canvas, destRect, url.get());
 }
 
 void GraphicsContext::setURLFragmentForRect(const String& destName,
@@ -1270,7 +1270,7 @@ void GraphicsContext::setURLFragmentForRect(const String& destName,
   DCHECK(m_canvas);
 
   sk_sp<SkData> skDestName(SkData::MakeWithCString(destName.utf8().data()));
-  SkAnnotateLinkToDestination(m_canvas, rect, skDestName.get());
+  PaintCanvasAnnotateLinkToDestination(m_canvas, rect, skDestName.get());
 }
 
 void GraphicsContext::setURLDestinationLocation(const String& name,
@@ -1280,7 +1280,7 @@ void GraphicsContext::setURLDestinationLocation(const String& name,
   DCHECK(m_canvas);
 
   sk_sp<SkData> skName(SkData::MakeWithCString(name.utf8().data()));
-  SkAnnotateNamedDestination(
+  PaintCanvasAnnotateNamedDestination(
       m_canvas, SkPoint::Make(location.x(), location.y()), skName.get());
 }
 
diff --git a/third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.cpp b/third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.cpp
index 8e56c8cbbc3773..3abcd1efe80bec 100644
--- a/third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.cpp
+++ b/third_party/WebKit/Source/platform/graphics/RecordingImageBufferSurface.cpp
@@ -99,14 +99,14 @@ void RecordingImageBufferSurface::fallBackToRasterCanvas(
   m_fallbackSurface->setImageBuffer(m_imageBuffer);
 
   if (m_previousFrame) {
-    m_previousFrame->playback(m_fallbackSurface->canvas());
+    m_fallbackSurface->canvas()->drawPicture(m_previousFrame);
     m_previousFrame.reset();
   }
 
   if (m_currentFrame) {
     sk_sp<PaintRecord> record = m_currentFrame->finishRecordingAsPicture();
     if (record)
-      record->playback(m_fallbackSurface->canvas());
+      m_fallbackSurface->canvas()->drawPicture(record);
     m_currentFrame.reset();
   }
 
diff --git a/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.cpp b/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.cpp
index 72474a405f2dd5..3118cad3ee25f2 100644
--- a/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.cpp
+++ b/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.cpp
@@ -31,6 +31,7 @@
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 
 #include "platform/graphics/skia/SkiaUtils.h"
+#include "third_party/skia/include/core/SkSurface.h"
 #include "wtf/PassRefPtr.h"
 
 namespace blink {
@@ -47,24 +48,25 @@ UnacceleratedImageBufferSurface::UnacceleratedImageBufferSurface(
   SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), colorType,
                                        alphaType, colorSpace);
   SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
-  m_surface = PaintSurface::MakeRaster(
-      info, Opaque == opacityMode ? 0 : &disableLCDProps);
+  m_surface =
+      SkSurface::MakeRaster(info, Opaque == opacityMode ? 0 : &disableLCDProps);
+
+  if (!m_surface)
+    return;
 
   // Always save an initial frame, to support resetting the top level matrix
   // and clip.
-  if (m_surface)
-    m_surface->getCanvas()->save();
+  m_canvas = WTF::wrapUnique(new PaintCanvas(m_surface->getCanvas()));
+  m_canvas->save();
 
-  if (initializationMode == InitializeImagePixels) {
-    if (m_surface)
-      clear();
-  }
+  if (initializationMode == InitializeImagePixels)
+    clear();
 }
 
 UnacceleratedImageBufferSurface::~UnacceleratedImageBufferSurface() {}
 
 PaintCanvas* UnacceleratedImageBufferSurface::canvas() {
-  return m_surface->getCanvas();
+  return m_canvas.get();
 }
 
 bool UnacceleratedImageBufferSurface::isValid() const {
diff --git a/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.h b/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.h
index 8c91ce6632e939..f2d03391f91129 100644
--- a/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.h
+++ b/third_party/WebKit/Source/platform/graphics/UnacceleratedImageBufferSurface.h
@@ -33,7 +33,6 @@
 
 #include "platform/graphics/ImageBufferSurface.h"
 #include "platform/graphics/paint/PaintCanvas.h"
-#include "platform/graphics/paint/PaintSurface.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 
 namespace blink {
@@ -58,7 +57,8 @@ class PLATFORM_EXPORT UnacceleratedImageBufferSurface
   sk_sp<SkImage> newImageSnapshot(AccelerationHint, SnapshotReason) override;
 
  private:
-  sk_sp<PaintSurface> m_surface;
+  sk_sp<SkSurface> m_surface;
+  std::unique_ptr<PaintCanvas> m_canvas;
 };
 
 }  // namespace blink
diff --git a/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.cpp b/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.cpp
index 78847f69dcdef6..63f4ca581f0af6 100644
--- a/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.cpp
+++ b/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.cpp
@@ -56,16 +56,18 @@ AcceleratedImageBufferSurface::AcceleratedImageBufferSurface(
   SkImageInfo info = SkImageInfo::Make(size.width(), size.height(), colorType,
                                        alphaType, colorSpace);
   SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
-  m_surface = PaintSurface::MakeRenderTarget(
+  m_surface = SkSurface::MakeRenderTarget(
       grContext, SkBudgeted::kYes, info, 0 /* sampleCount */,
       Opaque == opacityMode ? nullptr : &disableLCDProps);
   if (!m_surface)
     return;
+
+  m_canvas = WTF::wrapUnique(new PaintCanvas(m_surface->getCanvas()));
   clear();
 
   // Always save an initial frame, to support resetting the top level matrix
   // and clip.
-  m_surface->getCanvas()->save();
+  m_canvas->save();
 }
 
 bool AcceleratedImageBufferSurface::isValid() const {
@@ -83,7 +85,7 @@ GLuint AcceleratedImageBufferSurface::getBackingTextureHandleForOverwrite() {
     return 0;
   return skia::GrBackendObjectToGrGLTextureInfo(
              m_surface->getTextureHandle(
-                 PaintSurface::kDiscardWrite_TextureHandleAccess))
+                 SkSurface::kDiscardWrite_TextureHandleAccess))
       ->fID;
 }
 
diff --git a/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.h b/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.h
index 7f388670a7de29..ab8d1f6e23eda1 100644
--- a/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.h
+++ b/third_party/WebKit/Source/platform/graphics/gpu/AcceleratedImageBufferSurface.h
@@ -53,9 +53,7 @@ class PLATFORM_EXPORT AcceleratedImageBufferSurface
                                 SkColorType = kN32_SkColorType);
   ~AcceleratedImageBufferSurface() override {}
 
-  PaintCanvas* canvas() override {
-    return m_surface ? m_surface->getCanvas() : nullptr;
-  }
+  PaintCanvas* canvas() override { return m_canvas.get(); }
   bool isValid() const override;
   bool isAccelerated() const override { return true; }
   sk_sp<SkImage> newImageSnapshot(AccelerationHint, SnapshotReason) override;
@@ -63,7 +61,8 @@ class PLATFORM_EXPORT AcceleratedImageBufferSurface
 
  private:
   unsigned m_contextId;
-  sk_sp<PaintSurface> m_surface;  // Uses m_contextProvider.
+  sk_sp<SkSurface> m_surface;  // Uses m_contextProvider.
+  std::unique_ptr<PaintCanvas> m_canvas;
 };
 
 }  // namespace blink
diff --git a/third_party/WebKit/Source/platform/graphics/paint/PaintCanvas.h b/third_party/WebKit/Source/platform/graphics/paint/PaintCanvas.h
index c31f9ea66fb4ff..02aaae5a3d082c 100644
--- a/third_party/WebKit/Source/platform/graphics/paint/PaintCanvas.h
+++ b/third_party/WebKit/Source/platform/graphics/paint/PaintCanvas.h
@@ -10,7 +10,6 @@
 namespace blink {
 using cc::PaintCanvas;
 using cc::PaintCanvasAutoRestore;
-using cc::PaintCanvasPassThrough;
 using cc::ToPixmap;
 }
 
diff --git a/third_party/WebKit/Source/web/PageWidgetDelegate.cpp b/third_party/WebKit/Source/web/PageWidgetDelegate.cpp
index d69ecb805121c4..27fcf548bf62ca 100644
--- a/third_party/WebKit/Source/web/PageWidgetDelegate.cpp
+++ b/third_party/WebKit/Source/web/PageWidgetDelegate.cpp
@@ -96,7 +96,8 @@ static void paintInternal(Page& page,
       paintContext.fillRect(dirtyRect, Color::white);
     }
   }
-  builder.endRecording()->playback(canvas);
+
+  canvas->drawPicture(builder.endRecording());
 }
 
 void PageWidgetDelegate::paint(Page& page,
diff --git a/third_party/WebKit/Source/web/WebLocalFrameImpl.cpp b/third_party/WebKit/Source/web/WebLocalFrameImpl.cpp
index 6c10f4be03c66f..4deb1c6ba3876f 100644
--- a/third_party/WebKit/Source/web/WebLocalFrameImpl.cpp
+++ b/third_party/WebKit/Source/web/WebLocalFrameImpl.cpp
@@ -307,7 +307,7 @@ class ChromePrintContext : public PrintContext {
     builder.context().setPrinting(true);
 
     float scale = spoolPage(builder, pageNumber);
-    builder.endRecording()->playback(canvas);
+    canvas->drawPicture(builder.endRecording());
     return scale;
   }
 
@@ -374,7 +374,7 @@ class ChromePrintContext : public PrintContext {
         currentHeight += pageSizeInPixels.height() + 1;
       }
     }
-    builder.endRecording()->playback(canvas);
+    canvas->drawPicture(builder.endRecording());
   }
 
  protected:
diff --git a/ui/gfx/paint_vector_icon_unittest.cc b/ui/gfx/paint_vector_icon_unittest.cc
index 6786bf12d0187a..1adbb3fe3c8f14 100644
--- a/ui/gfx/paint_vector_icon_unittest.cc
+++ b/ui/gfx/paint_vector_icon_unittest.cc
@@ -7,6 +7,8 @@
 #include <gtest/gtest.h>
 #include <vector>
 
+#include "cc/paint/paint_record.h"
+#include "cc/paint/paint_recorder.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/gfx/canvas.h"
@@ -36,8 +38,8 @@ class MockCanvas : public SkCanvas {
 // Tests that a relative move to command (R_MOVE_TO) after a close command
 // (CLOSE) uses the correct starting point. See crbug.com/697497
 TEST(VectorIconTest, RelativeMoveToAfterClose) {
-  MockCanvas mock(100, 100);
-  Canvas canvas(&mock, 1.0f);
+  cc::PaintRecorder recorder;
+  Canvas canvas(recorder.beginRecording(100, 100), 1.0f);
 
   const PathElement elements[] = {
       MOVE_TO, 4, 5,
@@ -51,6 +53,11 @@ TEST(VectorIconTest, RelativeMoveToAfterClose) {
   const VectorIcon icon = {elements, nullptr};
 
   PaintVectorIcon(&canvas, icon, 100, SK_ColorMAGENTA);
+  sk_sp<cc::PaintRecord> record = recorder.finishRecordingAsPicture();
+
+  MockCanvas mock(100, 100);
+  record->playback(&mock);
+
   ASSERT_EQ(1U, mock.paths().size());
   SkPoint last_point;
   EXPECT_TRUE(mock.paths()[0].getLastPt(&last_point));