Separate replacement creation from layer discovery

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 80 matching lines @@
         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 SkIPoint& offset, const SkMatrix& ctm) 
+                  const SkIPoint& offset, const SkMatrix& ctm,
+                  const SkPaint* paint)
         : fKey(pictureID, start, stop, offset, ctm)
         , fTexture(NULL)
+        , fPaint(paint)
         , fRect(GrIRect16::MakeEmpty())
         , fPlot(NULL)
         , fLocked(false) {
         SkASSERT(SK_InvalidGenID != pictureID && start >= 0 && stop >= 0);
     }
 
     ~GrCachedLayer() {
         SkSafeUnref(fTexture);
     }
 
     uint32_t pictureID() const { return fKey.pictureID(); }
     int start() const { return fKey.start(); }
     int stop() const { return fKey.stop(); }
     const SkIPoint& offset() const { return fKey.offset(); }
     const SkMatrix& ctm() const { return fKey.ctm(); }
 
     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; }
 
     void setPlot(GrPlot* plot) {
         SkASSERT(NULL == plot || NULL == fPlot);
         fPlot = plot;
     }
     GrPlot* plot() { return fPlot; }
 
     bool isAtlased() const { return SkToBool(fPlot); }
 
     void setLocked(bool locked) { fLocked = locked; }
     bool locked() const { return fLocked; }
 
     SkDEBUGCODE(const GrPlot* plot() const { return fPlot; })
     SkDEBUGCODE(void validate(const GrTexture* backingTexture) const;)
 
 private:
     const Key       fKey;
 
+    // The paint used when dropping the layer down into the owning canvas.
+    // Can be NULL.
+    const SkPaint*  fPaint;

[bsalomon, 2014/09/17 13:37:37]

Is this just a ptr so that it can be NULL or to save a copy? I'm just concerned
about lifetime issues. Same for GrReplacements::ReplacementInfo.

Another pattern is using SkTLazy<SkPaint> which has an isValid().

[robertphillips, 2014/09/17 13:43:24]

I have a TODO to clean this up (I'm leaning towards just making a copy). Why
don't I do that in the next CL?

[bsalomon, 2014/09/17 13:43:49]

Acknowledged.

+
     // fTexture is a ref on the atlasing texture for atlased layers and a
     // ref on a GrTexture for non-atlased textures.
     GrTexture*      fTexture;
 
     // For both atlased and non-atlased layers 'fRect' contains the  bound of
     // the layer in whichever texture it resides. It is empty when 'fTexture'
     // is NULL.
     GrIRect16       fRect;
 
     // For atlased layers, fPlot stores the atlas plot in which the layer rests.
@@ skipping 23 matching lines @@
 
     // 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, int stop, 
                              const SkIPoint& offset, const SkMatrix& ctm);
     GrCachedLayer* findLayerOrCreate(uint32_t pictureID,
                                      int start, int stop, 
                                      const SkIPoint& offset,
-                                     const SkMatrix& ctm);
+                                     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);
 
     // Inform the cache that layer's cached image is not currently required
     void unlock(GrCachedLayer* layer);
 
     // Setup to be notified when 'picture' is deleted
@@ skipping 33 matching lines @@
     // This implements a plot-centric locking mechanism (since the atlas
     // backing texture is always locked). Each layer that is locked (i.e.,
     // needed for the current rendering) in a plot increments the plot lock
     // 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];
 
     void initAtlas();
     GrCachedLayer* createLayer(uint32_t pictureID, int start, int stop, 
-                               const SkIPoint& offset, const SkMatrix& ctm);
+                               const SkIPoint& offset, 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();
 
     // for testing
     friend class TestingAccess;
     int numLayers() const { return fLayerHash.count(); }
 };
 
 #endif