Convert all SkRecordPattern matchers into SkRecord mutators.

src/record/SkRecordPattern.h

 #ifndef SkRecordPattern_DEFINED
 #define SkRecordPattern_DEFINED
 
 #include "SkTLogic.h"
 
 namespace SkRecords {
 
 // First, some matchers.  These match a single command in the SkRecord,
 // and may hang onto some data from it.  If so, you can get the data by calling .get().
 
 // Matches a command of type T, and stores that command.
 template <typename T>
 class Is {
 public:
     Is() : fPtr(NULL) {}
 
     typedef T type;
     type* get() { return fPtr; }
 
-    bool match(T* ptr) {
+    bool operator()(T* ptr) {
         fPtr = ptr;
         return true;
     }
 
     template <typename U>
-    bool match(U*) {
+    bool operator()(U*) {
         fPtr = NULL;
         return false;
     }
 
 private:
     type* fPtr;
 };
 
 // Matches any command that draws, and stores its paint.
 class IsDraw {
     SK_CREATE_MEMBER_DETECTOR(paint);
 public:
     IsDraw() : fPaint(NULL) {}
 
     typedef SkPaint type;
     type* get() { return fPaint; }
 
     template <typename T>
-    SK_WHEN(HasMember_paint<T>, bool) match(T* draw) {
+    SK_WHEN(HasMember_paint<T>, bool) operator()(T* draw) {
         fPaint = AsPtr(draw->paint);
         return true;
     }
 
     template <typename T>
-    SK_WHEN(!HasMember_paint<T>, bool) match(T*) {
+    SK_WHEN(!HasMember_paint<T>, bool) operator()(T*) {
         fPaint = NULL;
         return false;
     }
 
     // SaveLayer has an SkPaint named paint, but it's not a draw.
-    bool match(SaveLayer*) {
+    bool operator()(SaveLayer*) {
         fPaint = NULL;
         return false;
     }
 
 private:
     // Abstracts away whether the paint is always part of the command or optional.
     template <typename T> static T* AsPtr(SkRecords::Optional<T>& x) { return x; }
     template <typename T> static T* AsPtr(T& x) { return &x; }
 
     type* fPaint;
 };
 
 // Matches if Matcher doesn't.  Stores nothing.
 template <typename Matcher>
 struct Not {
     template <typename T>
-    bool match(T* ptr) { return !Matcher().match(ptr); }
+    bool operator()(T* ptr) { return !Matcher()(ptr); }
 };
 
 // Matches if either of A or B does.  Stores nothing.
 template <typename A, typename B>
 struct Or {
     template <typename T>
-    bool match(T* ptr) { return A().match(ptr) || B().match(ptr); }
+    bool operator()(T* ptr) { return A()(ptr) || B()(ptr); }
 };
 
 // Matches if any of A, B or C does.  Stores nothing.
 template <typename A, typename B, typename C>
 struct Or3 : Or<A, Or<B, C> > {};
 
 // We'll use this to choose which implementation of Star suits each Matcher.
 SK_CREATE_TYPE_DETECTOR(type);
 
 // Star is a special matcher that matches Matcher 0 or more times _greedily_ in the SkRecord.
 // This version stores nothing.  It's enabled when Matcher stores nothing.
 template <typename Matcher, typename = void>
 class Star {
 public:
     void reset() {}
 
     template <typename T>
-    bool match(T* ptr) { return Matcher().match(ptr); }
+    bool operator()(T* ptr) { return Matcher()(ptr); }
 };
 
 // This version stores a list of matches.  It's enabled if Matcher stores something.
 template <typename Matcher>
 class Star<Matcher, SK_WHEN(HasType_type<Matcher>, void)> {
 public:
     typedef SkTDArray<typename Matcher::type*> type;
     type* get() { return &fMatches; }
 
     void reset() { fMatches.rewind(); }
 
     template <typename T>
-    bool match(T* ptr) {
+    bool operator()(T* ptr) {
         Matcher matcher;
-        if (matcher.match(ptr)) {
+        if (matcher(ptr)) {
             fMatches.push(matcher.get());
             return true;
         }
         return false;
     }
 
 private:
     type fMatches;
 };
 
@@ skipping 29 matching lines @@
     }
 
     // Once either match or search has succeeded, access the stored data of the first, second,
     // or third matcher in this pattern.  Add as needed for longer patterns.
     // T is checked statically at compile time; no casting is involved.  It's just an API wart.
     template <typename T> T* first()  { return fHead.get(); }
     template <typename T> T* second() { return fTail.fHead.get(); }
     template <typename T> T* third()  { return fTail.fTail.fHead.get(); }
 
 private:
-    template <typename T>
-    void operator()(T* r) { fHeadMatched = fHead.match(r); }
-
     // If head isn't a Star, try to match at i once.
     template <typename T>
     unsigned matchHead(T*, SkRecord* record, unsigned i) {
         if (i < record->count()) {
-            fHeadMatched = false;
-            record->mutate(i, *this);
-            if (fHeadMatched) {
+            if (record->mutate<bool>(i, fHead)) {
                 return i+1;
             }
         }
         return 0;
     }
 
     // If head is a Star, walk i until it doesn't match.
     template <typename T>
     unsigned matchHead(Star<T>*, SkRecord* record, unsigned i) {
         fHead.reset();
         while (i < record->count()) {
-            fHeadMatched = false;
-            record->mutate(i, *this);
-            if (!fHeadMatched) {
+            if (!record->mutate<bool>(i, fHead)) {
                 return i;
             }
             i++;
         }
         return 0;
     }
 
     Matcher fHead;
     Pattern fTail;
-    bool fHeadMatched;
-
-    friend class ::SkRecord;  // So operator() can otherwise stay private.
 
     // All Cons are friends with each other.  This lets first, second, and third work.
     template <typename, typename> friend class Cons;
 };
 
 // Nil is the end of every pattern Cons chain.
 struct Nil {
     // Bottoms out recursion down the fTail chain.  Just return whatever i the front decided on.
     unsigned match(SkRecord*, unsigned i) { return i; }
 };
 
 // These Pattern# types are syntax sugar over Cons and Nil, just to help eliminate some of the
 // template noise.  Use these if you can.  Feel free to add more for longer patterns.
 // All types A, B, C, ... are Matchers.
 template <typename A>
 struct Pattern1 : Cons<A, Nil> {};
 
 template <typename A, typename B>
 struct Pattern2 : Cons<A, Pattern1<B> > {};
 
 template <typename A, typename B, typename C>
 struct Pattern3 : Cons<A, Pattern2<B, C> > {};
 
 }  // namespace SkRecords
 
 #endif//SkRecordPattern_DEFINED