cc: Audit and static_assert the types in PaintOpBuffer can be moved.

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 54 matching lines @@
   Rotate,
   Save,
   SaveLayer,
   SaveLayerAlpha,
   Scale,
   SetMatrix,
   Translate,
   LastPaintOpType = Translate,
 };
 
+// It is a requirement for every field in a PaintOp that we can memcpy it to
+// another place in memory and free the only one (without calling any
+// constructors or destructors). Specializations of this template are for
+// types that we know to be safe for memcpy+free, with static asserts if
+// possible, and explanations if not.
+template <typename T>
+struct SafePaintOpData;

[vmpstr, 2017/06/01 22:00:55]

Don't need the forward declare anymore

+
+template <typename T>
+struct SafePaintOpData {
+  using type = T;
+
+  // TODO(danakj): This could use std::is_trivially_move_constructible once that
+  // is available on all our toolchains.
+  static_assert(base::is_trivially_copyable<type>::value,
+                "This type is not trivially copyable, which means it may not be"
+                " okay to change its memory address via memcpy+free. A template"
+                " specialization should be provided for this type that verifies"
+                " or explains why it is valid to memcpy+free this type.");
+};
+
+// sk_sp<T> pointers behave if their memory address is changed because there
+// is never a pointer back to the sk_sp<T> itself from inside the T. This is
+// true because multiple sk_sp<> may point to the same T and they are
+// transient compared to the lifetime of any T. Additionally, the move
+// constructor doesn't change any state that needs to be reflected in the new
+// object.
+template <typename U>
+struct SafePaintOpData<sk_sp<U>> {
+  using type = sk_sp<U>;
+};
+// scoped_refptr<> is able to be moved in memory for the same reasons as
+// sk_sp<>.
+template <typename U>
+struct SafePaintOpData<scoped_refptr<U>> {
+  using type = scoped_refptr<U>;
+};
+
+// PaintFlags is a collection of trivial data types and sk_sp<> ref pointers.
+// The trivial data types satisfy std::is_trivially_copyable, and sk_sp<> is
+// valid to have its memory address changed for reasons decribed on
+// SafePaintOpData<sk_sp>.
+template <>
+struct SafePaintOpData<PaintFlags> {
+  using type = PaintFlags;
+};
+
+// PaintImage is a set of trivial types and an sk_sp<> which is able to be
+// moved in memory as described on SafePaintOpData<sk_sp>. PaintImage does not
+// hold any pointers back to itself directly or indirectly.
+template <>
+struct SafePaintOpData<PaintImage> {
+  using type = PaintImage;
+};
+
+// ThreadsafePath is an SkPath which contains trivial types, sk_sp<>, and
+// SkAtomic<uint8_t>. sk_sp<> is valid as described on SafePaintOpData<sk_sp>.
+// SkAtomic<uint8_t> stores a trivial type internally, and takes its address
+// but does not store it.
+template <>
+struct SafePaintOpData<ThreadsafePath> {
+  using type = ThreadsafePath;
+};
+
+// WARNING: It is a requirement for every field in a PaintOp that we can memcpy
+// it to another place in memory and free the only one (without calling any
+// constructors or destructors). We think of this as moving the memory address
+// of the data type. This is required because PaintOpBuffer stores PaintOps in
+// a memory buffer that is realloced when it grows, changing the address of
+// everything inside the buffer.
+// std::is_trivially_copyable<> would guarantee this, but is a superset of the
+// guarantees that we need. For instance sk_sp<> works correctly when we
+// memcpy+free it, but it has a non-trivial move constructor and destructor,
+// which would make it fail a check for std::is_trivially_copyable<>.
+// std::is_trivially_move_constructible<> also provides enough as we are moving
+// the objects from one address to another conceptually, but also is not
+// satisfied by sk_sp<> since it modifies the moved-from type.
+//
+// THEREFORE: For each field in a PaintOp, declare it as a
+// SafePaintOpData<T>::type, which provides us with an explanation of safety for
+// each type.
+//
+// BEWARE: std::vector does *not* work if its memory address is changed, as
+// implementations can (and do) sometimes have a pointer back to the vector from
+// its internals, so running its move-assignment operator is required.
 struct CC_PAINT_EXPORT PaintOp {

[vmpstr, 2017/06/01 22:00:55]

maybe we can add something like

template <typename T>
using Member = SafePaintOpData<T>::type;

to PaintOp and then everything can just be 

Member<bool> flag; type of things? AFAIK that would still trigger the static
assert?

(this is a nit, I'm just trying to improve the ergonomics of using this a bit,
but maybe this is more explicit. not sure)

   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;
@@ skipping 33 matching lines @@
     SkImage* image = shader ? shader->isAImage(nullptr, nullptr) : nullptr;
     return image && image->isLazyGenerated();
   }
 
   // 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;
+  SafePaintOpData<PaintFlags>::type flags;
 };
 
+// A PaintOp with an additional block of memory with variable size. The
+// additional data held in the PaintOpWithData must be able to be moved in
+// memory without consequences. As such it must not (directly or indirectly)
+// contain any pointers back to itself or to the PaintOp.
 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) {}
 
   // 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;
+  SafePaintOpData<size_t>::type bytes;
 
  protected:
   // For some derived object T, return the internally stored data.
   // This needs the fully derived type to know how much to offset
   // from the start of the top to the data.
   template <typename T>
   const void* GetDataForThis(const T* op) const {
     static_assert(std::is_convertible<T, PaintOpWithData>::value,
                   "T is not a PaintOpWithData");
     // Arbitrary data for a PaintOp is stored after the PaintOp itself
@@ skipping 10 matching lines @@
         const_cast<const PaintOpWithData*>(this)->GetDataForThis(
             const_cast<const T*>(op)));
   }
 };
 
 struct CC_PAINT_EXPORT PaintOpWithArrayBase : PaintOpWithFlags {
   explicit PaintOpWithArrayBase(const PaintFlags& flags)
       : PaintOpWithFlags(flags) {}
 };
 
+// A PaintOp with an additional block of memory with variable size that is
+// an array of a known type. The types held in the array must be able to be
+// moved in memory without consequences. As such it must not (directly or
+// indirectly) contain any pointers back to itself or to the PaintOp. We use
+// std::is_trivially_copyable() to verify this (it is more strict but satisfies
+// our needs).
 template <typename M>
 struct CC_PAINT_EXPORT PaintOpWithArray : PaintOpWithArrayBase {
+  static_assert(base::is_trivially_copyable<M>::value, "");
+
   // Paint op that has a M[count] and a char[bytes].
   // Array data is stored first so that it can be aligned with T's alignment
   // with the arbitrary unaligned char data after it.
   // Memory layout here is: | op | M[count] | char[bytes] | padding | next op |
   // Next op is located at (char*)(op) + op->skip.
   PaintOpWithArray(const PaintFlags& flags, size_t bytes, size_t count)
       : PaintOpWithArrayBase(flags), bytes(bytes), count(count) {}
 
-  size_t bytes;
-  size_t count;
+  SafePaintOpData<size_t>::type bytes;
+  SafePaintOpData<size_t>::type count;
 
  protected:
   template <typename T>
   const void* GetDataForThis(const T* op) const {
     static_assert(std::is_convertible<T, PaintOpWithArrayBase>::value,
                   "T is not a PaintOpWithData");
     const char* start_array =
         reinterpret_cast<const char*>(GetArrayForThis(op));
     return start_array + sizeof(M) * count;
   }
@@ skipping 39 matching lines @@
 
   static constexpr PaintOpType kType = PaintOpType::Annotate;
   AnnotateOp(PaintCanvas::AnnotationType annotation_type,
              const SkRect& rect,
              sk_sp<SkData> data);
   ~AnnotateOp();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  PaintCanvas::AnnotationType annotation_type;
-  SkRect rect;
-  sk_sp<SkData> data;
+  SafePaintOpData<PaintCanvas::AnnotationType>::type annotation_type;
+  SafePaintOpData<SkRect>::type rect;
+  SafePaintOpData<sk_sp<SkData>>::type data;
 };
 
 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) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
   int CountSlowPaths() const;
 
-  ThreadsafePath path;
-  SkClipOp op;
-  bool antialias;
+  SafePaintOpData<ThreadsafePath>::type path;
+  SafePaintOpData<SkClipOp>::type op;
+  SafePaintOpData<bool>::type antialias;
 };
 
 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) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  SkRect rect;
-  SkClipOp op;
-  bool antialias;
+  SafePaintOpData<SkRect>::type rect;
+  SafePaintOpData<SkClipOp>::type op;
+  SafePaintOpData<bool>::type antialias;
 };
 
 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) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  SkRRect rrect;
-  SkClipOp op;
-  bool antialias;
+  SafePaintOpData<SkRRect>::type rrect;
+  SafePaintOpData<SkClipOp>::type op;
+  SafePaintOpData<bool>::type antialias;
 };
 
 struct CC_PAINT_EXPORT ConcatOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Concat;
   explicit ConcatOp(const SkMatrix& matrix) : matrix(matrix) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  ThreadsafeMatrix matrix;
+  SafePaintOpData<ThreadsafeMatrix>::type matrix;
 };
 
 struct CC_PAINT_EXPORT DrawArcOp final : PaintOpWithFlags {
   static constexpr PaintOpType kType = PaintOpType::DrawArc;
   static constexpr bool kIsDrawOp = true;
   DrawArcOp(const SkRect& oval,
             SkScalar start_angle,
             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) {
     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;
+  SafePaintOpData<SkRect>::type oval;
+  SafePaintOpData<SkScalar>::type start_angle;
+  SafePaintOpData<SkScalar>::type sweep_angle;
+  SafePaintOpData<bool>::type 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) {
     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;
+  SafePaintOpData<SkScalar>::type cx;
+  SafePaintOpData<SkScalar>::type cy;
+  SafePaintOpData<SkScalar>::type 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) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  SkColor color;
-  SkBlendMode mode;
+  SafePaintOpData<SkColor>::type color;
+  SafePaintOpData<SkBlendMode>::type mode;
 };
 
 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();
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
   size_t AdditionalBytesUsed() const;
   bool HasDiscardableImages() const;
   int CountSlowPaths() const;
 
-  scoped_refptr<DisplayItemList> list;
+  SafePaintOpData<scoped_refptr<DisplayItemList>>::type list;
 };
 
 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) {
     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;
+  SafePaintOpData<SkRRect>::type outer;
+  SafePaintOpData<SkRRect>::type 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) {
     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);
   bool HasDiscardableImages() const;
 
-  PaintImage image;
-  SkScalar left;
-  SkScalar top;
+  SafePaintOpData<PaintImage>::type image;
+  SafePaintOpData<SkScalar>::type left;
+  SafePaintOpData<SkScalar>::type 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) {
     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);
   bool HasDiscardableImages() const;
 
-  PaintImage image;
-  SkRect src;
-  SkRect dst;
-  PaintCanvas::SrcRectConstraint constraint;
+  SafePaintOpData<PaintImage>::type image;
+  SafePaintOpData<SkRect>::type src;
+  SafePaintOpData<SkRect>::type dst;
+  SafePaintOpData<PaintCanvas::SrcRectConstraint>::type 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) {
     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;
+  SafePaintOpData<SkIRect>::type 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) {
     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;
+  SafePaintOpData<SkScalar>::type x0;
+  SafePaintOpData<SkScalar>::type y0;
+  SafePaintOpData<SkScalar>::type x1;
+  SafePaintOpData<SkScalar>::type 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) {
     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;
+  SafePaintOpData<SkRect>::type 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) {
     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;
+  SafePaintOpData<ThreadsafePath>::type 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) {
@@ skipping 16 matching lines @@
   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;
   bool HasDiscardableImages() const;
   int CountSlowPaths() const;
 
-  sk_sp<const PaintRecord> record;
+  SafePaintOpData<sk_sp<const PaintRecord>>::type 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) {
     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;
+  SafePaintOpData<SkRect>::type 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) {
     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;
+  SafePaintOpData<SkRRect>::type 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) {
     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;
+  SafePaintOpData<SkScalar>::type x;
+  SafePaintOpData<SkScalar>::type 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) {
     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;
+  SafePaintOpData<sk_sp<SkTextBlob>>::type blob;
+  SafePaintOpData<SkScalar>::type x;
+  SafePaintOpData<SkScalar>::type y;
 };
 
 struct CC_PAINT_EXPORT NoopOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Noop;
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm) {}
 };
 
 struct CC_PAINT_EXPORT RestoreOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Restore;
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 };
 
 struct CC_PAINT_EXPORT RotateOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Rotate;
   explicit RotateOp(SkScalar degrees) : degrees(degrees) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  SkScalar degrees;
+  SafePaintOpData<SkScalar>::type degrees;
 };
 
 struct CC_PAINT_EXPORT SaveOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Save;
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      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) {
     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;
+  SafePaintOpData<SkRect>::type 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,
                      const SkMatrix& original_ctm);
 
-  SkRect bounds;
-  uint8_t alpha;
+  SafePaintOpData<SkRect>::type bounds;
+  SafePaintOpData<uint8_t>::type alpha;
 };
 
 struct CC_PAINT_EXPORT ScaleOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Scale;
   ScaleOp(SkScalar sx, SkScalar sy) : sx(sx), sy(sy) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  SkScalar sx;
-  SkScalar sy;
+  SafePaintOpData<SkScalar>::type sx;
+  SafePaintOpData<SkScalar>::type sy;
 };
 
 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??
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  ThreadsafeMatrix matrix;
+  SafePaintOpData<ThreadsafeMatrix>::type matrix;
 };
 
 struct CC_PAINT_EXPORT TranslateOp final : PaintOp {
   static constexpr PaintOpType kType = PaintOpType::Translate;
   TranslateOp(SkScalar dx, SkScalar dy) : dx(dx), dy(dy) {}
   static void Raster(const PaintOp* op,
                      SkCanvas* canvas,
                      const SkMatrix& original_ctm);
 
-  SkScalar dx;
-  SkScalar dy;
+  SafePaintOpData<SkScalar>::type dx;
+  SafePaintOpData<SkScalar>::type dy;
 };
 
 using LargestPaintOp = DrawDRRectOp;
 
 class CC_PAINT_EXPORT PaintOpBuffer : public SkRefCnt {
  public:
   enum { kInitialBufferSize = 4096 };
   // It's not necessarily the case that the op with the maximum alignment
   // requirements is also the biggest op, but for now that's true.
   static constexpr size_t PaintOpAlign = ALIGNOF(DrawDRRectOp);
@@ skipping 193 matching lines @@
   // Record additional bytes used by referenced sub-records and display lists.
   size_t subrecord_bytes_used_ = 0;
   bool has_discardable_images_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(PaintOpBuffer);
 };
 
 }  // namespace cc
 
 #endif  // CC_PAINT_PAINT_OP_BUFFER_H_