Revert changes which were breaking the build.

tests/MatrixClipCollapseTest.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 "Test.h"
 #include "SkCanvas.h"
 #include "SkDebugCanvas.h"
@@ skipping 111 matching lines @@
     kRect_DrawOpType,
     kRRect_DrawOpType,
 #if 0
     kSprite_DrawOpType,
     kText_DrawOpType,
     kTextOnPath_DrawOpType,
     kTextTopBottom_DrawOpType,
     kDrawVertices_DrawOpType,
 #endif
 
-    kLastNonSaveLayer_DrawOpType = kRect_DrawOpType,
-
-    // saveLayer's have to handled apart from the other draw operations
-    // since they also alter the save/restore structure.
-    kSaveLayer_DrawOpType,
+    kLast_DrawOpType = kRect_DrawOpType
 };
 
-static const int kNonSaveLayerDrawOpTypeCount = kLastNonSaveLayer_DrawOpType + 1;
+static const int kDrawOpTypeCount = kLast_DrawOpType + 1;
 
 typedef void (*PFEmitMC)(SkCanvas* canvas, MatType mat, ClipType clip,
                          DrawOpType draw, SkTDArray<DrawType>* expected,
                          int accumulatedClips);
 typedef void (*PFEmitBody)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
                            ClipType clip, DrawOpType draw,
                            SkTDArray<DrawType>* expected, int accumulatedClips);
 typedef void (*PFEmitStruct)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
                              ClipType clip, PFEmitBody emitBody, DrawOpType draw,
                              SkTDArray<DrawType>* expected);
@@ skipping 168 matching lines @@
 
 //////////////////////////////////////////////////////////////////////////////
 
 // Emit:
 //  clip
 //  matrix
 // Simple case - the clip isn't effect by the matrix
 static void emit_clip_and_mat(SkCanvas* canvas, MatType mat, ClipType clip,
                               DrawOpType draw, SkTDArray<DrawType>* expected,
                               int accumulatedClips) {
-    emit_clip(canvas, clip);
-    emit_mat(canvas, mat);
-
     if (kNone_DrawOpType == draw) {
         return;
     }
 
+    emit_clip(canvas, clip);
+    emit_mat(canvas, mat);
+
     for (int i = 0; i < accumulatedClips; ++i) {
         add_clip(clip, mat, expected);
     }
     add_mat(mat, expected);
 }
 
 // Emit:
 //  matrix
 //  clip
 // Emitting the matrix first is more challenging since the matrix has to be
 // pushed across (i.e., applied to) the clip.
 static void emit_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip,
                               DrawOpType draw, SkTDArray<DrawType>* expected,
                               int accumulatedClips) {
-    emit_mat(canvas, mat);
-    emit_clip(canvas, clip);
-
     if (kNone_DrawOpType == draw) {
         return;
     }
 
+    emit_mat(canvas, mat);
+    emit_clip(canvas, clip);
+
     // the matrix & clip order will be reversed once collapsed!
     for (int i = 0; i < accumulatedClips; ++i) {
         add_clip(clip, mat, expected);
     }
     add_mat(mat, expected);
 }
 
 // Emit:
 //  matrix
 //  clip
 //  matrix
 //  clip
 // This tests that the matrices and clips coalesce when collapsed
 static void emit_double_mat_and_clip(SkCanvas* canvas, MatType mat, ClipType clip,
                                      DrawOpType draw, SkTDArray<DrawType>* expected,
                                      int accumulatedClips) {
+    if (kNone_DrawOpType == draw) {
+        return;
+    }
+
     emit_mat(canvas, mat);
     emit_clip(canvas, clip);
     emit_mat(canvas, mat);
     emit_clip(canvas, clip);
 
-    if (kNone_DrawOpType == draw) {
-        return;
-    }
-
     for (int i = 0; i < accumulatedClips; ++i) {
         add_clip(clip, mat, expected);
         add_clip(clip, mat, expected);
     }
     add_mat(mat, expected);
 }
 
 // Emit:
 //  matrix
 //  clip
 //  clip
 // This tests accumulation of clips in same transform state. It also tests pushing
 // of the matrix across both the clips.
 static void emit_mat_clip_clip(SkCanvas* canvas, MatType mat, ClipType clip,
                                DrawOpType draw, SkTDArray<DrawType>* expected,
                                int accumulatedClips) {
+    if (kNone_DrawOpType == draw) {
+        return;
+    }
+
     emit_mat(canvas, mat);
     emit_clip(canvas, clip);
     emit_clip(canvas, clip);
 
-    if (kNone_DrawOpType == draw) {
-        return;
-    }
-
     for (int i = 0; i < accumulatedClips; ++i) {
         add_clip(clip, mat, expected);
         add_clip(clip, mat, expected);
     }
     add_mat(mat, expected);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 // Emit:
@@ skipping 47 matching lines @@
 //  SaveLayer
 //      matrix & clip calls
 //      draw op
 //  Restore
 static void emit_body2(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
                        ClipType clip, DrawOpType draw,
                        SkTDArray<DrawType>* expected, int accumulatedClips) {
     bool needsSaveRestore = kNone_DrawOpType != draw &&
                             (kNone_MatType != mat || kNone_ClipType != clip);
 
-    if (kNone_MatType != mat || kNone_ClipType != clip) {
-        *expected->append() = SAVE;
+    if (needsSaveRestore) {
+        *expected->append() = SAVE_LAYER;
     }
-    (*emitMC)(canvas, mat, clip, kSaveLayer_DrawOpType, expected, accumulatedClips+1);
-    *expected->append() = SAVE_LAYER;
+    (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these get fused into later ops
     // TODO: widen testing to exercise saveLayer's parameters
     canvas->saveLayer(NULL, NULL);
         if (needsSaveRestore) {
             *expected->append() = SAVE;
         }
-        (*emitMC)(canvas, mat, clip, draw, expected, 1);
+        (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+2);
         emit_draw(canvas, draw, expected);
         if (needsSaveRestore) {
             *expected->append() = RESTORE;
         }
     canvas->restore();
-    *expected->append() = RESTORE;
-    if (kNone_MatType != mat || kNone_ClipType != clip) {
+    if (needsSaveRestore) {
         *expected->append() = RESTORE;
     }
 }
 
 // Emit:
 //  matrix & clip calls
 //  SaveLayer
 //      matrix & clip calls
 //      SaveLayer
 //          matrix & clip calls
 //          draw op
 //      Restore
 //      matrix & clip calls (will be ignored)
 //  Restore
 static void emit_body3(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
                        ClipType clip, DrawOpType draw,
                        SkTDArray<DrawType>* expected, int accumulatedClips) {
     bool needsSaveRestore = kNone_DrawOpType != draw &&
                             (kNone_MatType != mat || kNone_ClipType != clip);
 
-    if (kNone_MatType != mat || kNone_ClipType != clip) {
-        *expected->append() = SAVE;
-    }
-    (*emitMC)(canvas, mat, clip, kSaveLayer_DrawOpType, expected, accumulatedClips+1); 
+    // This saveLayer will always be forced b.c. we currently can't tell
+    // ahead of time if it will be empty (see comment in SkMatrixClipStateMgr::save)
     *expected->append() = SAVE_LAYER;
+
+    (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these get fused into later ops
     // TODO: widen testing to exercise saveLayer's parameters
     canvas->saveLayer(NULL, NULL);
-        (*emitMC)(canvas, mat, clip, kSaveLayer_DrawOpType, expected, 1);
-        if (kNone_MatType != mat || kNone_ClipType != clip) {
-            *expected->append() = SAVE;
+        (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these get fused into later ops
+        if (needsSaveRestore) {
+            *expected->append() = SAVE_LAYER;
         }
-        *expected->append() = SAVE_LAYER;
         // TODO: widen testing to exercise saveLayer's parameters
         canvas->saveLayer(NULL, NULL);
             if (needsSaveRestore) {
                 *expected->append() = SAVE;
             }
-            (*emitMC)(canvas, mat, clip, draw, expected, 1);
+            (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+3);
             emit_draw(canvas, draw, expected);
             if (needsSaveRestore) {
                 *expected->append() = RESTORE;
             }
-        canvas->restore();             // for saveLayer
-        *expected->append() = RESTORE; // for saveLayer
-        if (kNone_MatType != mat || kNone_ClipType != clip) {
+        canvas->restore();
+        if (needsSaveRestore) {
             *expected->append() = RESTORE;
         }
     canvas->restore();
+
     // required to match forced SAVE_LAYER
     *expected->append() = RESTORE;
-    if (kNone_MatType != mat || kNone_ClipType != clip) {
-        *expected->append() = RESTORE;
-    }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 // Emit:
 //  Save
 //      some body
 //  Restore
 // Note: the outer save/restore are provided by beginRecording/endRecording
 static void emit_struct0(SkCanvas* canvas,
@@ skipping 110 matching lines @@
     PFEmitStruct gStructure[] = { emit_struct0, emit_struct1, emit_struct2, emit_struct3 };
     PFEmitBody gBody[] = { emit_body0, emit_body1, emit_body2, emit_body3 };
     PFEmitMC gMCs[] = { emit_clip_and_mat, emit_mat_and_clip,
                         emit_double_mat_and_clip, emit_mat_clip_clip };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gStructure); ++i) {
         for (size_t j = 0; j < SK_ARRAY_COUNT(gBody); ++j) {
             for (size_t k = 0; k < SK_ARRAY_COUNT(gMCs); ++k) {
                 for (int l = 0; l < kMatTypeCount; ++l) {
                     for (int m = 0; m < kClipTypeCount; ++m) {
-                        for (int n = 0; n < kNonSaveLayerDrawOpTypeCount; ++n) {
+                        for (int n = 0; n < kDrawOpTypeCount; ++n) {
 #ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                             static int testID = -1;
                             ++testID;
                             if (testID < -1) {
                                 continue;
                             }
-                            SkDebugf("test: %d\n", testID);
 #endif
 
                             SkTDArray<DrawType> expected, actual;
 
                             SkPicture picture;
 
                             // Note: beginRecording/endRecording add a save/restore pair
                             SkCanvas* canvas = picture.beginRecording(100, 100);
                             (*gStructure[i])(canvas,
                                              gMCs[k],
@@ skipping 30 matching lines @@
             }
         }
     }
 }
 
 DEF_TEST(MatrixClipCollapse, reporter) {
     test_collapse(reporter);
 }
 
 #endif