Modernize SkRecordPattern.h

src/core/SkRecordOpts.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 "SkRecordOpts.h"
 
 #include "SkRecordPattern.h"
 #include "SkRecords.h"
 #include "SkTDArray.h"
 
 using namespace SkRecords;
 
 void SkRecordOptimize(SkRecord* record) {
     // This might be useful  as a first pass in the future if we want to weed
     // out junk for other optimization passes.  Right now, nothing needs it,
     // and the bounding box hierarchy will do the work of skipping no-op
     // Save-NoDraw-Restore sequences better than we can here.
     //SkRecordNoopSaveRestores(record);
 
     SkRecordNoopSaveLayerDrawRestores(record);
     SkRecordMergeSvgOpacityAndFilterLayers(record);
 }
 
 // Most of the optimizations in this file are pattern-based.  These are all defined as structs with:
-//   - a Pattern typedef
-//   - a bool onMatch(SkRceord*, Pattern*, int begin, int end) method,
+//   - a Match typedef
+//   - a bool onMatch(SkRceord*, Match*, int begin, int end) method,
 //     which returns true if it made changes and false if not.
 
 // Run a pattern-based optimization once across the SkRecord, returning true if it made any changes.
-// It looks for spans which match Pass::Pattern, and when found calls onMatch() with the pattern,
+// It looks for spans which match Pass::Match, and when found calls onMatch() with that pattern,
 // record, and [begin,end) span of the commands that matched.
 template <typename Pass>
 static bool apply(Pass* pass, SkRecord* record) {
-    typename Pass::Pattern pattern;
+    typename Pass::Match match;
     bool changed = false;
     int begin, end = 0;
 
-    while (pattern.search(record, &begin, &end)) {
-        changed |= pass->onMatch(record, &pattern, begin, end);
+    while (match.search(record, &begin, &end)) {
+        changed |= pass->onMatch(record, &match, begin, end);
     }
     return changed;
 }
 
 // Turns the logical NoOp Save and Restore in Save-Draw*-Restore patterns into actual NoOps.
 struct SaveOnlyDrawsRestoreNooper {
-    typedef Pattern3<Is<Save>,
-                     Star<Or<Is<NoOp>, IsDraw> >,
-                     Is<Restore> >
-        Pattern;
+    typedef Pattern<Is<Save>,
+                    Greedy<Or<Is<NoOp>, IsDraw>>,
+                    Is<Restore>>
+        Match;
 
-    bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) {
+    bool onMatch(SkRecord* record, Match*, int begin, int end) {
         record->replace<NoOp>(begin);  // Save
         record->replace<NoOp>(end-1);  // Restore
         return true;
     }
 };
 
 static bool fold_opacity_layer_color_to_paint(const SkPaint& layerPaint,
                                               bool isSaveLayer,
                                               SkPaint* paint) {
     // We assume layerPaint is always from a saveLayer.  If isSaveLayer is
@@ skipping 45 matching lines @@
         return false;
     }
 
     paint->setAlpha(SkMulDiv255Round(paint->getAlpha(), SkColorGetA(layerColor)));
 
     return true;
 }
 
 // Turns logical no-op Save-[non-drawing command]*-Restore patterns into actual no-ops.
 struct SaveNoDrawsRestoreNooper {
-    // Star matches greedily, so we also have to exclude Save and Restore.
+    // Greedy matches greedily, so we also have to exclude Save and Restore.
     // Nested SaveLayers need to be excluded, or we'll match their Restore!
-    typedef Pattern3<Is<Save>,
-                     Star<Not<Or4<Is<Save>,
+    typedef Pattern<Is<Save>,
+                    Greedy<Not<Or<Is<Save>,
                                   Is<SaveLayer>,
                                   Is<Restore>,
-                                  IsDraw> > >,
-                     Is<Restore> >
-        Pattern;
+                                  IsDraw>>>,
+                    Is<Restore>>
+        Match;
 
-    bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) {
+    bool onMatch(SkRecord* record, Match*, int begin, int end) {
         // The entire span between Save and Restore (inclusively) does nothing.
         for (int i = begin; i < end; i++) {
             record->replace<NoOp>(i);
         }
         return true;
     }
 };
 void SkRecordNoopSaveRestores(SkRecord* record) {
     SaveOnlyDrawsRestoreNooper onlyDraws;
     SaveNoDrawsRestoreNooper noDraws;
 
     // Run until they stop changing things.
     while (apply(&onlyDraws, record) || apply(&noDraws, record));
 }
 
 // For some SaveLayer-[drawing command]-Restore patterns, merge the SaveLayer's alpha into the
 // draw, and no-op the SaveLayer and Restore.
 struct SaveLayerDrawRestoreNooper {
-    typedef Pattern3<Is<SaveLayer>, IsDraw, Is<Restore> > Pattern;
+    typedef Pattern<Is<SaveLayer>, IsDraw, Is<Restore>> Match;
 
-    bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) {
+    bool onMatch(SkRecord* record, Match* match, int begin, int end) {
         // A SaveLayer's bounds field is just a hint, so we should be free to ignore it.
-        SkPaint* layerPaint = pattern->first<SaveLayer>()->paint;
+        SkPaint* layerPaint = match->first<SaveLayer>()->paint;
         if (nullptr == layerPaint) {
             // There wasn't really any point to this SaveLayer at all.
             return KillSaveLayerAndRestore(record, begin);
         }
 
-        SkPaint* drawPaint = pattern->second<SkPaint>();
+        SkPaint* drawPaint = match->second<SkPaint>();
         if (drawPaint == nullptr) {
             // We can just give the draw the SaveLayer's paint.
             // TODO(mtklein): figure out how to do this clearly
             return false;
         }
 
         if (!fold_opacity_layer_color_to_paint(*layerPaint, false /*isSaveLayer*/, drawPaint)) {
             return false;
         }
 
@@ skipping 15 matching lines @@
 /* For SVG generated:
   SaveLayer (non-opaque, typically for CSS opacity)
     Save
       ClipRect
       SaveLayer (typically for SVG filter)
       Restore
     Restore
   Restore
 */
 struct SvgOpacityAndFilterLayerMergePass {
-    typedef Pattern7<Is<SaveLayer>, Is<Save>, Is<ClipRect>, Is<SaveLayer>,
-                     Is<Restore>, Is<Restore>, Is<Restore> > Pattern;
+    typedef Pattern<Is<SaveLayer>, Is<Save>, Is<ClipRect>, Is<SaveLayer>,
+                    Is<Restore>, Is<Restore>, Is<Restore>> Match;
 
-    bool onMatch(SkRecord* record, Pattern* pattern, int begin, int end) {
-        SkPaint* opacityPaint = pattern->first<SaveLayer>()->paint;
+    bool onMatch(SkRecord* record, Match* match, int begin, int end) {
+        SkPaint* opacityPaint = match->first<SaveLayer>()->paint;
         if (nullptr == opacityPaint) {
             // There wasn't really any point to this SaveLayer at all.
             return KillSaveLayerAndRestore(record, begin);
         }
 
         // This layer typically contains a filter, but this should work for layers with for other
         // purposes too.
-        SkPaint* filterLayerPaint = pattern->fourth<SaveLayer>()->paint;
+        SkPaint* filterLayerPaint = match->fourth<SaveLayer>()->paint;
         if (filterLayerPaint == nullptr) {
             // We can just give the inner SaveLayer the paint of the outer SaveLayer.
             // TODO(mtklein): figure out how to do this clearly
             return false;
         }
 
         if (!fold_opacity_layer_color_to_paint(*opacityPaint, true /*isSaveLayer*/,
                                                filterLayerPaint)) {
             return false;
         }
 
         return KillSaveLayerAndRestore(record, begin);
     }
 
     static bool KillSaveLayerAndRestore(SkRecord* record, int saveLayerIndex) {
         record->replace<NoOp>(saveLayerIndex);     // SaveLayer
         record->replace<NoOp>(saveLayerIndex + 6); // Restore
         return true;
     }
 };
 
 void SkRecordMergeSvgOpacityAndFilterLayers(SkRecord* record) {
     SvgOpacityAndFilterLayerMergePass pass;
     apply(&pass, record);
 }