Convert all SkRecordPattern matchers into SkRecord mutators.

src/record/SkRecord.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkRecord_DEFINED
 #define SkRecord_DEFINED
 
@@ skipping 15 matching lines @@
 // get this wrong.
 
 class SkRecord : SkNoncopyable {
 public:
     SkRecord(size_t chunkBytes = 4096, unsigned firstReserveCount = 64 / sizeof(void*))
         : fAlloc(chunkBytes), fCount(0), fReserved(0), kFirstReserveCount(firstReserveCount) {}
 
     ~SkRecord() {
         Destroyer destroyer;
         for (unsigned i = 0; i < this->count(); i++) {
-            this->mutate(i, destroyer);
+            this->mutate<void>(i, destroyer);
         }
     }
 
     // Returns the number of canvas commands in this SkRecord.
     unsigned count() const { return fCount; }
 
     // Visit the i-th canvas command with a functor matching this interface:
     //   template <typename T>
-    //   void operator()(const T& record) { ... }
+    //   R operator()(const T& record) { ... }
     // This operator() must be defined for at least all SkRecords::*.
-    template <typename F>
-    void visit(unsigned i, F& f) const {
+    template <typename R, typename F>
+    R visit(unsigned i, F& f) const {
         SkASSERT(i < this->count());
-        fRecords[i].visit(fTypes[i], f);
+        return fRecords[i].visit<R>(fTypes[i], f);
     }
 
     // Mutate the i-th canvas command with a functor matching this interface:
     //   template <typename T>
-    //   void operator()(T* record) { ... }
+    //   R operator()(T* record) { ... }
     // This operator() must be defined for at least all SkRecords::*.
-    template <typename F>
-    void mutate(unsigned i, F& f) {
+    template <typename R, typename F>
+    R mutate(unsigned i, F& f) {
         SkASSERT(i < this->count());
-        fRecords[i].mutate(fTypes[i], f);
+        return fRecords[i].mutate<R>(fTypes[i], f);
     }
+    // TODO: It'd be nice to infer R from F for visit and mutate if we ever get std::result_of.
 
     // Allocate contiguous space for count Ts, to be freed when the SkRecord is destroyed.
     // Here T can be any class, not just those from SkRecords.  Throws on failure.
     template <typename T>
     T* alloc(unsigned count = 1) {
         return (T*)fAlloc.allocThrow(sizeof(T) * count);
     }
 
     // Add a new command of type T to the end of this SkRecord.
     // You are expected to placement new an object of type T onto this pointer.
@@ skipping 10 matching lines @@
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // References to the original command are invalidated.
     template <typename T>
     T* replace(unsigned i) {
         SkASSERT(i < this->count());
 
         Destroyer destroyer;
-        this->mutate(i, destroyer);
+        this->mutate<void>(i, destroyer);
 
         fTypes[i] = T::kType;
         return fRecords[i].set(this->allocCommand<T>());
     }
 
     // Replace the i-th command with a new command of type T.
     // You are expected to placement new an object of type T onto this pointer.
     // You must show proof that you've already adopted the existing command.
     template <typename T, typename Existing>
     T* replace(unsigned i, const SkRecords::Adopted<Existing>& proofOfAdoption) {
@@ skipping 81 matching lines @@
             fPtr = ptr;
             return ptr;
         }
 
         // Get the data in fAlloc, assuming it's of type T.
         template <typename T>
         T* ptr() const { return (T*)fPtr; }
 
         // Visit this record with functor F (see public API above) assuming the record we're
         // pointing to has this type.
-        template <typename F>
-        void visit(Type8 type, F& f) const {
+        template <typename R, typename F>
+        R visit(Type8 type, F& f) const {
         #define CASE(T) case SkRecords::T##_Type: return f(*this->ptr<SkRecords::T>());
             switch(type) { SK_RECORD_TYPES(CASE) }
         #undef CASE
+            SkDEBUGFAIL("Unreachable");
+            return R();
         }
 
         // Mutate this record with functor F (see public API above) assuming the record we're
         // pointing to has this type.
-        template <typename F>
-        void mutate(Type8 type, F& f) {
+        template <typename R, typename F>
+        R mutate(Type8 type, F& f) {
         #define CASE(T) case SkRecords::T##_Type: return f(this->ptr<SkRecords::T>());
             switch(type) { SK_RECORD_TYPES(CASE) }
         #undef CASE
+            SkDEBUGFAIL("Unreachable");
+            return R();
         }
 
     private:
         void* fPtr;
     };
 
     // fAlloc needs to be a data structure which can append variable length data in contiguous
     // chunks, returning a stable handle to that data for later retrieval.
     //
     // fRecords and fTypes need to be data structures that can append fixed length data, and need to
     // support efficient forward iteration.  (They don't need to be contiguous or indexable.)
 
     SkChunkAlloc fAlloc;
     SkAutoTMalloc<Record> fRecords;
     SkAutoTMalloc<Type8> fTypes;
     // fCount and fReserved measure both fRecords and fTypes, which always grow in lock step.
     unsigned fCount;
     unsigned fReserved;
     const unsigned kFirstReserveCount;
 };
 
 #endif//SkRecord_DEFINED