Update Layer Hoisting to store its atlas texture in the resource cache

src/gpu/GrLayerAtlas.cpp

 
 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+#include "GrGpuResourcePriv.h"
 #include "GrLayerAtlas.h"
 #include "GrRectanizer.h"
 #include "GrTextureProvider.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 GrLayerAtlas::Plot::Plot() 
     : fID(-1)
     , fRects(nullptr) {
     fOffset.set(0, 0);
 }
@@ skipping 17 matching lines @@
     loc->fY += fOffset.fY;
     return true;
 }
 
 void GrLayerAtlas::Plot::reset() {
     SkASSERT(fRects);
     fRects->reset();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+static void get_layer_atlas_key(GrUniqueKey* result) {
+    static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
+    GrUniqueKey::Builder builder(result, kDomain, 0);

[bsalomon, 2015/11/05 15:39:25]

Can't the key itself be a static?

[robertphillips, 2015/11/05 19:14:22]

Done.

+}
+
+bool GrLayerAtlas::reattachBackingTexture() {
+    SkASSERT(!fTexture);
+
+    GrUniqueKey key;
+
+    get_layer_atlas_key(&key);
+
+    fTexture.reset(fTexProvider->findAndRefTextureByUniqueKey(key));
+    return SkToBool(fTexture);
+}
+
+void GrLayerAtlas::createBackingTexture() {
+    SkASSERT(!fTexture);
+
+    GrSurfaceDesc desc;
+    desc.fFlags = fFlags;
+    desc.fWidth = fBackingTextureSize.width();
+    desc.fHeight = fBackingTextureSize.height();
+    desc.fConfig = fPixelConfig;
+
+    fTexture.reset(fTexProvider->createTexture(desc, true, nullptr, 0));
+
+    GrUniqueKey key;
+
+    get_layer_atlas_key(&key);
+
+    fTexture->resourcePriv().setUniqueKey(key);
+}
 
 GrLayerAtlas::GrLayerAtlas(GrTextureProvider* texProvider, GrPixelConfig config, 
                            GrSurfaceFlags flags,
                            const SkISize& backingTextureSize,
                            int numPlotsX, int numPlotsY) {
     fTexProvider = texProvider;
     fPixelConfig = config;
     fFlags = flags;
     fBackingTextureSize = backingTextureSize;
-    fTexture = nullptr;
 
     int textureWidth = fBackingTextureSize.width();
     int textureHeight = fBackingTextureSize.height();
 
     int plotWidth = textureWidth / numPlotsX;
     int plotHeight = textureHeight / numPlotsY;
 
     SkASSERT(plotWidth * numPlotsX == textureWidth);
     SkASSERT(plotHeight * numPlotsY == textureHeight);
 
     // We currently do not support compressed atlases...
     SkASSERT(!GrPixelConfigIsCompressed(config));
 
     // set up allocated plots
     fPlotArray = new Plot[numPlotsX * numPlotsY];
 
     Plot* currPlot = fPlotArray;
     for (int y = numPlotsY-1; y >= 0; --y) {
         for (int x = numPlotsX-1; x >= 0; --x) {
             currPlot->init(y*numPlotsX+x, x, y, plotWidth, plotHeight);
 
             // build LRU list
             fPlotList.addToHead(currPlot);
             ++currPlot;
         }
     }
 }
 
+void GrLayerAtlas::resetPlots() {
+    PlotIter iter;
+    for (Plot* plot = iter.init(fPlotList, PlotIter::kHead_IterStart); plot; plot = iter.next()) {
+        plot->reset();
+    }
+}
+
 GrLayerAtlas::~GrLayerAtlas() {
-    SkSafeUnref(fTexture);
     delete[] fPlotArray;
 }
 
 void GrLayerAtlas::makeMRU(Plot* plot) {
     if (fPlotList.head() == plot) {
         return;
     }
 
     fPlotList.remove(plot);
     fPlotList.addToHead(plot);
 };
 
 GrLayerAtlas::Plot* GrLayerAtlas::addToAtlas(ClientPlotUsage* usage,
                                              int width, int height, SkIPoint16* loc) {
     // Iterate through the plots currently being used by this client and see if we can find a hole.
     // The last one was most recently added and probably most empty.
     // We want to consolidate the uses from individual clients to the same plot(s) so that
     // when a specific client goes away they are more likely to completely empty a plot.
     for (int i = usage->numPlots()-1; i >= 0; --i) {
         Plot* plot = usage->plot(i);
         if (plot->allocateRect(width, height, loc)) {
             this->makeMRU(plot);
             return plot;
         }
     }
 
     // before we get a new plot, make sure we have a backing texture
     if (nullptr == fTexture) {
-        // TODO: Update this to use the cache rather than directly creating a texture.
-        GrSurfaceDesc desc;
-        desc.fFlags = fFlags;
-        desc.fWidth = fBackingTextureSize.width();
-        desc.fHeight = fBackingTextureSize.height();
-        desc.fConfig = fPixelConfig;
-
-        fTexture = fTexProvider->createTexture(desc, true, nullptr, 0);
+        this->createBackingTexture();
         if (nullptr == fTexture) {
             return nullptr;
         }
     }
 
     // Now look through all allocated plots for one we can share, in MRU order
     // TODO: its seems like traversing from emptiest to fullest would make more sense
     PlotList::Iter plotIter;
     plotIter.init(fPlotList, PlotList::Iter::kHead_IterStart);
     Plot* plot;
     while ((plot = plotIter.get())) {
         if (plot->allocateRect(width, height, loc)) {
             this->makeMRU(plot);
             // new plot for atlas, put at end of array
             usage->appendPlot(plot);
             return plot;
         }
         plotIter.next();
     }
 
     // If the above fails, then the current plot list has no room
     return nullptr;
 }