Collapse matrix & clip stack in PictureRecord

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 34 matching lines @@
 //      - not sure if this would be useful since it somewhat duplicates the
 //        correctness test of running render_pictures in record mode and
 //        rendering before and after images. Additionally the matrix/clip collapse
 //        is sure to cause some small differences so an automated test might
 //        yield too many false positives.
 //   run the matrix/clip collapse system on the 10K skp set
 //      - this should give us warm fuzzies that the matrix clip collapse
 //        system is ready for prime time
 //   bench the recording times with/without matrix/clip collapsing
 
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
+
+// Enable/disable debugging helper code
+//#define TEST_COLLAPSE_MATRIX_CLIP_STATE 1
 
 // Extract the command ops from the input SkPicture
 static void gets_ops(SkPicture& input, SkTDArray<DrawType>* ops) {
     SkDebugCanvas debugCanvas(input.width(), input.height());
     debugCanvas.setBounds(input.width(), input.height());
     input.draw(&debugCanvas);
 
     ops->setCount(debugCanvas.getSize());
     for (int i = 0; i < debugCanvas.getSize(); ++i) {
         (*ops)[i] = debugCanvas.getDrawCommandAt(i)->getType();
@@ skipping 550 matching lines @@
         (*emitMC)(canvas, mat, clip, draw, NULL, 1); // these will get fused into later ops
         canvas->save();
             (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 2);
         canvas->restore();
     canvas->restore();
     (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these will get removed
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef SK_COLLAPSE_MATRIX_CLIP_STATE
 static void print(const SkTDArray<DrawType>& expected, const SkTDArray<DrawType>& actual) {
     SkDebugf("\n\nexpected %d --- actual %d\n", expected.count(), actual.count());
     int max = SkMax32(expected.count(), actual.count());
 
     for (int i = 0; i < max; ++i) {
         if (i < expected.count()) {
             SkDebugf("%16s,    ", SkDrawCommand::GetCommandString(expected[i]));
         } else {
             SkDebugf("%16s,    ", " ");
         }
@@ skipping 14 matching lines @@
     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 < kDrawOpTypeCount; ++n) {
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                             static int testID = -1;
                             ++testID;
                             if (testID < -1) {
                                 continue;
                             }
 #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],
                                              (MatType) l,
                                              (ClipType) m,
                                              gBody[j],
                                              (DrawOpType) n,
                                              &expected);
                             picture.endRecording();
 
                             gets_ops(picture, &actual);
 
                             REPORTER_ASSERT(reporter, expected.count() == actual.count());
 
                             if (expected.count() != actual.count()) {
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                                 print(expected, actual);
 #endif
                                 continue;
                             }
 
                             for (int i = 0; i < expected.count(); ++i) {
                                 REPORTER_ASSERT(reporter, expected[i] == actual[i]);
-#ifdef COLLAPSE_MATRIX_CLIP_STATE
+#ifdef TEST_COLLAPSE_MATRIX_CLIP_STATE
                                 if (expected[i] != actual[i]) {
                                     print(expected, actual);
                                 }
 #endif
                                 break;
                             }
                         }
                     }
                 }
             }
         }
     }
 }
 
 DEF_TEST(MatrixClipCollapse, reporter) {
     test_collapse(reporter);
 }
 
 #endif