Image filters: de-nest SkImageFilter::Cache and Cache::Key.

include/core/SkImageFilter.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageFilter_DEFINED
 #define SkImageFilter_DEFINED
 
 #include "../private/SkTArray.h"
 #include "../private/SkTemplates.h"
 #include "../private/SkMutex.h"
 #include "SkFilterQuality.h"
 #include "SkFlattenable.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 
 class GrContext;
 class GrFragmentProcessor;
 class SkColorFilter;
 struct SkIPoint;
 class SkSpecialImage;
+class SkImageFilterCache;
+struct SkImageFilterCacheKey;
 
 /**
  *  Base class for image filters. If one is installed in the paint, then
  *  all drawing occurs as usual, but it is as if the drawing happened into an
  *  offscreen (before the xfermode is applied). This offscreen bitmap will
  *  then be handed to the imagefilter, who in turn creates a new bitmap which
  *  is what will finally be drawn to the device (using the original xfermode).
  */
 class SK_API SkImageFilter : public SkFlattenable {
 public:
-    // This cache maps from (filter's unique ID + CTM + clipBounds + src bitmap generation ID) to
-    // (result, offset).
-    class Cache : public SkRefCnt {
-    public:
-        struct Key;
-        virtual ~Cache() {}
-        static Cache* Create(size_t maxBytes);
-        static Cache* Get();
-        virtual SkSpecialImage* get(const Key& key, SkIPoint* offset) const = 0;
-        virtual void set(const Key& key, SkSpecialImage* image, const SkIPoint& offset) = 0;
-        virtual void purge() = 0;
-        virtual void purgeByKeys(const Key[], int) = 0;
-        SkDEBUGCODE(virtual int count() const = 0;)
-    };
-
     class Context {
     public:
-        Context(const SkMatrix& ctm, const SkIRect& clipBounds, Cache* cache)
+        Context(const SkMatrix& ctm, const SkIRect& clipBounds, SkImageFilterCache* cache)
             : fCTM(ctm)
             , fClipBounds(clipBounds)
             , fCache(cache)
         {}
 
         const SkMatrix& ctm() const { return fCTM; }
         const SkIRect& clipBounds() const { return fClipBounds; }
-        Cache* cache() const { return fCache; }
+        SkImageFilterCache* cache() const { return fCache; }
 
     private:
-        SkMatrix        fCTM;
-        SkIRect         fClipBounds;
-        Cache*          fCache;
+        SkMatrix               fCTM;
+        SkIRect                fClipBounds;
+        SkImageFilterCache*    fCache;
     };
 
     class CropRect {
     public:
         enum CropEdge {
             kHasLeft_CropEdge   = 0x01,
             kHasTop_CropEdge    = 0x02,
             kHasWidth_CropEdge  = 0x04,
             kHasHeight_CropEdge = 0x08,
             kHasAll_CropEdge    = 0x0F,
@@ skipping 317 matching lines @@
     void init(sk_sp<SkImageFilter>* inputs, int inputCount, const CropRect* cropRect);
 
     bool usesSrcInput() const { return fUsesSrcInput; }
     virtual bool affectsTransparentBlack() const { return false; }
 
     SkAutoSTArray<2, sk_sp<SkImageFilter>> fInputs;
 
     bool fUsesSrcInput;
     CropRect fCropRect;
     uint32_t fUniqueID; // Globally unique
-    mutable SkTArray<Cache::Key> fCacheKeys;
+    mutable SkTArray<SkImageFilterCacheKey> fCacheKeys;
     mutable SkMutex fMutex;
     typedef SkFlattenable INHERITED;
 };
 
 /**
  *  Helper to unflatten the common data, and return NULL if we fail.
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif