add region to dictionary in SkMatrixClipStackMgr

src/core/SkMatrixClipStateMgr.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrixClipStateMgr.h"
 #include "SkPictureRecord.h"
 
 bool SkMatrixClipStateMgr::MatrixClipState::ClipInfo::clipPath(SkPictureRecord* picRecord,
                                                                const SkPath& path,
                                                                SkRegion::Op op,
                                                                bool doAA,
                                                                int matrixID) {
     int pathID = picRecord->addPathToHeap(path);
 
-    ClipOp& newClip = fClips.push_back();
-    newClip.fClipType = kPath_ClipType;
-    newClip.fGeom.fPathID = pathID;
-    newClip.fOp = op;
-    newClip.fDoAA = doAA;
-    newClip.fMatrixID = matrixID;
-    newClip.fOffset = kInvalidJumpOffset;
+    ClipOp* newClip = fClips.append();
+    newClip->fClipType = kPath_ClipType;
+    newClip->fGeom.fPathID = pathID;
+    newClip->fOp = op;
+    newClip->fDoAA = doAA;
+    newClip->fMatrixID = matrixID;
+    newClip->fOffset = kInvalidJumpOffset;
     return false;
 }
 
 bool SkMatrixClipStateMgr::MatrixClipState::ClipInfo::clipRegion(SkPictureRecord* picRecord,
-                                                                 const SkRegion& region,
+                                                                 int regionID,
                                                                  SkRegion::Op op,
                                                                  int matrixID) {
     // TODO: add a region dictionary so we don't have to copy the region in here
-    ClipOp& newClip = fClips.push_back();
-    newClip.fClipType = kRegion_ClipType;
-    newClip.fGeom.fRegion = SkNEW(SkRegion(region));
-    newClip.fOp = op;
-    newClip.fDoAA = true;      // not necessary but sanity preserving
-    newClip.fMatrixID = matrixID;
-    newClip.fOffset = kInvalidJumpOffset;
+    ClipOp* newClip = fClips.append();
+    newClip->fClipType = kRegion_ClipType;
+    newClip->fGeom.fRegionID = regionID;
+    newClip->fOp = op;
+    newClip->fDoAA = true;      // not necessary but sanity preserving
+    newClip->fMatrixID = matrixID;
+    newClip->fOffset = kInvalidJumpOffset;
     return false;
 }
 
 void SkMatrixClipStateMgr::writeDeltaMat(int currentMatID, int desiredMatID) {
     const SkMatrix& current = this->lookupMat(currentMatID);
     const SkMatrix& desired = this->lookupMat(desiredMatID);
 
     SkMatrix delta;
     bool result = current.invert(&delta);
     if (result) {
@@ skipping 35 matching lines @@
                                                                   op, curClip.fDoAA);
             break;
         case kRRect_ClipType:
             curClip.fOffset = mgr->getPicRecord()->recordClipRRect(curClip.fGeom.fRRect, op, 
                                                                    curClip.fDoAA);
             break;
         case kPath_ClipType:
             curClip.fOffset = mgr->getPicRecord()->recordClipPath(curClip.fGeom.fPathID, op, 
                                                                   curClip.fDoAA);
             break;
-        case kRegion_ClipType:
-            curClip.fOffset = mgr->getPicRecord()->recordClipRegion(*curClip.fGeom.fRegion, op);
+        case kRegion_ClipType: {
+            const SkRegion* region = mgr->lookupRegion(curClip.fGeom.fRegionID);
+            curClip.fOffset = mgr->getPicRecord()->recordClipRegion(*region, op);
             break;
+        }
         default:
             SkASSERT(0);
         }
     }
 }
 
 // Fill in the skip offsets for all the clips written in the current block
 void SkMatrixClipStateMgr::MatrixClipState::ClipInfo::fillInSkips(SkWriter32* writer,
                                                                   int32_t restoreOffset) {
     for (int i = 0; i < fClips.count(); ++i) {
@@ skipping 16 matching lines @@
                        sizeof(fMatrixClipStackStorage))
     , fCurOpenStateID(kIdentityWideOpenStateID) {
 
     // The first slot in the matrix dictionary is reserved for the identity matrix
     fMatrixDict.append()->reset();
 
     fCurMCState = (MatrixClipState*)fMatrixClipStack.push_back();
     new (fCurMCState) MatrixClipState(NULL, 0);    // balanced in restore()
 }
 
+SkMatrixClipStateMgr::~SkMatrixClipStateMgr() {
+    for (int i = 0; i < fRegionDict.count(); ++i) {
+        SkDELETE(fRegionDict[i]);
+    }
+}
+
 
 int SkMatrixClipStateMgr::save(SkCanvas::SaveFlags flags) {
     SkDEBUGCODE(this->validate();)
 
     MatrixClipState* newTop = (MatrixClipState*)fMatrixClipStack.push_back();
     new (newTop) MatrixClipState(fCurMCState, flags); // balanced in restore()
     fCurMCState = newTop;
 
     SkDEBUGCODE(this->validate();)
 
@@ skipping 117 matching lines @@
 
         for (const MatrixClipState* state = (const MatrixClipState*) iter.next();
              state != NULL;
              state = (const MatrixClipState*) iter.next()) {
             state->fClipInfo->checkOffsetNotEqual(-1);
         }
     }
 }
 #endif
 
+int SkMatrixClipStateMgr::addRegionToDict(const SkRegion& region) {
+    int index = fRegionDict.count();
+    *fRegionDict.append() = SkNEW(SkRegion(region));
+    return index;
+}
+
 int SkMatrixClipStateMgr::addMatToDict(const SkMatrix& mat) {
     if (mat.isIdentity()) {
         return kIdentityMatID;
     }
 
     *fMatrixDict.append() = mat;
     return fMatrixDict.count()-1;
 }