Use a union inside GrShape to hold geometry

src/gpu/GrShape.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrShape_DEFINED
 #define GrShape_DEFINED
 
@@ skipping 16 matching lines @@
  * to geometric information and is included in the new shape's key. When the same style is applied
  * to two shapes that reflect the same underlying geometry the computed keys of the stylized shapes
  * will be the same.
  *
  * Currently this can only be constructed from a path, rect, or rrect though it can become a path
  * applying style to the geometry. The idea is to expand this to cover most or all of the geometries
  * that have SkCanvas::draw APIs.
  */
 class GrShape {
 public:
-    GrShape() : fType(Type::kEmpty) {}
+    GrShape() { this->initType(Type::kEmpty); }
 
-    explicit GrShape(const SkPath& path)
-        : fType(Type::kPath)
-        , fPath(&path) {
-        this->attemptToSimplifyPath();
-    }
+    explicit GrShape(const SkPath& path) : GrShape(path, GrStyle::SimpleFill()) {}
 
-    explicit GrShape(const SkRRect& rrect)
-        : fType(Type::kRRect)
-        , fRRect(rrect)
-        , fRRectIsInverted(false) {
-        fRRectStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectDir);
-        this->attemptToSimplifyRRect();
-    }
+    explicit GrShape(const SkRRect& rrect) : GrShape(rrect, GrStyle::SimpleFill()) {}
 
-    explicit GrShape(const SkRect& rect)
-        : fType(Type::kRRect)
-        , fRRect(SkRRect::MakeRect(rect))
-        , fRRectIsInverted(false) {
-        fRRectStart = DefaultRectDirAndStartIndex(rect, false, &fRRectDir);
-        this->attemptToSimplifyRRect();
-    }
+    explicit GrShape(const SkRect& rect) : GrShape(rect, GrStyle::SimpleFill()) {}
 
-    GrShape(const SkPath& path, const GrStyle& style)
-        : fType(Type::kPath)
-        , fPath(&path)
-        , fStyle(style) {
+    GrShape(const SkPath& path, const GrStyle& style) : fStyle(style) {
+        this->initType(Type::kPath, &path);
         this->attemptToSimplifyPath();
     }
 
     GrShape(const SkRRect& rrect, const GrStyle& style)
-        : fType(Type::kRRect)
-        , fRRect(rrect)
-        , fRRectIsInverted(false)
-        , fStyle(style) {
-        fRRectStart = DefaultRRectDirAndStartIndex(rrect, style.hasPathEffect(), &fRRectDir);
+        : fStyle(style) {
+        this->initType(Type::kRRect);
+        fRRectData.fRRect = rrect;
+        fRRectData.fInverted = false;
+        fRRectData.fStart = DefaultRRectDirAndStartIndex(rrect, style.hasPathEffect(),
+                                                         &fRRectData.fDir);
         this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkRRect& rrect, SkPath::Direction dir, unsigned start, bool inverted,
             const GrStyle& style)
-        : fType(Type::kRRect)
-        , fRRect(rrect)
-        , fRRectIsInverted(inverted)
-        , fStyle(style) {
+        : fStyle(style) {
+        this->initType(Type::kRRect);
+        fRRectData.fRRect = rrect;
+        fRRectData.fInverted = inverted;
         if (style.pathEffect()) {
-            fRRectDir = dir;
-            fRRectStart = start;
-            if (fRRect.getType() == SkRRect::kRect_Type) {
-                fRRectStart = (fRRectStart + 1) & 0b110;
-            } else if (fRRect.getType() == SkRRect::kOval_Type) {
-                fRRectStart &= 0b110;
+            fRRectData.fDir = dir;
+            fRRectData.fStart = start;
+            if (fRRectData.fRRect.getType() == SkRRect::kRect_Type) {
+                fRRectData.fStart = (fRRectData.fStart + 1) & 0b110;
+            } else if (fRRectData.fRRect.getType() == SkRRect::kOval_Type) {
+                fRRectData.fStart &= 0b110;
             }
         } else {
-            fRRectStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectDir);
+            fRRectData.fStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectData.fDir);
         }
         this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkRect& rect, const GrStyle& style)
-        : fType(Type::kRRect)
-        , fRRect(SkRRect::MakeRect(rect))
-        , fRRectIsInverted(false)
-        , fStyle(style) {
-        fRRectStart = DefaultRectDirAndStartIndex(rect, style.hasPathEffect(), &fRRectDir);
+        : fStyle(style) {
+        this->initType(Type::kRRect);
+        fRRectData.fRRect = SkRRect::MakeRect(rect);
+        fRRectData.fInverted = false;
+        fRRectData.fStart = DefaultRectDirAndStartIndex(rect, style.hasPathEffect(),
+                                                        &fRRectData.fDir);
         this->attemptToSimplifyRRect();
     }
 
-    GrShape(const SkPath& path, const SkPaint& paint)
-        : fType(Type::kPath)
-        , fPath(&path)
-        , fStyle(paint) {
+    GrShape(const SkPath& path, const SkPaint& paint) : fStyle(paint) {
+        this->initType(Type::kPath, &path);
         this->attemptToSimplifyPath();
     }
 
     GrShape(const SkRRect& rrect, const SkPaint& paint)
-        : fType(Type::kRRect)
-        , fRRect(rrect)
-        , fRRectIsInverted(false)
-        , fStyle(paint) {
-        fRRectStart = DefaultRRectDirAndStartIndex(rrect, fStyle.hasPathEffect(), &fRRectDir);
+        : fStyle(paint) {
+        this->initType(Type::kRRect);
+        fRRectData.fRRect = rrect;
+        fRRectData.fInverted = false;
+        fRRectData.fStart = DefaultRRectDirAndStartIndex(rrect, fStyle.hasPathEffect(),
+                                                         &fRRectData.fDir);
         this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkRect& rect, const SkPaint& paint)
-        : fType(Type::kRRect)
-        , fRRect(SkRRect::MakeRect(rect))
-        , fRRectIsInverted(false)
-        , fStyle(paint) {
-        fRRectStart = DefaultRectDirAndStartIndex(rect, fStyle.hasPathEffect(), &fRRectDir);
+        : fStyle(paint) {
+        this->initType(Type::kRRect);
+        fRRectData.fRRect = SkRRect::MakeRect(rect);
+        fRRectData.fInverted = false;
+        fRRectData.fStart = DefaultRectDirAndStartIndex(rect, fStyle.hasPathEffect(),
+                                                        &fRRectData.fDir);
         this->attemptToSimplifyRRect();
     }
 
     GrShape(const GrShape&);
     GrShape& operator=(const GrShape& that);
 
-    ~GrShape() {
-        if (Type::kPath == fType) {
-            fPath.reset();
-        }
-    }
+    ~GrShape() { this->changeType(Type::kEmpty); }
 
     const GrStyle& style() const { return fStyle; }
 
     /**
      * Returns a shape that has either applied the path effect or path effect and stroking
      * information from this shape's style to its geometry. Scale is used when approximating the
      * output geometry and typically is computed from the view matrix
      */
     GrShape applyStyle(GrStyle::Apply apply, SkScalar scale) const {
         return GrShape(*this, apply, scale);
     }
 
     /** Returns the unstyled geometry as a rrect if possible. */
     bool asRRect(SkRRect* rrect, SkPath::Direction* dir, unsigned* start, bool* inverted) const {
         if (Type::kRRect != fType) {
             return false;
         }
         if (rrect) {
-            *rrect = fRRect;
+            *rrect = fRRectData.fRRect;
         }
         if (dir) {
-            *dir = fRRectDir;
+            *dir = fRRectData.fDir;
         }
         if (start) {
-            *start = fRRectStart;
+            *start = fRRectData.fStart;
         }
         if (inverted) {
-            *inverted = fRRectIsInverted;
+            *inverted = fRRectData.fInverted;
         }
         return true;
     }
 
     /**
      * If the unstyled shape is a straight line segment, returns true and sets pts to the endpoints.
      * An inverse filled line path is still considered a line.
      */
      bool asLine(SkPoint pts[2]) const {
          if (fType != Type::kPath) {
              return false;
          }
-         return fPath.get()->isLine(pts);
+         return this->path().isLine(pts);
      }
 
     /** Returns the unstyled geometry as a path. */
     void asPath(SkPath* out) const {
         switch (fType) {
             case Type::kEmpty:
                 out->reset();
                 break;
             case Type::kRRect:
                 out->reset();
-                out->addRRect(fRRect, fRRectDir, fRRectStart);
+                out->addRRect(fRRectData.fRRect, fRRectData.fDir, fRRectData.fStart);
                 // Below matches the fill type that attemptToSimplifyPath uses.
-                if (fRRectIsInverted) {
+                if (fRRectData.fInverted) {
                     out->setFillType(kDefaultPathInverseFillType);
                 } else {
                     out->setFillType(kDefaultPathFillType);
                 }
                 break;
             case Type::kPath:
-                *out = *fPath.get();
+                *out = this->path();
                 break;
         }
     }
 
     /**
      * Returns whether the geometry is empty. Note that applying the style could produce a
      * non-empty shape.
      */
     bool isEmpty() const { return Type::kEmpty == fType; }
 
@@ skipping 18 matching lines @@
         switch (fType) {
             case Type::kEmpty:
                 return true;
             case Type::kRRect:
                 return true;
             case Type::kPath:
                 // SkPath.isConvex() really means "is this path convex were it to be closed" and
                 // thus doesn't give the correct answer for stroked paths, hence we also check
                 // whether the path is either filled or closed. Convex paths may only have one
                 // contour hence isLastContourClosed() is a sufficient for a convex path.
-                return (this->style().isSimpleFill() || fPath.get()->isLastContourClosed()) &&
-                       fPath.get()->isConvex();
+                return (this->style().isSimpleFill() || this->path().isLastContourClosed()) &&
+                        this->path().isConvex();
         }
         return false;
     }
 
     /** Is the pre-styled geometry inverse filled? */
     bool inverseFilled() const {
         bool ret = false;
         switch (fType) {
             case Type::kEmpty:
                 ret = false;
                 break;
             case Type::kRRect:
-                ret = fRRectIsInverted;
+                ret = fRRectData.fInverted;
                 break;
             case Type::kPath:
-                ret = this->fPath.get()->isInverseFillType();
+                ret = this->path().isInverseFillType();
                 break;
         }
         // Dashing ignores inverseness. We should have caught this earlier. skbug.com/5421
         SkASSERT(!(ret && this->style().isDashed()));
         return ret;
     }
 
     /**
      * Might applying the styling to the geometry produce an inverse fill. The "may" part comes in
      * because an arbitrary path effect could produce an inverse filled path. In other cases this
@@ skipping 13 matching lines @@
      * not have any caps if stroked (modulo the effect of any path effect).
      */
     bool knownToBeClosed() const {
         switch (fType) {
             case Type::kEmpty:
                 return true;
             case Type::kRRect:
                 return true;
             case Type::kPath:
                 // SkPath doesn't keep track of the closed status of each contour.
-                return SkPathPriv::IsClosedSingleContour(*fPath.get());
+                return SkPathPriv::IsClosedSingleContour(this->path());
         }
         return false;
     }
 
     uint32_t segmentMask() const {
         switch (fType) {
             case Type::kEmpty:
                 return 0;
             case Type::kRRect:
-                if (fRRect.getType() == SkRRect::kOval_Type) {
+                if (fRRectData.fRRect.getType() == SkRRect::kOval_Type) {
                     return SkPath::kConic_SegmentMask;
-                } else if (fRRect.getType() == SkRRect::kRect_Type) {
+                } else if (fRRectData.fRRect.getType() == SkRRect::kRect_Type) {
                     return SkPath::kLine_SegmentMask;
                 }
                 return SkPath::kLine_SegmentMask | SkPath::kConic_SegmentMask;
             case Type::kPath:
-                return fPath.get()->getSegmentMasks();
+                return this->path().getSegmentMasks();
         }
         return 0;
     }
 
     /**
      * Gets the size of the key for the shape represented by this GrShape (ignoring its styling).
      * A negative value is returned if the shape has no key (shouldn't be cached).
      */
     int unstyledKeySize() const;
 
     bool hasUnstyledKey() const { return this->unstyledKeySize() >= 0; }
 
     /**
      * Writes unstyledKeySize() bytes into the provided pointer. Assumes that there is enough
      * space allocated for the key and that unstyledKeySize() does not return a negative value
      * for this shape.
      */
     void writeUnstyledKey(uint32_t* key) const;
 
 private:
     enum class Type {
         kEmpty,
         kRRect,
         kPath,
     };
 
+    void initType(Type type, const SkPath* path = nullptr) {
+        fType = Type::kEmpty;
+        this->changeType(type, path);
+    }
+
+    void changeType(Type type, const SkPath* path = nullptr) {
+        bool wasPath = Type::kPath == fType;
+        fType = type;
+        bool isPath = Type::kPath == type;
+        SkASSERT(!path || isPath);
+        if (wasPath && !isPath) {
+            fPathData.fPath.~SkPath();
+        } else if (!wasPath && isPath) {
+            if (path) {
+                new (&fPathData.fPath) SkPath(*path);
+            } else {
+                new (&fPathData.fPath) SkPath();
+            }
+        } else if (isPath && path) {
+            fPathData.fPath = *path;
+        }
+        // Whether or not we use the path's gen ID is decided in attemptToSimplifyPath.
+        fPathData.fGenID = 0;
+    }
+
+    SkPath& path() {
+        SkASSERT(Type::kPath == fType);
+        return fPathData.fPath;
+    }
+
+    const SkPath& path() const {
+        SkASSERT(Type::kPath == fType);
+        return fPathData.fPath;
+    }
+
     /** Constructor used by the applyStyle() function */
     GrShape(const GrShape& parentShape, GrStyle::Apply, SkScalar scale);
 
     /**
      * Determines the key we should inherit from the input shape's geometry and style when
      * we are applying the style to create a new shape.
      */
     void setInheritedKey(const GrShape& parentShape, GrStyle::Apply, SkScalar scale);
 
     void attemptToSimplifyPath();
@@ skipping 43 matching lines @@
         static constexpr unsigned kPathRRectStartIdx = 6;
         *dir = kDefaultRRectDir;
         if (!hasPathEffect) {
             // It doesn't matter what start we use, just be consistent to avoid redundant keys.
             return kDefaultRRectStart;
         }
         return kPathRRectStartIdx;
     }
 
     Type                        fType;
-    SkRRect                     fRRect;
-    SkPath::Direction           fRRectDir;
-    unsigned                    fRRectStart;
-    bool                        fRRectIsInverted;
-    SkTLazy<SkPath>             fPath;
-    // Gen ID of the original path (fPath may be modified)
-    int32_t                     fPathGenID = 0;
+    union {
+        struct {
+            SkRRect                     fRRect;
+            SkPath::Direction           fDir;
+            unsigned                    fStart;
+            bool                        fInverted;
+        } fRRectData;
+        struct {
+            SkPath                      fPath;
+            // Gen ID of the original path (fPath may be modified)
+            int32_t                     fGenID;
+        } fPathData;
+    };
     GrStyle                     fStyle;
     SkAutoSTArray<8, uint32_t>  fInheritedKey;
 };
 #endif