Revert changes which were breaking the build.

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"
@@ skipping 102 matching lines @@
             bool clipRect(const SkRect& rect,
                           SkRegion::Op op,
                           bool doAA,
                           int matrixID) {
                 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.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,
                             int regionID,
                             SkRegion::Op op,
                             int matrixID);
-            void writeClip(int* curMatID, SkMatrixClipStateMgr* mgr);
+            void writeClip(int* curMatID,
+                           SkMatrixClipStateMgr* mgr,
+                           bool* overrideFirstOp);
+            void fillInSkips(SkWriter32* writer, int32_t restoreOffset);
 
-            SkDEBUGCODE(int numClips() const { return fClips.count(); })
-
+#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:
                 ClipType     fClipType;
 
                 union {
                     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;
             };
 
             SkTDArray<ClipOp> fClips;
 
             typedef SkNoncopyable INHERITED;
         };
 
         MatrixClipState(MatrixClipState* prev, int flags)
 #ifdef SK_DEBUG
             : fPrev(prev)
@@ skipping 40 matching lines @@
         ClipInfo*    fClipInfo;
         ClipInfo     fClipInfoStorage;
 
         // Tracks the current depth of saveLayers to support the isDrawingToLayer call
         int          fLayerID;
         // Does this MC state represent a saveLayer call?
         bool         fIsSaveLayer;
 
         // The next two fields are only valid when fIsSaveLayer is set.
         int32_t      fSaveLayerBaseStateID;
-        SkTDArray<int>* fSavedSkipOffsets;
+        bool         fSaveLayerBracketed;
 
 #ifdef SK_DEBUG
         MatrixClipState* fPrev; // debugging aid
 #endif
 
         int32_t     fMCStateID;
     };
 
     enum CallType {
         kMatrix_CallType,
@@ skipping 77 matching lines @@
 
     bool clipRegion(const SkRegion& region, SkRegion::Op op) {
         this->call(SkMatrixClipStateMgr::kClip_CallType);
         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);
+    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);
+
+        for (const MatrixClipState* state = (const MatrixClipState*) iter.next();
+             state != NULL;
+             state = (const MatrixClipState*) iter.next()) {
+            state->fClipInfo->fillInSkips(writer, restoreOffset);
+        }
+    }
 
     void finish();
 
 protected:
     SkPictureRecord* fPicRecord;
 
     uint32_t         fMatrixClipStackStorage[43]; // sized to fit 2 clip states
     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;
-    // The skip offsets for the current open state. These are the locations in the 
-    // skp that must be filled in when the current open state is closed. These are
-    // here rather then distributed across the MatrixClipState's because saveLayers
-    // can cause MC states to be nested.
-    SkTDArray<int32_t>  *fSkipOffsets;
 
     SkDEBUGCODE(void validate();)
 
-    int MCStackPush(SkCanvas::SaveFlags flags);
-
-    void addClipOffset(int offset) {
-        SkASSERT(NULL != fSkipOffsets);
-        SkASSERT(kIdentityWideOpenStateID != fCurOpenStateID);
-
-        *fSkipOffsets->append() = offset;
-    }
-
     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