Improved SkPathRef interface security

include/core/SkPathRef.h

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPathRef_DEFINED
 #define SkPathRef_DEFINED
@@ skipping 31 matching lines @@
     public:
         Editor(SkAutoTUnref<SkPathRef>* pathRef,
                int incReserveVerbs = 0,
                int incReservePoints = 0);
 
         ~Editor() { SkDEBUGCODE(sk_atomic_dec(&fPathRef->fEditorsAttached);) }
 
         /**
          * Returns the array of points.
          */
-        SkPoint* points() { return fPathRef->fPoints; }
+        SkPoint* points() { return fPathRef->getPoints(); }
+        const SkPoint* points() const { return fPathRef->points(); }
 
         /**
          * Gets the ith point. Shortcut for this->points() + i
          */
         SkPoint* atPoint(int i) {
             SkASSERT((unsigned) i < (unsigned) fPathRef->fPointCnt);
             return this->points() + i;
         };
+        const SkPoint* atPoint(int i) const {
+            SkASSERT((unsigned) i < (unsigned) fPathRef->fPointCnt);
+            return this->points() + i;
+        };
 
         /**
          * Adds the verb and allocates space for the number of points indicated by the verb. The
          * return value is a pointer to where the points for the verb should be written.
          * 'weight' is only used if 'verb' is kConic_Verb
          */
         SkPoint* growForVerb(int /*SkPath::Verb*/ verb, SkScalar weight = 0) {
             SkDEBUGCODE(fPathRef->validate();)
             return fPathRef->growForVerb(verb, weight);
         }
@@ skipping 11 matching lines @@
             return fPathRef->growForRepeatedVerb(verb, numVbs, weights); 
         }
 
         /**
          * Resets the path ref to a new verb and point count. The new verbs and points are
          * uninitialized.
          */
         void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
             fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
         }
+
         /**
          * Gets the path ref that is wrapped in the Editor.
          */
         SkPathRef* pathRef() { return fPathRef; }
 
         void setIsOval(bool isOval) { fPathRef->setIsOval(isOval); }
 
+        void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); }
+
     private:
         SkPathRef* fPathRef;
     };
 
 public:
     /**
      * Gets a path ref with no verbs or points.
      */
     static SkPathRef* CreateEmpty();
 
@@ skipping 42 matching lines @@
         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;
     }
 
-    void setBounds(const SkRect& rect) {
-        SkASSERT(rect.fLeft <= rect.fRight && rect.fTop <= rect.fBottom);
-        fBounds = rect;
-        fBoundsIsDirty = false;
-        fIsFinite = fBounds.isFinite();
-    }
-
     /**
      * Transforms a path ref by a matrix, allocating a new one only if necessary.
      */
     static void CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
                                       const SkPathRef& src,
                                       const SkMatrix& matrix);
 
     static SkPathRef* CreateFromBuffer(SkRBuffer* buffer
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V16_AND_ALL_OTHER_INSTANCES_TOO
         , bool newFormat, int32_t oldPacked
@@ skipping 114 matching lines @@
 
     // called, if dirty, by getBounds()
     void computeBounds() const {
         SkDEBUGCODE(this->validate();)
         SkASSERT(fBoundsIsDirty);
 
         fIsFinite = ComputePtBounds(&fBounds, *this);
         fBoundsIsDirty = false;
     }
 
+    void setBounds(const SkRect& rect) {
+        SkASSERT(rect.fLeft <= rect.fRight && rect.fTop <= rect.fBottom);
+        fBounds = rect;
+        fBoundsIsDirty = false;
+        fIsFinite = fBounds.isFinite();
+    }
+
     /** Makes additional room but does not change the counts or change the genID */
     void incReserve(int additionalVerbs, int additionalPoints) {
         SkDEBUGCODE(this->validate();)
         size_t space = additionalVerbs * sizeof(uint8_t) + additionalPoints * sizeof (SkPoint);
         this->makeSpace(space);
         SkDEBUGCODE(this->validate();)
     }
 
     /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
      *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
@@ skipping 99 matching lines @@
 
     SkDEBUGCODE(void validate() const;)
 
     /**
      * Called the first time someone calls CreateEmpty to actually create the singleton.
      */
     static void CreateEmptyImpl(SkPathRef** empty);
 
     void setIsOval(bool isOval) { fIsOval = isOval; }
 
+    SkPoint* getPoints() { 
+        SkDEBUGCODE(this->validate();) 
+        fIsOval = false;
+        return fPoints; 
+    }
+
     enum {
         kMinSize = 256,
     };
 
     mutable SkRect      fBounds;
     uint8_t             fSegmentMask;
     mutable uint8_t     fBoundsIsDirty;
     mutable SkBool8     fIsFinite;    // only meaningful if bounds are valid
     mutable SkBool8     fIsOval;
 
     SkPoint*            fPoints; // points to begining of the allocation
     uint8_t*            fVerbs; // points just past the end of the allocation (verbs grow backwards)
     int                 fVerbCnt;
     int                 fPointCnt;
     size_t              fFreeSpace; // redundant but saves computation
     SkTDArray<SkScalar> fConicWeights;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
     };
     mutable uint32_t    fGenerationID;
     SkDEBUGCODE(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
+    friend class PathRefTest_Private;
     typedef SkRefCnt INHERITED;
 };
 
 #endif