Move segment mask from SkPath to SkPathRef

include/core/SkPath.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPath_DEFINED
@@ skipping 65 matching lines @@
 
     /** Returns true if the filltype is one of the Inverse variants */
     bool isInverseFillType() const { return IsInverseFillType((FillType)fFillType); }
 
     /**
      *  Toggle between inverse and normal filltypes. This reverse the return
      *  value of isInverseFillType()
      */
     void toggleInverseFillType() {
         fFillType ^= 2;
-     }
+    }
 
     enum Convexity {
         kUnknown_Convexity,
         kConvex_Convexity,
         kConcave_Convexity
     };
 
     /**
      *  Return the path's convexity, as stored in the path. If it is currently unknown,
      *  then this function will attempt to compute the convexity (and cache the result).
@@ skipping 342 matching lines @@
                 this contour, to specify the 1st control point of a cubic curve
         @param dx2   The amount to add to the x-coordinate of the last point on
                 this contour, to specify the 2nd control point of a cubic curve
         @param dy2   The amount to add to the y-coordinate of the last point on
                 this contour, to specify the 2nd control point of a cubic curve
         @param dx3   The amount to add to the x-coordinate of the last point on
                      this contour, to specify the end point of a cubic curve
         @param dy3   The amount to add to the y-coordinate of the last point on
                      this contour, to specify the end point of a cubic curve
     */
-    void    rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
-                     SkScalar x3, SkScalar y3);
+    void rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
+                  SkScalar x3, SkScalar y3);
 
     /** Append the specified arc to the path as a new contour. If the start of
         the path is different from the path's current last point, then an
         automatic lineTo() is added to connect the current contour to the start
         of the arc. However, if the path is empty, then we call moveTo() with
         the first point of the arc. The sweep angle is treated mod 360.
 
         @param oval The bounding oval defining the shape and size of the arc
         @param startAngle Starting angle (in degrees) where the arc begins
         @param sweepAngle Sweep angle (in degrees) measured clockwise. This is
                           treated mod 360.
         @param forceMoveTo If true, always begin a new contour with the arc
     */
-    void    arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
-                  bool forceMoveTo);
+    void arcTo(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
+               bool forceMoveTo);
 
     /** Append a line and arc to the current path. This is the same as the
         PostScript call "arct".
     */
     void arcTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                SkScalar radius);
 
     /** Append a line and arc to the current path. This is the same as the
         PostScript call "arct".
     */
@@ skipping 295 matching lines @@
         kQuad_SegmentMask   = 1 << 1,
         kConic_SegmentMask  = 1 << 2,
         kCubic_SegmentMask  = 1 << 3,
     };
 
     /**
      *  Returns a mask, where each bit corresponding to a SegmentMask is
      *  set if the path contains 1 or more segments of that type.
      *  Returns 0 for an empty path (no segments).
      */
-    uint32_t getSegmentMasks() const { return fSegmentMask; }
+    uint32_t getSegmentMasks() const { return fPathRef->getSegmentMasks(); }
 
     enum Verb {
         kMove_Verb,     //!< iter.next returns 1 point
         kLine_Verb,     //!< iter.next returns 2 points
         kQuad_Verb,     //!< iter.next returns 3 points
         kConic_Verb,    //!< iter.next returns 3 points + iter.conicWeight()
         kCubic_Verb,    //!< iter.next returns 4 points
         kClose_Verb,    //!< iter.next returns 1 point (contour's moveTo pt)
         kDone_Verb,     //!< iter.next returns 0 points
     };
@@ skipping 143 matching lines @@
         kNewFormat_SerializationShift = 29, // requires 1 bit
 #endif
         kUnused1_SerializationShift = 28,    // 1 free bit
         kDirection_SerializationShift = 26, // requires 2 bits
         kUnused2_SerializationShift = 25,    // 1 free bit
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V16_AND_ALL_OTHER_INSTANCES_TOO
         kOldIsOval_SerializationShift = 24,    // requires 1 bit
 #endif
         kConvexity_SerializationShift = 16, // requires 8 bits
         kFillType_SerializationShift = 8,   // requires 8 bits
-        kSegmentMask_SerializationShift = 0 // requires 4 bits
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V16_AND_ALL_OTHER_INSTANCES_TOO
+        kOldSegmentMask_SerializationShift = 0 // requires 4 bits
+#endif
     };
 
     SkAutoTUnref<SkPathRef> fPathRef;
 
     int                 fLastMoveToIndex;
     uint8_t             fFillType;
-    uint8_t             fSegmentMask;
     mutable uint8_t     fConvexity;
     mutable uint8_t     fDirection;
 #ifdef SK_BUILD_FOR_ANDROID
     const SkPath*       fSourcePath;
 #endif
 
     /** Resets all fields other than fPathRef to their initial 'empty' values.
      *  Assumes the caller has already emptied fPathRef.
      *  On Android increments fGenerationID without reseting it.
      */
@@ skipping 48 matching lines @@
     friend class SkPathRef;     // just for SerializationOffsets
 #endif
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test reversePathTo
     friend class PathTest_Private; // unit test reversePathTo
 };
 
 #endif