Add clip to layer cache

src/gpu/GrLayerCache.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 GrLayerCache_DEFINED
 #define GrLayerCache_DEFINED
 
@@ skipping 33 matching lines @@
 // get a ref to the GrTexture in which they reside. In both cases 'fRect' 
 // contains the layer's extent in its texture.
 // Atlased layers also get a pointer to the plot in which they reside.
 // For non-atlased layers, the lock field just corresponds to locking in
 // the resource cache. For atlased layers, it implements an additional level
 // of locking to allow atlased layers to be reused multiple times.
 struct GrCachedLayer {
 public:
     // For SkTDynamicHash
     struct Key {
-        // TODO: the key needs to include the clip
-        Key(uint32_t pictureID, int start, const SkMatrix& ctm) 
+        Key(uint32_t pictureID, int start, const SkIRect& bounds, const SkMatrix& ctm)
         : fPictureID(pictureID)
-        , fStart(start) {
-            fCTM[0] = ctm.getScaleX();
-            fCTM[1] = ctm.getSkewX();
-            fCTM[2] = ctm.getSkewY();
-            fCTM[3] = ctm.getScaleY();
+        , fStart(start)
+        , fBounds(bounds)
+        , fCTM(ctm) {
+            fCTM.getType(); // force initialization of type so hashes match
+
             // Key needs to be tightly packed.
             GR_STATIC_ASSERT(sizeof(Key) == sizeof(uint32_t) +      // picture ID
                                             sizeof(int) +           // start index
-                                            4 * sizeof(SkScalar));  // 2x2 from CTM
+                                            4 * sizeof(uint32_t) +  // bounds
+                                            9 * sizeof(SkScalar) + sizeof(uint32_t)); // matrix
         }
 
         bool operator==(const Key& other) const {
             return fPictureID == other.fPictureID &&
                    fStart == other.fStart &&
-                   0 == memcmp(fCTM, other.fCTM, sizeof(fCTM));
+                   fBounds == other.fBounds &&
+                   fCTM.cheapEqualTo(other.fCTM);
         }
 
         uint32_t pictureID() const { return fPictureID; }
         int start() const { return fStart; }
+        const SkIRect& bound() const { return fBounds; }
+        const SkMatrix& ctm() const { return fCTM; }
 
     private:
         // ID of the picture of which this layer is a part
         const uint32_t fPictureID;
         // The the index of the saveLayer command in the picture
         const int      fStart;
+        // The bounds of the layer. The TL corner is its offset.
+        const SkIRect  fBounds;
         // The 2x2 portion of the CTM applied to this layer in the picture
-        SkScalar       fCTM[4];
+        SkMatrix       fCTM;
     };
 
     static const Key& GetKey(const GrCachedLayer& layer) { return layer.fKey; }
     static uint32_t Hash(const Key& key) { 
         return SkChecksum::Murmur3(reinterpret_cast<const uint32_t*>(&key), sizeof(Key));
     }
 
     // GrCachedLayer proper
     GrCachedLayer(uint32_t pictureID, int start, int stop,
-                  const SkMatrix& ctm, const SkPaint* paint)
-        : fKey(pictureID, start, ctm)
+                  const SkIRect& bounds, const SkMatrix& ctm,
+                  const SkPaint* paint)
+        : fKey(pictureID, start, bounds, ctm)
         , fStop(stop)
         , fPaint(paint ? SkNEW_ARGS(SkPaint, (*paint)) : NULL)
         , fTexture(NULL)
         , fRect(GrIRect16::MakeEmpty())
         , fPlot(NULL)
         , fUses(0)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID && start >= 0 && stop >= 0);
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
         SkDELETE(fPaint);
     }
 
     uint32_t pictureID() const { return fKey.pictureID(); }
     int start() const { return fKey.start(); }
+    const SkIRect& bound() const { return fKey.bound(); }
 
     int stop() const { return fStop; }
     void setTexture(GrTexture* texture, const GrIRect16& rect) {
         SkRefCnt_SafeAssign(fTexture, texture);
         fRect = rect;
     }
     GrTexture* texture() { return fTexture; }
     const SkPaint* paint() const { return fPaint; }
     const GrIRect16& rect() const { return fRect; }
 
@@ skipping 64 matching lines @@
 // classes.
 class GrLayerCache {
 public:
     GrLayerCache(GrContext*);
     ~GrLayerCache();
 
     // As a cache, the GrLayerCache can be ordered to free up all its cached
     // elements by the GrContext
     void freeAll();
 
-    GrCachedLayer* findLayer(uint32_t pictureID, int start, const SkMatrix& ctm);
+    GrCachedLayer* findLayer(uint32_t pictureID, int start, 
+                             const SkIRect& bounds, const SkMatrix& ctm);
     GrCachedLayer* findLayerOrCreate(uint32_t pictureID,
                                      int start, int stop, 
+                                     const SkIRect& bounds,
                                      const SkMatrix& ctm,
                                      const SkPaint* paint);
 
     // Inform the cache that layer's cached image is now required. 
     // Return true if the layer must be re-rendered. Return false if the
     // layer was found in the cache and can be reused.
     bool lock(GrCachedLayer* layer, const GrTextureDesc& desc, bool dontAtlas);
 
     // addUse is just here to keep the API symmetric
     void addUse(GrCachedLayer* layer) { layer->addUse(); }
@@ skipping 49 matching lines @@
     // count for that plot. Similarly, once a rendering is complete all the
     // layers used in it decrement the lock count for the used plots.
     // Plots with a 0 lock count are open for recycling/purging.
     int fPlotLocks[kNumPlotsX * kNumPlotsY];
 
     // Inform the cache that layer's cached image is not currently required
     void unlock(GrCachedLayer* layer);
 
     void initAtlas();
     GrCachedLayer* createLayer(uint32_t pictureID, int start, int stop, 
-                               const SkMatrix& ctm, const SkPaint* paint);
+                               const SkIRect& bounds, const SkMatrix& ctm, 
+                               const SkPaint* paint);
 
     void purgeAll();
 
     // Remove all the layers (and unlock any resources) associated with 'pictureID'
     void purge(uint32_t pictureID);
 
     static bool PlausiblyAtlasable(int width, int height) {
         return width <= kPlotWidth && height <= kPlotHeight;
     }
 
     void purgePlot(GrPlot* plot);
 
     // Try to find a purgeable plot and clear it out. Return true if a plot
     // was purged; false otherwise.
     bool purgePlot();
 
     void incPlotLock(int plotIdx) { ++fPlotLocks[plotIdx]; }
     void decPlotLock(int plotIdx) {
         SkASSERT(fPlotLocks[plotIdx] > 0);
         --fPlotLocks[plotIdx];
     }
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif