Implement a persistent uniqueID-based cache for SkImageFilter.

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
 
@@ skipping 43 matching lines @@
         // By default, we cache only image filters with 2 or more children.
         // Values less than 2 mean always cache; values greater than 2 are not supported.
         static Cache* Create(int minChildren = 2);
         virtual ~Cache() {}
         virtual bool get(const SkImageFilter* key, SkBitmap* result, SkIPoint* offset) = 0;
         virtual void set(const SkImageFilter* key,
                          const SkBitmap& result, const SkIPoint& offset) = 0;
         virtual void remove(const SkImageFilter* key) = 0;
     };
 
+    // This cache maps from (filter's unique ID + CTM + clipBounds + src bitmap generation ID) to
+    // (result, offset).
+    class UniqueIDCache : public SkRefCnt {
+    public:
+        struct Key;
+        virtual ~UniqueIDCache() {}
+        static UniqueIDCache* Create(size_t maxBytes);
+        static UniqueIDCache* Get();
+        virtual bool get(const Key& key, SkBitmap* result, SkIPoint* offset) const = 0;
+        virtual void set(const Key& key, const SkBitmap& result, const SkIPoint& offset) = 0;
+    };
+
     class Context {
     public:
-        Context(const SkMatrix& ctm, const SkIRect& clipBounds, Cache* cache) :
+        Context(const SkMatrix& ctm, const SkIRect& clipBounds, UniqueIDCache* cache) :
             fCTM(ctm), fClipBounds(clipBounds), fCache(cache) {
         }
         const SkMatrix& ctm() const { return fCTM; }
         const SkIRect& clipBounds() const { return fClipBounds; }
-        Cache* cache() const { return fCache; }
+        UniqueIDCache* cache() const { return fCache; }
     private:
         SkMatrix fCTM;
         SkIRect  fClipBounds;
-        Cache*   fCache;
+        UniqueIDCache* fCache;
     };
 
     class Proxy {
     public:
         virtual ~Proxy() {};
 
         virtual SkBaseDevice* createDevice(int width, int height) = 0;
         // returns true if the proxy can handle this filter natively
         virtual bool canHandleImageFilter(const SkImageFilter*) = 0;
         // returns true if the proxy handled the filter itself. if this returns
@@ skipping 117 matching lines @@
     class Common {
     public:
         Common() {}
         ~Common();
 
         bool unflatten(SkReadBuffer&, int expectedInputs = -1);
 
         CropRect        cropRect() const { return fCropRect; }
         int             inputCount() const { return fInputs.count(); }
         SkImageFilter** inputs() const { return fInputs.get(); }
+        uint32_t        uniqueID() const { return fUniqueID; }
 
         // If the caller wants a copy of the inputs, call this and it will transfer ownership
         // of the unflattened input filters to the caller. This is just a short-cut for copying
         // the inputs, calling ref() on each, and then waiting for Common's destructor to call
         // unref() on each.
         void detachInputs(SkImageFilter** inputs);
 
     private:
         CropRect fCropRect;
         // most filters accept at most 2 input-filters
         SkAutoSTArray<2, SkImageFilter*> fInputs;
+        uint32_t fUniqueID;
 
         void allocInputs(int count);
     };
 
     SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect = NULL);
 
     virtual ~SkImageFilter();
 
     /**
      *  Constructs a new SkImageFilter read from an SkReadBuffer object.
@@ skipping 67 matching lines @@
      *  parameters before they are used in the effect. Note that this function
      *  will be called with (NULL, NULL, SkMatrix::I()) to query for support,
      *  so returning "true" indicates support for all possible matrices.
      */
     virtual bool asNewEffect(GrEffect** effect,
                              GrTexture*,
                              const SkMatrix& matrix,
                              const SkIRect& bounds) const;
 
 private:
+    bool usesSrcInput() const { return fUsesSrcInput; }
+
     typedef SkFlattenable INHERITED;
     int fInputCount;
     SkImageFilter** fInputs;
+    bool fUsesSrcInput;
     CropRect fCropRect;
+    uint32_t fUniqueID; // Globally unique
 };
 
 #endif