cc: Fix data race in PaintOpBuffer by not mutating PaintOps.

cc/paint/paint_op_buffer.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_OP_BUFFER_H_
 #define CC_PAINT_PAINT_OP_BUFFER_H_
 
 #include <stdint.h>
 
 #include "base/logging.h"
@@ skipping 61 matching lines @@
   Translate,
   LastPaintOpType = Translate,
 };
 
 struct CC_PAINT_EXPORT PaintOp {
   uint32_t type : 8;
   uint32_t skip : 24;
 
   PaintOpType GetType() const { return static_cast<PaintOpType>(type); }
 
+  // Subclasses should provide a static Raster() method which is called from
+  // here. The Raster method should take a const PaintOp* parameter. It is
+  // static with a pointer to the base type so that we can use it as a function
+  // pointer.
   void Raster(SkCanvas* canvas, const SkMatrix& original_ctm) const;
   bool IsDrawOp() const;
 
   // Only valid for draw ops.
   void RasterWithAlpha(SkCanvas* canvas, uint8_t alpha) const;
 
   int CountSlowPaths() const { return 0; }
   int CountSlowPathsFromFlags() const { return 0; }
 
   // Returns the number of bytes used by this op in referenced sub records
   // and display lists.  This doesn't count other objects like paths or blobs.
   size_t AdditionalBytesUsed() const { return 0; }
 
   static constexpr bool kIsDrawOp = false;
   static constexpr bool kHasPaintFlags = false;
   static SkRect kUnsetRect;
 };
 
 struct CC_PAINT_EXPORT PaintOpWithFlags : PaintOp {
   static constexpr bool kHasPaintFlags = true;
 
   explicit PaintOpWithFlags(const PaintFlags& flags) : flags(flags) {}
 
   int CountSlowPathsFromFlags() const { return flags.getPathEffect() ? 1 : 0; }
 
+  // Subclasses should provide a static RasterWithFlags() method which is called
+  // from the Raster() method. The RasterWithFlags() should use the PaintFlags
+  // passed to it, instead of the |flags| member directly, as some callers may
+  // provide a modified PaintFlags. The RasterWithFlags() method is static with
+  // a const PaintOpWithFlags* parameter so that it can be used as a function
+  // pointer.
   PaintFlags flags;
 };
 
 struct CC_PAINT_EXPORT PaintOpWithData : PaintOpWithFlags {
   // Having data is just a helper for ops that have a varying amount of data and
   // want a way to store that inline.  This is for ops that pass in a
   // void* and a length.  The void* data is assumed to not have any alignment
   // requirements.
   PaintOpWithData(const PaintFlags& flags, size_t bytes)
       : PaintOpWithFlags(flags), bytes(bytes) {}
@@ skipping 165 matching lines @@
             SkScalar sweep_angle,
             bool use_center,
             const PaintFlags& flags)
       : PaintOpWithFlags(flags),
         oval(oval),
         start_angle(start_angle),
         sweep_angle(sweep_angle),
         use_center(use_center) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkRect oval;
   SkScalar start_angle;
   SkScalar sweep_angle;
   bool use_center;
 };
 
 struct CC_PAINT_EXPORT DrawCircleOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawCircle;
   static constexpr bool kIsDrawOp = true;
   DrawCircleOp(SkScalar cx,
                SkScalar cy,
                SkScalar radius,
                const PaintFlags& flags)
       : PaintOpWithFlags(flags), cx(cx), cy(cy), radius(radius) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkScalar cx;
   SkScalar cy;
   SkScalar radius;
 };
 
 struct CC_PAINT_EXPORT DrawColorOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawColor;
   static constexpr bool kIsDrawOp = true;
   DrawColorOp(SkColor color, SkBlendMode mode) : color(color), mode(mode) {}
@@ skipping 26 matching lines @@
 
 struct CC_PAINT_EXPORT DrawDRRectOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawDRRect;
   static constexpr bool kIsDrawOp = true;
   DrawDRRectOp(const SkRRect& outer,
                const SkRRect& inner,
                const PaintFlags& flags)
       : PaintOpWithFlags(flags), outer(outer), inner(inner) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkRRect outer;
   SkRRect inner;
 };
 
 struct CC_PAINT_EXPORT DrawImageOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawImage;
   static constexpr bool kIsDrawOp = true;
   DrawImageOp(const PaintImage& image,
               SkScalar left,
               SkScalar top,
               const PaintFlags* flags);
   ~DrawImageOp();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   PaintImage image;
   SkScalar left;
   SkScalar top;
 };
 
 struct CC_PAINT_EXPORT DrawImageRectOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawImageRect;
   static constexpr bool kIsDrawOp = true;
   DrawImageRectOp(const PaintImage& image,
                   const SkRect& src,
                   const SkRect& dst,
                   const PaintFlags* flags,
                   PaintCanvas::SrcRectConstraint constraint);
   ~DrawImageRectOp();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   PaintImage image;
   SkRect src;
   SkRect dst;
   PaintCanvas::SrcRectConstraint constraint;
 };
 
 struct CC_PAINT_EXPORT DrawIRectOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawIRect;
   static constexpr bool kIsDrawOp = true;
   DrawIRectOp(const SkIRect& rect, const PaintFlags& flags)
       : PaintOpWithFlags(flags), rect(rect) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkIRect rect;
 };
 
 struct CC_PAINT_EXPORT DrawLineOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawLine;
   static constexpr bool kIsDrawOp = true;
   DrawLineOp(SkScalar x0,
              SkScalar y0,
              SkScalar x1,
              SkScalar y1,
              const PaintFlags& flags)
       : PaintOpWithFlags(flags), x0(x0), y0(y0), x1(x1), y1(y1) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
+
   int CountSlowPaths() const;
 
   SkScalar x0;
   SkScalar y0;
   SkScalar x1;
   SkScalar y1;
 };
 
 struct CC_PAINT_EXPORT DrawOvalOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawOval;
   static constexpr bool kIsDrawOp = true;
   DrawOvalOp(const SkRect& oval, const PaintFlags& flags)
       : PaintOpWithFlags(flags), oval(oval) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkRect oval;
 };
 
 struct CC_PAINT_EXPORT DrawPathOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawPath;
   static constexpr bool kIsDrawOp = true;
   DrawPathOp(const SkPath& path, const PaintFlags& flags)
       : PaintOpWithFlags(flags), path(path) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
   int CountSlowPaths() const;
 
   ThreadsafePath path;
 };
 
 struct CC_PAINT_EXPORT DrawPosTextOp final : PaintOpWithArray<SkPoint> {
   static constexpr PaintOpType kType = PaintOpType::DrawPosText;
   static constexpr bool kIsDrawOp = true;
   DrawPosTextOp(size_t bytes, size_t count, const PaintFlags& flags);
   ~DrawPosTextOp();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
+
   const void* GetData() const { return GetDataForThis(this); }
   void* GetData() { return GetDataForThis(this); }
   const SkPoint* GetArray() const { return GetArrayForThis(this); }
   SkPoint* GetArray() { return GetArrayForThis(this); }
 };
 
 struct CC_PAINT_EXPORT DrawRecordOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawRecord;
   static constexpr bool kIsDrawOp = true;
   explicit DrawRecordOp(sk_sp<const PaintRecord> record);
   ~DrawRecordOp();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
   size_t AdditionalBytesUsed() const;
 
   sk_sp<const PaintRecord> record;
 };
 
 struct CC_PAINT_EXPORT DrawRectOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawRect;
   static constexpr bool kIsDrawOp = true;
   DrawRectOp(const SkRect& rect, const PaintFlags& flags)
       : PaintOpWithFlags(flags), rect(rect) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkRect rect;
 };
 
 struct CC_PAINT_EXPORT DrawRRectOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawRRect;
   static constexpr bool kIsDrawOp = true;
   DrawRRectOp(const SkRRect& rrect, const PaintFlags& flags)
       : PaintOpWithFlags(flags), rrect(rrect) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkRRect rrect;
 };
 
 struct CC_PAINT_EXPORT DrawTextOp final : PaintOpWithData {
   static constexpr PaintOpType kType = PaintOpType::DrawText;
   static constexpr bool kIsDrawOp = true;
   DrawTextOp(size_t bytes, SkScalar x, SkScalar y, const PaintFlags& flags)
       : PaintOpWithData(flags, bytes), x(x), y(y) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   void* GetData() { return GetDataForThis(this); }
   const void* GetData() const { return GetDataForThis(this); }
 
   SkScalar x;
   SkScalar y;
 };
 
 struct CC_PAINT_EXPORT DrawTextBlobOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawTextBlob;
   static constexpr bool kIsDrawOp = true;
   DrawTextBlobOp(sk_sp<SkTextBlob> blob,
                  SkScalar x,
                  SkScalar y,
                  const PaintFlags& flags);
   ~DrawTextBlobOp();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   sk_sp<SkTextBlob> blob;
   SkScalar x;
   SkScalar y;
 };
 
 struct CC_PAINT_EXPORT NoopOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Noop;
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
@@ skipping 24 matching lines @@
                      const SkMatrix& original_ctm);
 };
 
 struct CC_PAINT_EXPORT SaveLayerOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::SaveLayer;
   SaveLayerOp(const SkRect* bounds, const PaintFlags* flags)
       : PaintOpWithFlags(flags ? *flags : PaintFlags()),
         bounds(bounds ? *bounds : kUnsetRect) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
-                     const SkMatrix& original_ctm);
+                     const SkMatrix& original_ctm) {
+    auto* flags_op = static_cast<const PaintOpWithFlags*>(op);
+    RasterWithFlags(flags_op, &flags_op->flags, canvas, original_ctm);
+  }
+  static void RasterWithFlags(const PaintOpWithFlags* op,
+                              const PaintFlags* flags,
+                              SkCanvas* canvas,
+                              const SkMatrix& original_ctm);
 
   SkRect bounds;
 };
 
 struct CC_PAINT_EXPORT SaveLayerAlphaOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::SaveLayerAlpha;
   SaveLayerAlphaOp(const SkRect* bounds, uint8_t alpha)
       : bounds(bounds ? *bounds : kUnsetRect), alpha(alpha) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
@@ skipping 243 matching lines @@
   // Record additional bytes used by referenced sub-records and display lists.
   size_t subrecord_bytes_used_ = 0;
   SkRect cull_rect_;
 
   DISALLOW_COPY_AND_ASSIGN(PaintOpBuffer);
 };
 
 }  // namespace cc
 
 #endif  // CC_PAINT_PAINT_OP_BUFFER_H_