Move bound and isFinite into pathref

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
 #define SkPath_DEFINED
 
 #include "SkInstCnt.h"
 #include "SkMatrix.h"
+#include "SkPathRef.h"

[reed1, 2013/09/24 17:32:17]

// TODO: refactor this header to move more the impl into a .cpp

[robertphillips, 2013/09/26 12:18:44]

Done - although I put the TODO in SkPathRef.h not SkPath.h

 #include "SkTDArray.h"
 #include "SkRefCnt.h"
 
 #ifdef SK_BUILD_FOR_ANDROID
 #define GEN_ID_INC              fGenerationID++
 #define GEN_ID_PTR_INC(ptr)     (ptr)->fGenerationID++
 #else
 #define GEN_ID_INC
 #define GEN_ID_PTR_INC(ptr)
 #endif
 
 class SkReader32;
 class SkWriter32;
 class SkAutoPathBoundsUpdate;
 class SkString;
-class SkPathRef;
 class SkRRect;
 
 /** \class SkPath
 
     The SkPath class encapsulates compound (multiple contour) geometric paths
     consisting of straight line segments, quadratic curves, and cubic curves.
 */
 class SK_API SkPath {
 public:
     SK_DECLARE_INST_COUNT_ROOT(SkPath);
@@ skipping 133 matching lines @@
         path. However, any internal storage for those lines/curves is retained,
         making reuse of the path potentially faster.
         On Android, does not change fSourcePath.
     */
     void rewind();
 
     /** Returns true if the path is empty (contains no lines or curves)
 
         @return true if the path is empty (contains no lines or curves)
     */
-    bool isEmpty() const;
+    bool isEmpty() const {
+        SkDEBUGCODE(this->validate();)
+        return 0 == fPathRef->countVerbs();
+    }
 
     /**
      *  Returns true if all of the points in this path are finite, meaning there
      *  are no infinities and no NaNs.
      */
     bool isFinite() const {
-        if (fBoundsIsDirty) {
-            this->computeBounds();
-        }
-        return SkToBool(fIsFinite);
+        SkDEBUGCODE(this->validate();)
+        return fPathRef->isFinite();
     }
 
     /** Test a line for zero length
 
         @return true if the line is of zero length; otherwise false.
     */
     static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2) {
         return p1.equalsWithinTolerance(p2);
     }
 
@@ skipping 69 matching lines @@
 
     //! Swap contents of this and other. Guaranteed not to throw
     void swap(SkPath& other);
 
     /** Returns the bounds of the path's points. If the path contains 0 or 1
         points, the bounds is set to (0,0,0,0), and isEmpty() will return true.
         Note: this bounds may be larger than the actual shape, since curves
         do not extend as far as their control points.
     */
     const SkRect& getBounds() const {
-        if (fBoundsIsDirty) {
-            this->computeBounds();
-        }
-        return fBounds;
+        return fPathRef->getBounds();
     }
 
     /** Calling this will, if the internal cache of the bounds is out of date,
         update it so that subsequent calls to getBounds will be instantaneous.
         This also means that any copies or simple transformations of the path
         will inherit the cached bounds.
      */
     void updateBoundsCache() const {
         // for now, just calling getBounds() is sufficient
         this->getBounds();
@@ skipping 627 matching lines @@
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t getGenerationID() const;
     const SkPath* getSourcePath() const;
     void setSourcePath(const SkPath* path);
 #endif
 
     SkDEBUGCODE(void validate() const;)
 
 private:
     enum SerializationOffsets {
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+        kNewFormat_SerializationShift = 28, // requires 1 bit
+#endif
         kDirection_SerializationShift = 26, // requires 2 bits
-        kIsFinite_SerializationShift = 25,  // requires 1 bit
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+        // rename to kUnused_SerializationShift
+        kOldIsFinite_SerializationShift = 25,    // 1 bit
+#endif
         kIsOval_SerializationShift = 24,    // requires 1 bit
-        kConvexity_SerializationShift = 16, // requires 2 bits
-        kFillType_SerializationShift = 8,   // requires 2 bits
+        kConvexity_SerializationShift = 16, // requires 8 bits
+        kFillType_SerializationShift = 8,   // requires 8 bits
         kSegmentMask_SerializationShift = 0 // requires 4 bits
     };
 
     SkAutoTUnref<SkPathRef> fPathRef;
 
-    mutable SkRect      fBounds;
     int                 fLastMoveToIndex;
     uint8_t             fFillType;
     uint8_t             fSegmentMask;
-    mutable uint8_t     fBoundsIsDirty;
     mutable uint8_t     fConvexity;
     mutable uint8_t     fDirection;
-    mutable SkBool8     fIsFinite;    // only meaningful if bounds are valid
     mutable SkBool8     fIsOval;
 #ifdef SK_BUILD_FOR_ANDROID
     uint32_t            fGenerationID;
     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.
      */
     void resetFields();
 
     /** Sets all fields other than fPathRef to the values in 'that'.
      *  Assumes the caller has already set fPathRef.
      *  Doesn't change fGenerationID or fSourcePath on Android.
      */
     void copyFields(const SkPath& that);
 
-    // called, if dirty, by getBounds()
-    void computeBounds() const;
-
     friend class Iter;
 
     friend class SkPathStroker;
     /*  Append the first contour of path, ignoring path's initial point. If no
         moveTo() call has been made for this contour, the first point is
         automatically set to (0,0).
     */
     void pathTo(const SkPath& path);
 
     /*  Append, in reverse order, the first contour of path, ignoring path's
@@ skipping 10 matching lines @@
     //
     inline void injectMoveToIfNeeded();
 
     inline bool hasOnlyMoveTos() const;
 
     Convexity internalGetConvexity() const;
 
     bool isRectContour(bool allowPartial, int* currVerb, const SkPoint** pts,
                        bool* isClosed, Direction* direction) const;
 
+    /** Returns if the path can return a bound at no cost (true) or will have to
+        perform some computation (false).
+     */
+    bool hasComputedBounds() const {
+        SkDEBUGCODE(this->validate();)
+        return fPathRef->hasComputedBounds();
+    }
+
+
+    // 'rect' needs to be sorted
+    void setBounds(const SkRect& rect) {
+        fPathRef->setBounds(rect);
+    }
+
+#ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
+    friend class SkPathRef;     // just for SerializationOffsets
+#endif
     friend class SkAutoPathBoundsUpdate;
     friend class SkAutoDisableOvalCheck;
     friend class SkAutoDisableDirectionCheck;
     friend class SkBench_AddPathTest; // perf test pathTo/reversePathTo
 };
 
 #endif