Back PaintRecord with PaintOpBuffer instead of SkPicture

cc/paint/record_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_SKIA_PAINT_CANVAS_H_
-#define CC_PAINT_SKIA_PAINT_CANVAS_H_
+#ifndef CC_PAINT_RECORD_PAINT_CANVAS_H_
+#define CC_PAINT_RECORD_PAINT_CANVAS_H_
 
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/optional.h"
 #include "build/build_config.h"
 #include "cc/paint/paint_canvas.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 PaintOpBuffer;
 class PaintFlags;
 
-// A PaintCanvas derived class that passes PaintCanvas APIs through to
-// an SkCanvas.  This is more efficient than recording to a PaintRecord
-// and then playing back to an SkCanvas.
-class CC_PAINT_EXPORT SkiaPaintCanvas final : public PaintCanvas {
+class CC_PAINT_EXPORT RecordPaintCanvas final : public PaintCanvas {
  public:
-  explicit SkiaPaintCanvas(SkCanvas* canvas);
-  explicit SkiaPaintCanvas(const SkBitmap& bitmap);
-  explicit SkiaPaintCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props);
-  explicit SkiaPaintCanvas(SkiaPaintCanvas&& other);
-  ~SkiaPaintCanvas() override;
-
-  SkiaPaintCanvas& operator=(SkiaPaintCanvas&& other) = default;
+  explicit RecordPaintCanvas(PaintOpBuffer* buffer);
+  ~RecordPaintCanvas() override;
 
   SkMetaData& getMetaData() override;
   SkImageInfo imageInfo() const override;
 
   void flush() override;
 
   int save() override;
   int saveLayer(const SkRect* bounds, const PaintFlags* flags) override;
-  int saveLayerAlpha(const SkRect* bounds, U8CPU alpha) override;
+  int saveLayerAlpha(const SkRect* bounds, uint8_t alpha) override;
 
   void restore() override;
   int getSaveCount() const override;
   void restoreToCount(int save_count) override;
   void translate(SkScalar dx, SkScalar dy) override;
   void scale(SkScalar sx, SkScalar sy) override;
   void rotate(SkScalar degrees) override;
   void concat(const SkMatrix& matrix) override;
   void setMatrix(const SkMatrix& matrix) override;
 
-  void clipRect(const SkRect& rect, SkClipOp op, bool do_anti_alias) override;
-  void clipRRect(const SkRRect& rrect,
-                 SkClipOp op,
-                 bool do_anti_alias) override;
-  void clipPath(const SkPath& path, SkClipOp op, bool do_anti_alias) override;
+  void clipRect(const SkRect& rect, SkClipOp op, bool antialias) override;
+  void clipRRect(const SkRRect& rrect, SkClipOp op, bool antialias) override;
+  void clipPath(const SkPath& path, SkClipOp op, bool antialias) override;
   bool quickReject(const SkRect& rect) const override;
   bool quickReject(const SkPath& path) const override;
   SkRect getLocalClipBounds() const override;
   bool getLocalClipBounds(SkRect* bounds) const override;
   SkIRect getDeviceClipBounds() const override;
   bool getDeviceClipBounds(SkIRect* bounds) const override;
   void drawColor(SkColor color, SkBlendMode mode) override;
   void clear(SkColor color) override;
 
   void drawLine(SkScalar x0,
@@ skipping 68 matching lines @@
   // Don't shadow non-virtual helper functions.
   using PaintCanvas::clipRect;
   using PaintCanvas::clipRRect;
   using PaintCanvas::clipPath;
   using PaintCanvas::drawBitmap;
   using PaintCanvas::drawColor;
   using PaintCanvas::drawImage;
   using PaintCanvas::drawPicture;
 
  private:
-  SkCanvas* canvas_;
-  std::unique_ptr<SkCanvas> owned_;
+  const SkNoDrawCanvas* GetCanvas() const;
+  SkNoDrawCanvas* GetCanvas();
 
-  DISALLOW_COPY_AND_ASSIGN(SkiaPaintCanvas);
+  PaintOpBuffer* buffer_;
+
+  // TODO(enne): Although RecordPaintCanvas is mostly a write-only interface
+  // where paint commands are stored, occasionally users of PaintCanvas want
+  // to ask stateful questions mid-stream of clip and transform state.
+  // To avoid duplicating all this code (for now?), just forward to an SkCanvas
+  // that's not backed by anything but can answer these questions.
+  //
+  // This is mutable so that const functions (e.g. quickReject) that may
+  // lazy initialize the canvas can still be const.
+  mutable base::Optional<SkNoDrawCanvas> canvas_;

[enne (OOO), 2017/04/25 19:47:14]

It looks like all the blink_perf.paint regressions were due to the SkCanvas
initialization for every RecordPaintCanvas.

One approach which helped quite a bit was to have PaintRecorder own the canvas
and then resetForNextPicture (via https://skia-review.googlesource.com/c/11320/)
between recordings (when the PaintRecorder is reused).

The approach used here is to make the canvas optional per RecordPaintCanvas,
which addresses perf issues when the canvas isn't needed (such as on very common
single ops) and should fix the blink_perf.paint issues.

I think a followup is to combine these approaches (keep it optional, but store
it on the PaintRecorder) if the skia patch lands.

 };
 
 }  // namespace cc
 
-#endif  // CC_PAINT_SKIA_PAINT_CANVAS_H_
+#endif  // CC_PAINT_RECORD_PAINT_CANVAS_H_