add region to dictionary in SkMatrixClipStackMgr

src/core/SkMatrixClipStateMgr.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkMatrixClipStateMgr_DEFINED
 #define SkMatrixClipStateMgr_DEFINED
 
 #include "SkCanvas.h"
 #include "SkMatrix.h"
 #include "SkRegion.h"
 #include "SkRRect.h"
 #include "SkTypes.h"
-#include "SkTArray.h"
 #include "SkTDArray.h"
 
 class SkPictureRecord;
 class SkWriter32;
 
 // The SkMatrixClipStateMgr collapses the matrix/clip state of an SkPicture into
 // a series of save/restore blocks of consistent matrix clip state, e.g.:
 //
 //   save
 //     clip(s)
@@ skipping 82 matching lines @@
         };
 
         class ClipInfo : public SkNoncopyable {
         public:
             ClipInfo() {}
 
             bool clipRect(const SkRect& rect,
                           SkRegion::Op op,
                           bool doAA,
                           int matrixID) {
-                ClipOp& newClip = fClips.push_back();
-                newClip.fClipType = kRect_ClipType;
-                newClip.fGeom.fRRect.setRect(rect);   // storing the clipRect in the RRect
-                newClip.fOp = op;
-                newClip.fDoAA = doAA;
-                newClip.fMatrixID = matrixID;
-                newClip.fOffset = kInvalidJumpOffset;
+                ClipOp* newClip = fClips.append();
+                newClip->fClipType = kRect_ClipType;
+                newClip->fGeom.fRRect.setRect(rect);   // storing the clipRect in the RRect
+                newClip->fOp = op;
+                newClip->fDoAA = doAA;
+                newClip->fMatrixID = matrixID;
+                newClip->fOffset = kInvalidJumpOffset;
                 return false;
             }
 
             bool clipRRect(const SkRRect& rrect,
                            SkRegion::Op op,
                            bool doAA,
                            int matrixID) {
-                ClipOp& newClip = fClips.push_back();
-                newClip.fClipType = kRRect_ClipType;
-                newClip.fGeom.fRRect = rrect;
-                newClip.fOp = op;
-                newClip.fDoAA = doAA;
-                newClip.fMatrixID = matrixID;
-                newClip.fOffset = kInvalidJumpOffset;
+                ClipOp* newClip = fClips.append();
+                newClip->fClipType = kRRect_ClipType;
+                newClip->fGeom.fRRect = rrect;
+                newClip->fOp = op;
+                newClip->fDoAA = doAA;
+                newClip->fMatrixID = matrixID;
+                newClip->fOffset = kInvalidJumpOffset;
                 return false;
             }
 
             bool clipPath(SkPictureRecord* picRecord,
                           const SkPath& path,
                           SkRegion::Op op,
                           bool doAA,
                           int matrixID);
             bool clipRegion(SkPictureRecord* picRecord,
-                            const SkRegion& region,
+                            int regionID,
                             SkRegion::Op op,
                             int matrixID);
             void writeClip(int* curMatID, 
                            SkMatrixClipStateMgr* mgr,
                            bool* overrideFirstOp);
             void fillInSkips(SkWriter32* writer, int32_t restoreOffset);
 
 #ifdef SK_DEBUG
             void checkOffsetNotEqual(int32_t offset) {
                 for (int i = 0; i < fClips.count(); ++i) {
                     ClipOp& curClip = fClips[i];
                     SkASSERT(offset != curClip.fOffset);
                 }
             }
 #endif
         private:
             enum ClipType {
                 kRect_ClipType,
                 kRRect_ClipType,
                 kPath_ClipType,
                 kRegion_ClipType
             };
 
             static const int kInvalidJumpOffset = -1;
 
             class ClipOp {
             public:
-                ClipOp() {}
-                ~ClipOp() {
-                    if (kRegion_ClipType == fClipType) {
-                        SkDELETE(fGeom.fRegion);
-                    }
-                }
-
                 ClipType     fClipType;
 
                 union {
-                    SkRRect         fRRect;        // also stores clipRect
-                    int             fPathID;
-                    // TODO: add internal dictionary of regions
-                    // This parameter forces us to have a dtor and thus use
-                    // SkTArray rather then SkTDArray!
-                    const SkRegion* fRegion;
+                    SkRRect fRRect;        // also stores clipRect
+                    int     fPathID;
+                    int     fRegionID;
                 } fGeom;
 
                 bool         fDoAA;
                 SkRegion::Op fOp;
 
                 // The CTM in effect when this clip call was issued
                 int          fMatrixID;
 
                 // The offset of this clipOp's "jump-to-offset" location in the skp.
                 // -1 means the offset hasn't been written.
                 int32_t      fOffset;
             };
 
-            SkTArray<ClipOp> fClips;
+            SkTDArray<ClipOp> fClips;
 
             typedef SkNoncopyable INHERITED;
         };
 
         MatrixClipState(MatrixClipState* prev, int flags)
 #ifdef SK_DEBUG
             : fPrev(prev)
 #endif
         {
             if (NULL == prev) {
@@ skipping 53 matching lines @@
         int32_t     fMCStateID;
     };
 
     enum CallType {
         kMatrix_CallType,
         kClip_CallType,
         kOther_CallType
     };
 
     SkMatrixClipStateMgr();
+    ~SkMatrixClipStateMgr();
 
     void init(SkPictureRecord* picRecord) {
         // Note: we're not taking a ref here. It is expected that the SkMatrixClipStateMgr
         // is owned by the SkPictureRecord object
         fPicRecord = picRecord;
     }
 
     SkPictureRecord* getPicRecord() { return fPicRecord; }
 
     // TODO: need to override canvas' getSaveCount. Right now we pass the
@@ skipping 54 matching lines @@
     }
 
     bool clipPath(const SkPath& path, SkRegion::Op op, bool doAA) {
         this->call(SkMatrixClipStateMgr::kClip_CallType);
         return fCurMCState->fClipInfo->clipPath(fPicRecord, path, op, doAA,
                                                 fCurMCState->fMatrixInfo->getID(this));
     }
 
     bool clipRegion(const SkRegion& region, SkRegion::Op op) {
         this->call(SkMatrixClipStateMgr::kClip_CallType);
-        return fCurMCState->fClipInfo->clipRegion(fPicRecord, region, op,
+        int regionID = this->addRegionToDict(region);
+        return fCurMCState->fClipInfo->clipRegion(fPicRecord, regionID, op,
                                                   fCurMCState->fMatrixInfo->getID(this));
     }
 
     bool call(CallType callType);
 
     void fillInSkips(SkWriter32* writer, int32_t restoreOffset) {
         // Since we write out the entire clip stack at each block start we
         // need to update the skips for the entire stack each time too.
         SkDeque::F2BIter iter(fMatrixClipStack);
 
@@ skipping 13 matching lines @@
     SkDeque          fMatrixClipStack;
     MatrixClipState* fCurMCState;
 
     // This dictionary doesn't actually de-duplicate the matrices (except for the
     // identity matrix). It merely stores the matrices and allows them to be looked
     // up by ID later. The de-duplication mainly falls upon the matrix/clip stack 
     // which stores the ID so a revisited clip/matrix (via popping the stack) will 
     // use the same ID.
     SkTDArray<SkMatrix> fMatrixDict;
 
+    SkTDArray<SkRegion*> fRegionDict;
+
     // The MCStateID of the state currently in effect in the byte stream. 0 if none.
     int32_t          fCurOpenStateID;
 
     SkDEBUGCODE(void validate();)
 
     void writeDeltaMat(int currentMatID, int desiredMatID);
     static int32_t   NewMCStateID();
 
+    int addRegionToDict(const SkRegion& region);
+    const SkRegion* lookupRegion(int index) {
+        SkASSERT(index >= 0 && index < fRegionDict.count());
+        return fRegionDict[index];        
+    }
+
     // TODO: add stats to check if the dictionary really does
     // reduce the size of the SkPicture.
     int addMatToDict(const SkMatrix& mat);
     const SkMatrix& lookupMat(int index) {
         SkASSERT(index >= 0 && index < fMatrixDict.count());
         return fMatrixDict[index];
     }
 };
 
 #endif