Fix crash in PaintOpBuffer alpha optimization

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"
 #include "cc/paint/paint_canvas.h"
 #include "cc/paint/paint_export.h"
 #include "cc/paint/paint_flags.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkTextBlob.h"
 
 // PaintOpBuffer is a reimplementation of SkLiteDL.
 // See: third_party/skia/src/core/SkLiteDL.h.
 
 namespace cc {
 
 class DisplayItemList;
 
-class ThreadsafeMatrix : public SkMatrix {
+class CC_PAINT_EXPORT ThreadsafeMatrix : public SkMatrix {
  public:
   explicit ThreadsafeMatrix(const SkMatrix& matrix) : SkMatrix(matrix) {
     (void)getType();
   }
 };
 
-class ThreadsafePath : public SkPath {
+class CC_PAINT_EXPORT ThreadsafePath : public SkPath {
  public:
   explicit ThreadsafePath(const SkPath& path) : SkPath(path) {
     updateBoundsCache();
   }
 };
 
 enum class PaintOpType : uint8_t {
   Annotate,
   ClipPath,
   ClipRect,
@@ skipping 47 matching lines @@
   size_t AdditionalBytesUsed() const { return 0; }
 
   static constexpr bool kIsDrawOp = false;
   // If an op has |kHasPaintFlags| set to true, it must:
   // (1) Provide a PaintFlags member called |flags|
   // (2) Provide a RasterWithFlags function instead of a Raster function.
   static constexpr bool kHasPaintFlags = false;
   static SkRect kUnsetRect;
 };
 
-struct PaintOpWithData : PaintOp {
+struct CC_PAINT_EXPORT PaintOpWithData : PaintOp {
   // 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.
   explicit PaintOpWithData(size_t bytes) : bytes(bytes) {}
 
   // Get data out by calling paint_op_data.  This can't be part of the class
   // because it needs to know the size of the derived type.
   size_t bytes;
 };
 
 template <typename T>
 const void* paint_op_data(const T* op) {
   static_assert(std::is_convertible<T, PaintOpWithData>::value,
                 "T is not a PaintOpWithData");
   // Arbitrary data for a PaintOp is stored after the PaintOp itself
   // in the PaintOpBuffer.  Therefore, to access this data, it's
   // pointer math to increment past the size of T.  Accessing the
   // next op in the buffer is ((char*)op) + op->skip, with the data
   // fitting between.
   return op + 1;
 }
 
 template <typename T>
 void* paint_op_data(T* op) {
   static_assert(std::is_convertible<T, PaintOpWithData>::value,
                 "T is not a PaintOpWithData");
   return op + 1;
 }
 
-struct PaintOpWithDataArrayBase : PaintOpWithData {
+struct CC_PAINT_EXPORT PaintOpWithDataArrayBase : PaintOpWithData {
   // Helper class for static asserts in push functions.
   using PaintOpWithData::PaintOpWithData;
 };
 
 template <typename T>
-struct PaintOpWithDataArray : PaintOpWithDataArrayBase {
+struct CC_PAINT_EXPORT PaintOpWithDataArray : PaintOpWithDataArrayBase {
   // Paint op that has a T[count] and a char[bytes].
   PaintOpWithDataArray(size_t bytes, size_t count)
       : PaintOpWithDataArrayBase(bytes), count(count) {}
   // Use paint_op_array to get array data.
 
   size_t count;
 };
 
 template <typename M, typename T>
 const M* paint_op_array(const T* op) {
   static_assert(std::is_convertible<T, PaintOpWithDataArrayBase>::value,
                 "T is not a PaintOpWithDataArray");
   // See comment in paint_op_data.  Array data is stored after
   // any void* data.  Memory layout here is: |op|data|array data|next op|
   return SkTAddOffset<const M>(op + 1, op->bytes);
 }
 template <typename M, typename T>
 M* paint_op_array(T* op) {
   static_assert(std::is_convertible<T, PaintOpWithDataArrayBase>::value,
                 "T is not a PaintOpWithDataArray");
   return SkTAddOffset<M>(op + 1, op->bytes);
 }
 
-struct AnnotateOp final : PaintOp {
+struct CC_PAINT_EXPORT AnnotateOp final : PaintOp {
   enum class AnnotationType {
     URL,
     LinkToDestination,
     NamedDestination,
   };
 
   static constexpr PaintOpType kType = PaintOpType::Annotate;
   AnnotateOp(PaintCanvas::AnnotationType annotation_type,
              const SkRect& rect,
              sk_sp<SkData> data);
   ~AnnotateOp();
   void Raster(SkCanvas* canvas) const;
 
   PaintCanvas::AnnotationType annotation_type;
   SkRect rect;
   sk_sp<SkData> data;
 };
 
-struct ClipPathOp final : PaintOp {
+struct CC_PAINT_EXPORT ClipPathOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::ClipPath;
   ClipPathOp(SkPath path, SkClipOp op, bool antialias)
       : path(path), op(op), antialias(antialias) {}
   void Raster(SkCanvas* canvas) const;
   int CountSlowPaths() const;
 
   ThreadsafePath path;
   SkClipOp op;
   bool antialias;
 };
 
-struct ClipRectOp final : PaintOp {
+struct CC_PAINT_EXPORT ClipRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::ClipRect;
   ClipRectOp(const SkRect& rect, SkClipOp op, bool antialias)
       : rect(rect), op(op), antialias(antialias) {}
   void Raster(SkCanvas* canvas) const;
 
   SkRect rect;
   SkClipOp op;
   bool antialias;
 };
 
-struct ClipRRectOp final : PaintOp {
+struct CC_PAINT_EXPORT ClipRRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::ClipRRect;
   ClipRRectOp(const SkRRect& rrect, SkClipOp op, bool antialias)
       : rrect(rrect), op(op), antialias(antialias) {}
   void Raster(SkCanvas* canvas) const;
 
   SkRRect rrect;
   SkClipOp op;
   bool antialias;
 };
 
-struct ConcatOp final : PaintOp {
+struct CC_PAINT_EXPORT ConcatOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Concat;
   explicit ConcatOp(const SkMatrix& matrix) : matrix(matrix) {}
   void Raster(SkCanvas* canvas) const;
 
   ThreadsafeMatrix matrix;
 };
 
-struct DrawArcOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawArcOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawArc;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawArcOp(const SkRect& oval,
             SkScalar start_angle,
             SkScalar sweep_angle,
             bool use_center,
             const PaintFlags& flags)
       : oval(oval),
         start_angle(start_angle),
         sweep_angle(sweep_angle),
         use_center(use_center),
         flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkRect oval;
   SkScalar start_angle;
   SkScalar sweep_angle;
   bool use_center;
   PaintFlags flags;
 };
 
-struct DrawCircleOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawCircleOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawCircle;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawCircleOp(SkScalar cx,
                SkScalar cy,
                SkScalar radius,
                const PaintFlags& flags)
       : cx(cx), cy(cy), radius(radius), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkScalar cx;
   SkScalar cy;
   SkScalar radius;
   PaintFlags flags;
 };
 
-struct DrawColorOp final : PaintOp {
+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) {}
   void Raster(SkCanvas* canvas) const;
 
   SkColor color;
   SkBlendMode mode;
 };
 
-struct DrawDisplayItemListOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawDisplayItemListOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawDisplayItemList;
   static constexpr bool kIsDrawOp = true;
   explicit DrawDisplayItemListOp(scoped_refptr<DisplayItemList> list);
+  // Windows wants to generate these when types are exported, so
+  // provide them here explicitly so that DisplayItemList doesn't have
+  // to be defined in this header.
+  DrawDisplayItemListOp(const DrawDisplayItemListOp& op);
+  DrawDisplayItemListOp& operator=(const DrawDisplayItemListOp& op);
   ~DrawDisplayItemListOp();
   void Raster(SkCanvas* canvas) const;
   size_t AdditionalBytesUsed() const;
   // TODO(enne): DisplayItemList should know number of slow paths.
 
   scoped_refptr<DisplayItemList> list;
 };
 
-struct DrawDRRectOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawDRRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawDRRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawDRRectOp(const SkRRect& outer,
                const SkRRect& inner,
                const PaintFlags& flags)
       : outer(outer), inner(inner), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkRRect outer;
   SkRRect inner;
   PaintFlags flags;
 };
 
-struct DrawImageOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawImageOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawImage;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawImageOp(const PaintImage& image,
               SkScalar left,
               SkScalar top,
               const PaintFlags* flags);
   ~DrawImageOp();
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   PaintImage image;
   SkScalar left;
   SkScalar top;
   PaintFlags flags;
 };
 
-struct DrawImageRectOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawImageRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawImageRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawImageRectOp(const PaintImage& image,
                   const SkRect& src,
                   const SkRect& dst,
                   const PaintFlags* flags,
                   PaintCanvas::SrcRectConstraint constraint);
   ~DrawImageRectOp();
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   PaintImage image;
   PaintFlags flags;
   SkRect src;
   SkRect dst;
   PaintCanvas::SrcRectConstraint constraint;
 };
 
-struct DrawIRectOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawIRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawIRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawIRectOp(const SkIRect& rect, const PaintFlags& flags)
       : rect(rect), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkIRect rect;
   PaintFlags flags;
 };
 
-struct DrawLineOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawLineOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawLine;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawLineOp(SkScalar x0,
              SkScalar y0,
              SkScalar x1,
              SkScalar y1,
              const PaintFlags& flags)
       : x0(x0), y0(y0), x1(x1), y1(y1), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
   int CountSlowPaths() const;
 
   SkScalar x0;
   SkScalar y0;
   SkScalar x1;
   SkScalar y1;
   PaintFlags flags;
 };
 
-struct DrawOvalOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawOvalOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawOval;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawOvalOp(const SkRect& oval, const PaintFlags& flags)
       : oval(oval), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkRect oval;
   PaintFlags flags;
 };
 
-struct DrawPathOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawPathOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawPath;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawPathOp(const SkPath& path, const PaintFlags& flags)
       : path(path), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
   int CountSlowPaths() const;
 
   ThreadsafePath path;
   PaintFlags flags;
 };
 
-struct DrawPosTextOp final : PaintOpWithDataArray<SkPoint> {
+struct CC_PAINT_EXPORT DrawPosTextOp final : PaintOpWithDataArray<SkPoint> {
   static constexpr PaintOpType kType = PaintOpType::DrawPosText;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawPosTextOp(size_t bytes, size_t count, const PaintFlags& flags);
   ~DrawPosTextOp();
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   PaintFlags flags;
 };
 
-struct DrawRecordOp final : PaintOp {
+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();
   void Raster(SkCanvas* canvas) const;
   size_t AdditionalBytesUsed() const;
 
   sk_sp<const PaintRecord> record;
 };
 
-struct DrawRectOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawRectOp(const SkRect& rect, const PaintFlags& flags)
       : rect(rect), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkRect rect;
   PaintFlags flags;
 };
 
-struct DrawRRectOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawRRectOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawRRect;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawRRectOp(const SkRRect& rrect, const PaintFlags& flags)
       : rrect(rrect), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkRRect rrect;
   PaintFlags flags;
 };
 
-struct DrawTextOp final : PaintOpWithData {
+struct CC_PAINT_EXPORT DrawTextOp final : PaintOpWithData {
   static constexpr PaintOpType kType = PaintOpType::DrawText;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawTextOp(size_t bytes, SkScalar x, SkScalar y, const PaintFlags& flags)
       : PaintOpWithData(bytes), x(x), y(y), flags(flags) {}
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkScalar x;
   SkScalar y;
   PaintFlags flags;
 };
 
-struct DrawTextBlobOp final : PaintOp {
+struct CC_PAINT_EXPORT DrawTextBlobOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::DrawTextBlob;
   static constexpr bool kIsDrawOp = true;
   static constexpr bool kHasPaintFlags = true;
   DrawTextBlobOp(sk_sp<SkTextBlob> blob,
                  SkScalar x,
                  SkScalar y,
                  const PaintFlags& flags);
   ~DrawTextBlobOp();
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   sk_sp<SkTextBlob> blob;
   SkScalar x;
   SkScalar y;
   PaintFlags flags;
 };
 
-struct NoopOp final : PaintOp {
+struct CC_PAINT_EXPORT NoopOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Noop;
   void Raster(SkCanvas* canvas) const {}
 };
 
-struct RestoreOp final : PaintOp {
+struct CC_PAINT_EXPORT RestoreOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Restore;
   void Raster(SkCanvas* canvas) const;
 };
 
-struct RotateOp final : PaintOp {
+struct CC_PAINT_EXPORT RotateOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Rotate;
   explicit RotateOp(SkScalar degrees) : degrees(degrees) {}
   void Raster(SkCanvas* canvas) const;
 
   SkScalar degrees;
 };
 
-struct SaveOp final : PaintOp {
+struct CC_PAINT_EXPORT SaveOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Save;
   void Raster(SkCanvas* canvas) const;
 };
 
-struct SaveLayerOp final : PaintOp {
+struct CC_PAINT_EXPORT SaveLayerOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::SaveLayer;
   static constexpr bool kHasPaintFlags = true;
   SaveLayerOp(const SkRect* bounds, const PaintFlags* flags)
       : bounds(bounds ? *bounds : kUnsetRect) {
     if (flags)
       this->flags = *flags;
   }
   void RasterWithFlags(SkCanvas* canvas, const PaintFlags& flags) const;
 
   SkRect bounds;
   PaintFlags flags;
 };
 
-struct SaveLayerAlphaOp final : PaintOp {
+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) {}
   void Raster(SkCanvas* canvas) const;
 
   SkRect bounds;
   uint8_t alpha;
 };
 
-struct ScaleOp final : PaintOp {
+struct CC_PAINT_EXPORT ScaleOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Scale;
   ScaleOp(SkScalar sx, SkScalar sy) : sx(sx), sy(sy) {}
   void Raster(SkCanvas* canvas) const;
 
   SkScalar sx;
   SkScalar sy;
 };
 
-struct SetMatrixOp final : PaintOp {
+struct CC_PAINT_EXPORT SetMatrixOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::SetMatrix;
   explicit SetMatrixOp(const SkMatrix& matrix) : matrix(matrix) {}
   // This is the only op that needs the original ctm of the SkCanvas
   // used for raster (since SetMatrix is relative to the recording origin and
   // shouldn't clobber the SkCanvas raster origin).
   //
   // TODO(enne): Find some cleaner way to do this, possibly by making
   // all SetMatrix calls Concat??
   void Raster(SkCanvas* canvas, const SkMatrix& original_ctm) const;
 
   ThreadsafeMatrix matrix;
 };
 
-struct TranslateOp final : PaintOp {
+struct CC_PAINT_EXPORT TranslateOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Translate;
   TranslateOp(SkScalar dx, SkScalar dy) : dx(dx), dy(dy) {}
   void Raster(SkCanvas* canvas) const;
 
   SkScalar dx;
   SkScalar dy;
 };
 
 using LargestPaintOp = DrawDRRectOp;
 
@@ skipping 225 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_