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
@@ skipping 169 matching lines @@
     /** 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;
 
     /**
      *  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);
-    }
+    bool isFinite() const;
 
     /** 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);
     }
 
     /** Test a quad for zero length
@@ skipping 67 matching lines @@
     int getVerbs(uint8_t verbs[], int max) const;
 
     //! 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;
-    }
+    const SkRect& getBounds() const;
 
     /** 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 626 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;
+
+    // 'rect' needs to be sorted
+    void setBounds(const SkRect& rect);

[bsalomon, 2013/09/23 18:39:39]

Eek... I didn't realize we let clients set the bounds. It seems like we change
this behavior:

SkPath a;
SkPath b;
//...
b = a;
a.setBounds(/*...*/);
b.getBounds();

[robertphillips, 2013/09/23 18:56:42]

This is only used in SkAutoPathBoundsUpdate to avoid brute force recomputation
of the bounds.

+
+#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