Revert "Serialization of SkPictureImageFilter"

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"
 #include "SkPicture.h"
 #include "SkPictureFlat.h"
 #include "SkPictureRecord.h"
 
 // This test exercises the Matrix/Clip State collapsing system. It generates
 // example skps and the compares the actual stored operations to the expected
 // operations. The test works by emitting canvas operations at three levels:
 // overall structure, bodies that draw something and model/clip state changes.
 //
 // Structure methods only directly emit save and restores but call the
 // ModelClip and Body helper methods to fill in the structure. Since they only
 // emit saves and restores the operations emitted by the structure methods will
-// be completely removed by the matrix/clip collapse. Note: every save in
+// be completely removed by the matrix/clip collapse. Note: every save in 
 // a structure method is followed by a call to a ModelClip helper.
 //
 // Body methods only directly emit draw ops and saveLayer/restore pairs but call
 // the ModelClip helper methods. Since the body methods emit the ops that cannot
 // be collapsed (i.e., draw ops, saveLayer/restore) they also generate the
 // expected result information. Note: every saveLayer in a body method is
 // followed by a call to a ModelClip helper.
 //
 // The ModelClip methods output matrix and clip ops in various orders and
-// combinations. They contribute to the expected result by outputting the
+// combinations. They contribute to the expected result by outputting the 
 // expected matrix & clip ops. Note that, currently, the entire clip stack
 // is output for each MC state so the clip operations accumulate down the
 // save/restore stack.
 
 // TODOs:
 //   check on clip offsets
 //      - not sure if this is possible. The desire is to verify that the clip
 //        operations' offsets point to the correct follow-on operations. This
 //        could be difficult since there is no good way to communicate the
 //        offset stored in the SkPicture to the debugger's clip objects
-//   add comparison of rendered before & after images?
+//   add comparison of rendered before & after images? 
 //      - 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
 
@@ skipping 69 matching lines @@
     kTextOnPath_DrawOpType,
     kTextTopBottom_DrawOpType,
     kDrawVertices_DrawOpType,
 #endif
 
     kLast_DrawOpType = kRect_DrawOpType
 };
 
 static const int kDrawOpTypeCount = kLast_DrawOpType + 1;
 
-typedef void (*PFEmitMC)(SkCanvas* canvas, MatType mat, ClipType clip,
-                         DrawOpType draw, SkTDArray<DrawType>* expected,
+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,
+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,
+typedef void (*PFEmitStruct)(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, 
+                             ClipType clip, PFEmitBody emitBody, DrawOpType draw, 
                              SkTDArray<DrawType>* expected);
 
 //////////////////////////////////////////////////////////////////////////////
 
 // TODO: expand the testing to include the different ops & AA types!
 static void emit_clip(SkCanvas* canvas, ClipType clip) {
     switch (clip) {
         case kNone_ClipType:
             break;
         case kRect_ClipType: {
@@ skipping 102 matching lines @@
     }
 
     switch (mat) {
     case kNone_MatType:
         break;
     case kTranslate_MatType:    // fall thru
     case kScale_MatType:        // fall thru
     case kSkew_MatType:         // fall thru
     case kRotate_MatType:       // fall thru
     case kConcat_MatType:       // fall thru
-    case kSetMatrix_MatType:
+    case kSetMatrix_MatType:    
         // TODO: this system currently converts a setMatrix to concat. If we wanted to
         // really preserve the setMatrix semantics we should keep it a setMatrix. I'm
         // not sure if this is a good idea though since this would keep things like pinch
         // zoom from working.
         *expected->append() = CONCAT;
         break;
     default:
         SkASSERT(0);
     }
-}
+} 
 
 static void emit_draw(SkCanvas* canvas, DrawOpType draw, SkTDArray<DrawType>* expected) {
     switch (draw) {
         case kNone_DrawOpType:
             break;
         case kClear_DrawOpType:
             canvas->clear(SK_ColorRED);
             *expected->append() = DRAW_CLEAR;
             break;
         case kOval_DrawOpType: {
@@ skipping 23 matching lines @@
             SkASSERT(0);
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 // 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,
+static void emit_clip_and_mat(SkCanvas* canvas, MatType mat, ClipType clip, 
+                              DrawOpType draw, SkTDArray<DrawType>* expected, 
                               int accumulatedClips) {
     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,
+static void emit_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);
 
     // 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,
+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);
 
     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);
 
     for (int i = 0; i < accumulatedClips; ++i) {
         add_clip(clip, mat, expected);
         add_clip(clip, mat, expected);
     }
     add_mat(mat, expected);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 // Emit:
 //  matrix & clip calls
 //  draw op
-static void emit_body0(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body0(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, 
                        ClipType clip, DrawOpType draw,
                        SkTDArray<DrawType>* expected, int accumulatedClips) {
-    bool needsSaveRestore = kNone_DrawOpType != draw &&
+    bool needsSaveRestore = kNone_DrawOpType != draw && 
                             (kNone_MatType != mat || kNone_ClipType != clip);
 
     if (needsSaveRestore) {
         *expected->append() = SAVE;
     }
     (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+1);
     emit_draw(canvas, draw, expected);
     if (needsSaveRestore) {
         *expected->append() = RESTORE;
     }
 }
 
 // Emit:
 //  matrix & clip calls
 //  draw op
 //  matrix & clip calls
 //  draw op
-static void emit_body1(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body1(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, 
                        ClipType clip, DrawOpType draw,
                        SkTDArray<DrawType>* expected, int accumulatedClips) {
-    bool needsSaveRestore = kNone_DrawOpType != draw &&
+    bool needsSaveRestore = kNone_DrawOpType != draw && 
                             (kNone_MatType != mat || kNone_ClipType != clip);
 
     if (needsSaveRestore) {
         *expected->append() = SAVE;
     }
     (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+1);
     emit_draw(canvas, draw, expected);
     if (needsSaveRestore) {
         *expected->append() = RESTORE;
         *expected->append() = SAVE;
     }
     (*emitMC)(canvas, mat, clip, draw, expected, accumulatedClips+2);
     emit_draw(canvas, draw, expected);
     if (needsSaveRestore) {
         *expected->append() = RESTORE;
     }
 }
 
 // Emit:
 //  matrix & clip calls
 //  SaveLayer
 //      matrix & clip calls
 //      draw op
 //  Restore
-static void emit_body2(SkCanvas* canvas, PFEmitMC emitMC, MatType mat,
+static void emit_body2(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, 
                        ClipType clip, DrawOpType draw,
                        SkTDArray<DrawType>* expected, int accumulatedClips) {
-    bool needsSaveRestore = kNone_DrawOpType != draw &&
+    bool needsSaveRestore = kNone_DrawOpType != draw && 
                             (kNone_MatType != mat || kNone_ClipType != clip);
 
     if (needsSaveRestore) {
         *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;
@@ skipping 12 matching lines @@
 // 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,
+static void emit_body3(SkCanvas* canvas, PFEmitMC emitMC, MatType mat, 
                        ClipType clip, DrawOpType draw,
                        SkTDArray<DrawType>* expected, int accumulatedClips) {
-    bool needsSaveRestore = kNone_DrawOpType != draw &&
+    bool needsSaveRestore = kNone_DrawOpType != draw && 
                             (kNone_MatType != mat || kNone_ClipType != clip);
 
-    // This saveLayer will always be forced b.c. we currently can't tell
+    // 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, draw, NULL, 0); // these get fused into later ops
         if (needsSaveRestore) {
             *expected->append() = SAVE_LAYER;
         }
@@ skipping 17 matching lines @@
     *expected->append() = RESTORE;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 // Emit:
 //  Save
 //      some body
 //  Restore
 // Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct0(SkCanvas* canvas,
+static void emit_struct0(SkCanvas* canvas, 
                          PFEmitMC emitMC, MatType mat, ClipType clip,
                          PFEmitBody emitBody, DrawOpType draw,
                          SkTDArray<DrawType>* expected) {
     (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 0);
 }
 
 // Emit:
 //  Save
 //      matrix & clip calls
 //      Save
 //          some body
 //      Restore
 //      matrix & clip calls (will be ignored)
 //  Restore
 // Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct1(SkCanvas* canvas,
+static void emit_struct1(SkCanvas* canvas, 
                          PFEmitMC emitMC, MatType mat, ClipType clip,
                          PFEmitBody emitBody, DrawOpType draw,
                          SkTDArray<DrawType>* expected) {
     (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these get fused into later ops
     canvas->save();
         (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1);
     canvas->restore();
     (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these will get removed
 }
 
 // Emit:
 //  Save
 //      matrix & clip calls
 //      Save
 //          some body
 //      Restore
 //      Save
 //          some body
 //      Restore
 //      matrix & clip calls (will be ignored)
 //  Restore
 // Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct2(SkCanvas* canvas,
+static void emit_struct2(SkCanvas* canvas, 
                          PFEmitMC emitMC, MatType mat, ClipType clip,
                          PFEmitBody emitBody, DrawOpType draw,
                          SkTDArray<DrawType>* expected) {
     (*emitMC)(canvas, mat, clip, draw, NULL, 1); // these will get fused into later ops
     canvas->save();
         (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1);
     canvas->restore();
     canvas->save();
         (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1);
     canvas->restore();
     (*emitMC)(canvas, mat, clip, draw, NULL, 1); // these will get removed
 }
 
 // Emit:
 //  Save
 //      matrix & clip calls
 //      Save
 //          some body
 //      Restore
 //      Save
 //          matrix & clip calls
 //          Save
 //              some body
 //          Restore
 //      Restore
 //      matrix & clip calls (will be ignored)
 //  Restore
 // Note: the outer save/restore are provided by beginRecording/endRecording
-static void emit_struct3(SkCanvas* canvas,
+static void emit_struct3(SkCanvas* canvas, 
                          PFEmitMC emitMC, MatType mat, ClipType clip,
                          PFEmitBody emitBody, DrawOpType draw,
                          SkTDArray<DrawType>* expected) {
     (*emitMC)(canvas, mat, clip, draw, NULL, 0); // these will get fused into later ops
     canvas->save();
         (*emitBody)(canvas, emitMC, mat, clip, draw, expected, 1);
     canvas->restore();
     canvas->save();
         (*emitMC)(canvas, mat, clip, draw, NULL, 1); // these will get fused into later ops
         canvas->save();
@@ skipping 24 matching lines @@
         }
     }
     SkDebugf("\n\n");
     SkASSERT(0);
 }
 #endif
 
 static void test_collapse(skiatest::Reporter* reporter) {
     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,
+    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
                             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],
+                            (*gStructure[i])(canvas, 
+                                             gMCs[k], 
                                              (MatType) l,
                                              (ClipType) m,
-                                             gBody[j],
-                                             (DrawOpType) n,
+                                             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
                                 print(expected, actual);
@@ skipping 16 matching lines @@
             }
         }
     }
 }
 
 DEF_TEST(MatrixClipCollapse, reporter) {
     test_collapse(reporter);
 }
 
 #endif