Adding bulk plot reffer to cached textblobs

src/gpu/GrBatchAtlas.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBatchAtlas_DEFINED
 #define GrBatchAtlas_DEFINED
 
 #include "GrTexture.h"
 #include "SkPoint.h"
 #include "SkTDArray.h"
 #include "SkTInternalLList.h"
 
 class BatchPlot;
 class GrBatchTarget;
 class GrRectanizer;
 
 typedef SkTInternalLList<BatchPlot> GrBatchPlotList;
 
 class GrBatchAtlas {
 public:
     typedef uint64_t BatchToken;
     // An AtlasID is an opaque handle which callers can use to determine if the atlas contains

[bsalomon, 2015/04/01 20:21:31]

I think this comment should be updated to indicate that the atlas generates the
ID. Also, is it more of an "EntryHandle". AtlasID looks like it identifies an
atlas but really it identifies something in the atlas.

     // a specific piece of data
     typedef uint32_t AtlasID;
     static const uint32_t kInvalidAtlasID = 0;
     static const uint64_t kInvalidAtlasGeneration = 0;
 
     // A function pointer for use as a callback during eviction.  Whenever GrBatchAtlas evicts a
     // specific AtlasID, it will call all of the registered listeners so they can optionally process
     // the eviction
     typedef void (*EvictionFunc)(GrBatchAtlas::AtlasID, void*);
 
@@ skipping 11 matching lines @@
 
     uint64_t atlasGeneration() const { return fAtlasGeneration; }
     bool hasID(AtlasID id);
     void setLastRefToken(AtlasID id, BatchToken batchToken);
     void registerEvictionCallback(EvictionFunc func, void* userData) {
         EvictionData* data = fEvictionCallbacks.append();
         data->fFunc = func;
         data->fData = userData;
     }
 
+    /*
+     * A class which can be handed back to GrBatchAtlas for updating in bulk last ref tokens.
+     * NOTE: This class assumes you want to set the same BatchToken for each plot.
+     */
+    class BulkTokenReffer {

[bsalomon, 2015/04/01 20:21:31]

I find the use of "Ref" confusing in this class. It doesn't mean what it means
everywhere else in Skia. Same for setLastRefToken above.

+    public:
+        BulkTokenReffer() : fPlotAlreadyUpdated(0), fBatchToken(0) {}
+        void setRefToken(GrBatchAtlas* atlas, AtlasID id, BatchToken token) {

[bsalomon, 2015/04/01 20:21:31]

Does this mean it sets here and when setLastRefTokenBulk is called? Do you need
both? It seems a bit asymmetric that in here a separate token could be used per
plot but then when calling setLastRefTokenBulk no token is provided. I guess it
uses the last one passed here? Does that mean it can never be reused with a
later token unless you add another plot through this function?

+            int index = GrBatchAtlas::GetIndexFromID(id);
+            if (!this->find(index)) {
+                this->set(index);
+                atlas->setLastRefTokenInternal(index, token);
+                fBatchToken = token;
+            }
+        }
+
+        void reset() {
+            fPlotsToUpdate.reset();
+            fPlotAlreadyUpdated = 0;
+        }
+
+    private:
+        bool find(int index) const {
+            return (fPlotAlreadyUpdated >> index) & 1;
+        }
+        void set(int index) {
+            SkASSERT(!this->find(index));
+            fPlotAlreadyUpdated = fPlotAlreadyUpdated | (1 << index);
+            fPlotsToUpdate.push_back(index);
+        }
+
+        static const int kMaxPlots = 32;
+        uint32_t fPlotAlreadyUpdated;
+        BatchToken fBatchToken;
+        SkSTArray<4, int, true> fPlotsToUpdate;
+
+        friend class GrBatchAtlas;
+    };
+
+    void setLastRefTokenBulk(const BulkTokenReffer& reffer);
+
 private:
-    int getIndexFromID(AtlasID id) {
+    static int GetIndexFromID(AtlasID id) {
         return id & 0xffff;
     }
 
-    int getGenerationFromID(AtlasID id) {
+    static int GetGenerationFromID(AtlasID id) {
         return (id >> 16) & 0xffff;
     }
 
     inline void updatePlot(GrBatchTarget*, AtlasID*, BatchPlot*);
 
     inline void makeMRU(BatchPlot* plot);
 
     inline void processEviction(AtlasID);
 
+    void setLastRefTokenInternal(int index, BatchToken);
+
     GrTexture* fTexture;
     int fNumPlotsX;
     int fNumPlotsY;
     int fPlotWidth;
     int fPlotHeight;
     size_t fBPP;
     uint64_t fAtlasGeneration;
 
     struct EvictionData {
         EvictionFunc fFunc;
         void* fData;
     };
 
     SkTDArray<EvictionData> fEvictionCallbacks;
     // allocated array of GrBatchPlots
     SkAutoTUnref<BatchPlot>* fPlotArray;
     // LRU list of GrPlots (MRU at head - LRU at tail)
     GrBatchPlotList fPlotList;
+
+    friend class BulkTokenReffer;
 };
 
 #endif