Add specialized content key class for resources.

include/gpu/GrResourceKey.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 GrResourceKey_DEFINED
 #define GrResourceKey_DEFINED
 
 #include "GrTypes.h"
 #include "SkTemplates.h"
 #include "GrBinHashKey.h"
 
+uint32_t GrResourceKeyHash(const uint32_t* data, size_t size);
+
+class GrResourceKey {

[bsalomon, 2015/01/21 19:54:58]

The diff sucks... this is basically the old GrScratchKey made subclassable for
new subclasses GrScratchKey and GrResourceKey.

+public:
+    uint32_t hash() const {
+        this->validate();
+        return fKey[kHash_MetaDataIdx];
+    }
+
+    size_t size() const {
+        this->validate();
+        return this->internalSize();
+    }
+
+    const uint32_t* data() const {
+        this->validate();
+        return &fKey[kMetaDataCnt];
+    }
+
+protected:
+    static const uint32_t kInvalidDomain = 0;
+
+    GrResourceKey() { this->reset(); }
+
+    /** Reset to an invalid key. */
+    void reset() {
+        GR_STATIC_ASSERT((uint16_t)kInvalidDomain == kInvalidDomain);
+        fKey.reset(kMetaDataCnt);
+        fKey[kHash_MetaDataIdx] = 0;
+        fKey[kDomainAndSize_MetaDataIdx] = kInvalidDomain;
+    }
+
+    bool operator==(const GrResourceKey& that) const {
+        return 0 == memcmp(fKey.get(), that.fKey.get(), this->size());
+    }
+
+    GrResourceKey& operator=(const GrResourceKey& that) {
+        size_t bytes = that.size();
+        fKey.reset(SkToInt(bytes / sizeof(uint32_t)));
+        memcpy(fKey.get(), that.fKey.get(), bytes);
+        return *this;
+    }
+
+    bool isValid() const { return kInvalidDomain != this->domain(); }
+
+    uint32_t domain() const { return fKey[kDomainAndSize_MetaDataIdx] & 0xffff; }
+
+    /** Used to initialize a key. */
+    class Builder {
+    public:
+        Builder(GrResourceKey* key, uint32_t domain, int data32Count) : fKey(key) {
+            SkASSERT(data32Count >= 0);
+            SkASSERT(domain != kInvalidDomain);
+            key->fKey.reset(kMetaDataCnt + data32Count);
+            int size = (data32Count + kMetaDataCnt) * sizeof(uint32_t);
+            SkASSERT(SkToU16(size) == size);
+            SkASSERT(SkToU16(domain) == domain);
+            key->fKey[kDomainAndSize_MetaDataIdx] = domain | (size << 16);
+        }
+
+        ~Builder() { this->finish(); }
+
+        void finish() {
+            if (NULL == fKey) {
+                return;
+            }
+            GR_STATIC_ASSERT(0 == kHash_MetaDataIdx);
+            uint32_t* hash = &fKey->fKey[kHash_MetaDataIdx];
+            *hash = GrResourceKeyHash(hash + 1, fKey->internalSize() - sizeof(uint32_t));
+            fKey->validate();
+            fKey = NULL;
+        }
+
+        uint32_t& operator[](int dataIdx) {
+            SkASSERT(fKey);
+            SkDEBUGCODE(size_t dataCount = fKey->internalSize() / sizeof(uint32_t) - kMetaDataCnt;)
+            SkASSERT(SkToU32(dataIdx) < dataCount);
+            return fKey->fKey[kMetaDataCnt + dataIdx];
+        }
+
+    private:
+        GrResourceKey* fKey;
+    };
+
+private:
+    size_t internalSize() const {
+        return fKey[kDomainAndSize_MetaDataIdx] >> 16;
+    }
+
+    void validate() const {
+        SkASSERT(fKey[kHash_MetaDataIdx] ==
+                 GrResourceKeyHash(&fKey[kHash_MetaDataIdx] + 1,
+                                   this->internalSize() - sizeof(uint32_t)));
+    }
+
+    enum MetaDataIdx {
+        kHash_MetaDataIdx,
+        // The key domain and size are packed into a single uint32_t.
+        kDomainAndSize_MetaDataIdx,
+
+        kLastMetaDataIdx = kDomainAndSize_MetaDataIdx
+    };
+    static const uint32_t kMetaDataCnt = kLastMetaDataIdx + 1;
+
+    friend class TestResource; // For unit test to access kMetaDataCnt.
+
+    // bmp textures require 4 uint32_t values.
+    SkAutoSTArray<kMetaDataCnt + 4, uint32_t> fKey;
+};
+
 /**
  * A key used for scratch resources. The key consists of a resource type (subclass) identifier, a
  * hash, a data length, and type-specific data. A Builder object is used to initialize the
  * key contents. The contents must be initialized before the key can be used.
  */
-class GrScratchKey {
+class GrScratchKey : public GrResourceKey {
+private:
+    typedef GrResourceKey INHERITED;
+
 public:
+    static const uint32_t kInvalidResourceType = INHERITED::kInvalidDomain;
+
     /** Uniquely identifies the type of resource that is cached as scratch. */
     typedef uint32_t ResourceType;
     /** Generate a unique ResourceType. */
     static ResourceType GenerateResourceType();
 
-    GrScratchKey() { this->reset(); }
+    /** Creates an invalid scratch key. It must be initialized using a Builder object before use. */
+    GrScratchKey() {}
+
     GrScratchKey(const GrScratchKey& that) { *this = that; }
 
-    /** Reset to an invalid key. */
-    void reset() {
-        fKey.reset(kMetaDataCnt);
-        fKey[kHash_MetaDataIdx] = 0;
-        fKey[kTypeAndSize_MetaDataIdx] = kInvalidResourceType;
-    }
+    /** reset() returns the key to the invalid state. */
+    using INHERITED::reset;
 
     bool isValid() const { return kInvalidResourceType != this->resourceType(); }
 
-    ResourceType resourceType() const { return fKey[kTypeAndSize_MetaDataIdx] & 0xffff; }
-
-    uint32_t hash() const { return fKey[kHash_MetaDataIdx]; }
-
-    size_t size() const { return SkToInt(fKey[kTypeAndSize_MetaDataIdx] >> 16); }
-
-    const uint32_t* data() const { return &fKey[kMetaDataCnt]; }
+    ResourceType resourceType() const { return this->domain(); }
 
     GrScratchKey& operator=(const GrScratchKey& that) {
-        size_t bytes = that.size();
-        fKey.reset(SkToInt(bytes / sizeof(uint32_t)));
-        memcpy(fKey.get(), that.fKey.get(), bytes);
+        this->INHERITED::operator=(that);
         return *this;
     }
 
     bool operator==(const GrScratchKey& that) const {
-        return 0 == memcmp(fKey.get(), that.fKey.get(), this->size());
+        return this->INHERITED::operator==(that);
     }
     bool operator!=(const GrScratchKey& that) const { return !(*this == that); }
 
-    /** Used to initialize scratch key. */
-    class Builder {
+    class Builder : public INHERITED::Builder {
     public:
-        Builder(GrScratchKey* key, ResourceType type, int data32Count) : fKey(key) {
-            SkASSERT(data32Count >= 0);
-            SkASSERT(type != kInvalidResourceType);
-            key->fKey.reset(kMetaDataCnt + data32Count);
-            SkASSERT(type <= SK_MaxU16);
-            int size = (data32Count + kMetaDataCnt) * sizeof(uint32_t);
-            SkASSERT(size <= SK_MaxU16);
-            key->fKey[kTypeAndSize_MetaDataIdx] = type | (size << 16);
-        }
-
-        ~Builder() { this->finish(); }
-
-        void finish();
-
-        uint32_t& operator[](int dataIdx) {
-            SkASSERT(fKey);
-            SkDEBUGCODE(size_t dataCount = fKey->size() / sizeof(uint32_t) - kMetaDataCnt;)
-            SkASSERT(SkToU32(dataIdx) < dataCount);
-            return fKey->fKey[kMetaDataCnt + dataIdx];
-        }
-
+        Builder(GrScratchKey* key, ResourceType type, int data32Count)
+            : INHERITED(key, type, data32Count) {}
     private:
-        GrScratchKey* fKey;
-    };
-
+        typedef INHERITED::Builder INHERITED;
+    };
+};
+
+/**
+ * A key used for scratch resources. The key consists of a resource type (subclass) identifier, a
+ * hash, a data length, and type-specific data. A Builder object is used to initialize the
+ * key contents. The contents must be initialized before the key can be used.
+ */
+class GrContentKey : public GrResourceKey {
 private:
-    enum MetaDataIdx {
-        kHash_MetaDataIdx,
-        // The resource type and size are packed into a single uint32_t.
-        kTypeAndSize_MetaDataIdx,
-
-        kLastMetaDataIdx = kTypeAndSize_MetaDataIdx
-    };
-    static const uint32_t kInvalidResourceType = 0;
-    static const uint32_t kMetaDataCnt = kLastMetaDataIdx + 1;
-
-    friend class TestResource; // For unit test to access kMetaDataCnt.
-
-    // Stencil and textures each require 2 uint32_t values.
-    SkAutoSTArray<kMetaDataCnt + 2, uint32_t> fKey;
+    typedef GrResourceKey INHERITED;
+
+public:
+    static const uint32_t kInvalidDomain = INHERITED::kInvalidDomain;
+
+    typedef uint32_t Domain;
+    /** Generate a unique Domain of content keys. */
+    static Domain GenerateDomain();
+
+    /** Creates an invalid content key. It must be initialized using a Builder object before use. */
+    GrContentKey() {}
+
+    GrContentKey(const GrContentKey& that) { *this = that; }
+
+    /** reset() returns the key to the invalid state. */
+    using INHERITED::reset;
+
+    bool isValid() const { return kInvalidDomain != this->domain(); }
+
+    GrContentKey& operator=(const GrContentKey& that) {
+        this->INHERITED::operator=(that);
+        return *this;
+    }
+
+    bool operator==(const GrContentKey& that) const {
+        return this->INHERITED::operator==(that);
+    }
+    bool operator!=(const GrContentKey& that) const { return !(*this == that); }
+
+    class Builder : public INHERITED::Builder {
+    public:
+        Builder(GrContentKey* key, Domain domain, int data32Count)
+            : INHERITED(key, domain, data32Count) {}
+
+        /** Used to build a key that wraps another key and adds additional data. */
+        Builder(GrContentKey* key, const GrContentKey& innerKey, Domain domain,
+                int extraData32Cnt)
+            : INHERITED(key, domain, (SkToInt(innerKey.size()) >> 2) + extraData32Cnt) {
+            int innerKeyCnt = SkToInt(innerKey.size()) >> 2;
+            for (int i = 0; i < innerKeyCnt; ++i) {
+                // add the inner key to the end of the key so that op[] can be indexed normally.
+                this->operator[](extraData32Cnt + i) = innerKey.data()[i];
+            }
+        }
+    private:
+        typedef INHERITED::Builder INHERITED;
+    };
 };
 
-class GrResourceKey {
-public:
-    /** Flags set by the GrGpuResource subclass. */
-    typedef uint8_t ResourceFlags;
-
-    /** Creates a key for resource */
-    GrResourceKey(const GrCacheID& id, ResourceFlags flags) {
-        this->init(id.getDomain(), id.getKey(), flags);
-    };
-
-    GrResourceKey(const GrResourceKey& src) { fKey = src.fKey; }
-
-    GrResourceKey() { fKey.reset(); }
-
-    void reset(const GrCacheID& id, ResourceFlags flags) {
-        this->init(id.getDomain(), id.getKey(), flags);
-    }
-
-    uint32_t getHash() const { return fKey.getHash(); }
-
-    ResourceFlags getResourceFlags() const {
-        return *reinterpret_cast<const ResourceFlags*>(fKey.getData() +
-                                                       kResourceFlagsOffset);
-    }
-
-    bool operator==(const GrResourceKey& other) const { return fKey == other.fKey; }
-
-    // A key indicating that the resource is not usable as a scratch resource.
-    static GrResourceKey& NullScratchKey();
-
-private:
-    enum {
-        kCacheIDKeyOffset = 0,
-        kCacheIDDomainOffset = kCacheIDKeyOffset + sizeof(GrCacheID::Key),
-        kResourceFlagsOffset = kCacheIDDomainOffset + sizeof(GrCacheID::Domain),
-        kPadOffset = kResourceFlagsOffset + sizeof(ResourceFlags),
-        kKeySize = SkAlign4(kPadOffset),
-        kPadSize = kKeySize - kPadOffset
-    };
-
-    void init(const GrCacheID::Domain domain, const GrCacheID::Key& key, ResourceFlags flags) {
-        union {
-            uint8_t  fKey8[kKeySize];
-            uint32_t fKey32[kKeySize / 4];
-        } keyData;
-
-        uint8_t* k = keyData.fKey8;
-        memcpy(k + kCacheIDKeyOffset, key.fData8, sizeof(GrCacheID::Key));
-        memcpy(k + kCacheIDDomainOffset, &domain, sizeof(GrCacheID::Domain));
-        memcpy(k + kResourceFlagsOffset, &flags, sizeof(ResourceFlags));
-        memset(k + kPadOffset, 0, kPadSize);
-        fKey.setKeyData(keyData.fKey32);
-    }
-    GrBinHashKey<kKeySize> fKey;
-};
-
 #endif