cc: Make PaintCanvas abstract

cc/paint/paint_canvas.h

 // 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.
 
 #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/SkNoDrawCanvas.h"
 
 namespace cc {
 
 class PaintFlags;
 
 class CC_PAINT_EXPORT PaintCanvas {
  public:
-  // 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();
+  virtual SkMetaData& getMetaData() = 0;
+  virtual SkImageInfo imageInfo() const = 0;
 
-  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(); }
+  virtual void flush() = 0;
 
-  ALWAYS_INLINE SkISize getBaseLayerSize() const {
-    return canvas_->getBaseLayerSize();
+  virtual SkISize getBaseLayerSize() const = 0;
+  virtual bool peekPixels(SkPixmap* pixmap) = 0;
+  virtual bool readPixels(const SkImageInfo& dest_info,
+                          void* dest_pixels,
+                          size_t dest_row_bytes,
+                          int src_x,
+                          int src_y) = 0;
+  virtual bool readPixels(SkBitmap* bitmap, int src_x, int src_y) = 0;
+  virtual bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap) = 0;
+  virtual bool writePixels(const SkImageInfo& info,
+                           const void* pixels,
+                           size_t row_bytes,
+                           int x,
+                           int y) = 0;
+  virtual int save() = 0;
+  virtual int saveLayer(const SkRect* bounds, const PaintFlags* flags) = 0;
+  virtual int saveLayerAlpha(const SkRect* bounds, U8CPU alpha) = 0;
+
+  virtual void restore() = 0;
+  virtual int getSaveCount() const = 0;
+  virtual void restoreToCount(int save_count) = 0;
+  virtual void translate(SkScalar dx, SkScalar dy) = 0;
+  virtual void scale(SkScalar sx, SkScalar sy) = 0;
+  virtual void rotate(SkScalar degrees) = 0;
+  virtual void rotate(SkScalar degrees, SkScalar px, SkScalar py) = 0;
+  virtual void concat(const SkMatrix& matrix) = 0;
+  virtual void setMatrix(const SkMatrix& matrix) = 0;
+  virtual void resetMatrix() = 0;
+
+  virtual void clipRect(const SkRect& rect,
+                        SkClipOp op,
+                        bool do_anti_alias) = 0;
+  void clipRect(const SkRect& rect, SkClipOp op) { clipRect(rect, op, false); }
+  void clipRect(const SkRect& rect, bool do_anti_alias) {
+    clipRect(rect, SkClipOp::kIntersect, do_anti_alias);
   }
-  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);
+  void clipRect(const SkRect& rect) {
+    clipRect(rect, SkClipOp::kIntersect, false);
   }
 
-  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);
+  virtual void clipRRect(const SkRRect& rrect,
+                         SkClipOp op,
+                         bool do_anti_alias) = 0;
+  void clipRRect(const SkRRect& rrect, bool do_anti_alias) {
+    clipRRect(rrect, SkClipOp::kIntersect, do_anti_alias);
   }
-  ALWAYS_INLINE void translate(SkScalar dx, SkScalar dy) {
-    canvas_->translate(dx, dy);
+  void clipRRect(const SkRRect& rrect, SkClipOp op) {
+    clipRRect(rrect, op, false);
   }
-  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);
+  void clipRRect(const SkRRect& rrect) {
+    clipRRect(rrect, SkClipOp::kIntersect, false);
   }
-  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);
+
+  virtual void clipPath(const SkPath& path,
+                        SkClipOp op,
+                        bool do_anti_alias) = 0;
+  void clipPath(const SkPath& path, SkClipOp op) { clipPath(path, op, false); }
+  void clipPath(const SkPath& path, bool do_anti_alias) {
+    clipPath(path, SkClipOp::kIntersect, do_anti_alias);
   }
-  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);
+
+  virtual bool quickReject(const SkRect& rect) const = 0;
+  virtual bool quickReject(const SkPath& path) const = 0;
+  virtual SkRect getLocalClipBounds() const = 0;
+  virtual bool getLocalClipBounds(SkRect* bounds) const = 0;
+  virtual SkIRect getDeviceClipBounds() const = 0;
+  virtual bool getDeviceClipBounds(SkIRect* bounds) const = 0;
+  virtual void drawColor(SkColor color, SkBlendMode mode) = 0;
+  void drawColor(SkColor color) { drawColor(color, SkBlendMode::kSrcOver); }
+  virtual void clear(SkColor color) = 0;
+
+  virtual void drawLine(SkScalar x0,
+                        SkScalar y0,
+                        SkScalar x1,
+                        SkScalar y1,
+                        const PaintFlags& flags) = 0;
+  virtual void drawRect(const SkRect& rect, const PaintFlags& flags) = 0;
+  virtual void drawIRect(const SkIRect& rect, const PaintFlags& flags) = 0;
+  virtual void drawOval(const SkRect& oval, const PaintFlags& flags) = 0;
+  virtual void drawRRect(const SkRRect& rrect, const PaintFlags& flags) = 0;
+  virtual void drawDRRect(const SkRRect& outer,
+                          const SkRRect& inner,
+                          const PaintFlags& flags) = 0;
+  virtual void drawCircle(SkScalar cx,
+                          SkScalar cy,
+                          SkScalar radius,
+                          const PaintFlags& flags) = 0;
+  virtual void drawArc(const SkRect& oval,
+                       SkScalar start_angle,
+                       SkScalar sweep_angle,
+                       bool use_center,
+                       const PaintFlags& flags) = 0;
+  virtual void drawRoundRect(const SkRect& rect,
+                             SkScalar rx,
+                             SkScalar ry,
+                             const PaintFlags& flags) = 0;
+  virtual void drawPath(const SkPath& path, const PaintFlags& flags) = 0;
+  virtual void drawImage(const SkImage* image,
+                         SkScalar left,
+                         SkScalar top,
+                         const PaintFlags* flags) = 0;
+  void drawImage(const SkImage* image, SkScalar left, SkScalar top) {
+    drawImage(image, left, top, nullptr);
   }
-  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));
+  virtual void drawImage(const sk_sp<SkImage>& image,
+                         SkScalar left,
+                         SkScalar top,
+                         const PaintFlags* flags) = 0;
+  void drawImage(const sk_sp<SkImage>& image, SkScalar left, SkScalar top) {
+    drawImage(image, left, top, nullptr);
   }
 
   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));
+  virtual void drawImageRect(const SkImage* image,
+                             const SkRect& src,
+                             const SkRect& dst,
+                             const PaintFlags* flags,
+                             SrcRectConstraint constraint) = 0;
+  virtual void drawBitmap(const SkBitmap& bitmap,
+                          SkScalar left,
+                          SkScalar top,
+                          const PaintFlags* flags) = 0;
+  void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top) {
+    drawBitmap(bitmap, left, top, nullptr);
   }
 
-  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));
-  }
+  virtual void drawText(const void* text,
+                        size_t byte_length,
+                        SkScalar x,
+                        SkScalar y,
+                        const PaintFlags& flags) = 0;
+  virtual void drawPosText(const void* text,
+                           size_t byte_length,
+                           const SkPoint pos[],
+                           const PaintFlags& flags) = 0;
+  virtual void drawTextBlob(const SkTextBlob* blob,
+                            SkScalar x,
+                            SkScalar y,
+                            const PaintFlags& flags) = 0;
+  virtual void drawTextBlob(const sk_sp<SkTextBlob>& blob,
+                            SkScalar x,
+                            SkScalar y,
+                            const PaintFlags& flags) = 0;
 
-  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());
-  }
+  virtual void drawPicture(const PaintRecord* record) = 0;
+  virtual void drawPicture(const PaintRecord* record,
+                           const SkMatrix* matrix,
+                           const PaintFlags* flags) = 0;
+  virtual void drawPicture(sk_sp<PaintRecord> record) = 0;
 
-  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();
-  }
+  virtual bool isClipEmpty() const = 0;
+  virtual bool isClipRect() const = 0;
+  virtual const SkMatrix& getTotalMatrix() const = 0;
 
   // 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);
-  }
+  virtual void temporary_internal_describeTopLayer(SkMatrix* matrix,
+                                                   SkIRect* clip_bounds) = 0;
+
+  virtual bool ToPixmap(SkPixmap* output) = 0;
+  virtual void AnnotateRectWithURL(const SkRect& rect, SkData* data) = 0;
+  virtual void AnnotateNamedDestination(const SkPoint& point, SkData* data) = 0;
+  virtual void AnnotateLinkToDestination(const SkRect& rect, SkData* data) = 0;
 
  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);
 };
 
 class CC_PAINT_EXPORT PaintCanvasAutoRestore {
  public:
-  ALWAYS_INLINE PaintCanvasAutoRestore(PaintCanvas* canvas, bool save)
-      : canvas_(canvas) {
+  PaintCanvasAutoRestore(PaintCanvas* canvas, bool save) : canvas_(canvas) {
     if (canvas_) {
       save_count_ = canvas_->getSaveCount();
       if (save) {
         canvas_->save();
       }
     }
   }
 
-  ALWAYS_INLINE ~PaintCanvasAutoRestore() {
+  ~PaintCanvasAutoRestore() {
     if (canvas_) {
       canvas_->restoreToCount(save_count_);
     }
   }
 
-  ALWAYS_INLINE void restore() {
+  void restore() {
     if (canvas_) {
       canvas_->restoreToCount(save_count_);
       canvas_ = nullptr;
     }
   }
 
  private:
   PaintCanvas* canvas_ = nullptr;
   int save_count_ = 0;
 };
@@ skipping 21 matching lines @@
                                                          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_