Add a simpler key type for scratch resource keys.

src/gpu/GrTexture.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGpu.h"
+#include "GrResourceKey.h"
 #include "GrTexture.h"
 #include "GrTexturePriv.h"
 
 void GrTexture::dirtyMipMaps(bool mipMapsDirty) {
     if (mipMapsDirty) {
         if (kValid_MipMapsStatus == fMipMapsStatus) {
            fMipMapsStatus = kAllocated_MipMapsStatus;
         }
     } else {
         const bool sizeChanged = kNotAllocated_MipMapsStatus == fMipMapsStatus;
@@ skipping 93 matching lines @@
     }
 }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 GrTexture::GrTexture(GrGpu* gpu, bool isWrapped, const GrSurfaceDesc& desc)
     : INHERITED(gpu, isWrapped, desc)
     , fMipMapsStatus(kNotAllocated_MipMapsStatus) {
 
     if (!isWrapped) {
-        this->setScratchKey(GrTexturePriv::ComputeScratchKey(desc));
+        GrScratchKey key;
+        GrTexturePriv::ComputeScratchKey(desc, &key);
+        this->setScratchKey(key);
     }
     // only make sense if alloc size is pow2
     fShiftFixedX = 31 - SkCLZ(fDesc.fWidth);
     fShiftFixedY = 31 - SkCLZ(fDesc.fHeight);
 }
 
 GrResourceKey GrTexturePriv::ComputeKey(const GrGpu* gpu,
                                     const GrTextureParams* params,
                                     const GrSurfaceDesc& desc,
                                     const GrCacheID& cacheID) {
     GrResourceKey::ResourceFlags flags = get_texture_flags(gpu, params, desc);
-    return GrResourceKey(cacheID, ResourceType(), flags);
+    return GrResourceKey(cacheID, flags);
 }
 
-GrResourceKey GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc) {
-    GrCacheID::Key idKey;
-    // Instead of a client-provided key of the texture contents we create a key from the
-    // descriptor.
-    GR_STATIC_ASSERT(sizeof(idKey) >= 16);
-    SkASSERT(desc.fHeight < (1 << 16));
-    SkASSERT(desc.fWidth < (1 << 16));
-    idKey.fData32[0] = (desc.fWidth) | (desc.fHeight << 16);
-    idKey.fData32[1] = desc.fConfig | desc.fSampleCnt << 16;
-    idKey.fData32[2] = desc.fFlags;
-    idKey.fData32[3] = resolve_origin(desc);    // Only needs 2 bits actually
-    static const int kPadSize = sizeof(idKey) - 16;
-    GR_STATIC_ASSERT(kPadSize >= 0);
-    memset(idKey.fData8 + 16, 0, kPadSize);
+void GrTexturePriv::ComputeScratchKey(const GrSurfaceDesc& desc, GrScratchKey* key) {
+    static const GrScratchKey::ResourceType kType = GrScratchKey::GenerateResourceType();
 
-    GrCacheID cacheID(GrResourceKey::ScratchDomain(), idKey);
-    return GrResourceKey(cacheID, ResourceType(), 0);
+    GrScratchKey::Builder builder(key, kType, 2);
+
+    GrSurfaceOrigin origin = resolve_origin(desc);
+    uint32_t flags = desc.fFlags & ~kCheckAllocation_GrSurfaceFlag;
+
+    SkASSERT(desc.fWidth <= SK_MaxU16);
+    SkASSERT(desc.fHeight <= SK_MaxU16);
+    SkASSERT(static_cast<int>(desc.fConfig) < (1 << 6));
+    SkASSERT(desc.fSampleCnt < (1 << 8));
+    SkASSERT(flags < (1 << 10));
+    SkASSERT(static_cast<int>(origin) < (1 << 8));
+
+    builder[0] = desc.fWidth | (desc.fHeight << 16);
+    builder[1] = desc.fConfig | (desc.fSampleCnt << 6) | (flags << 14) | (origin << 24);
 }
 
 bool GrTexturePriv::NeedsResizing(const GrResourceKey& key) {
     return SkToBool(key.getResourceFlags() & kStretchToPOT_TextureFlag);
 }
 
 bool GrTexturePriv::NeedsBilerp(const GrResourceKey& key) {
     return SkToBool(key.getResourceFlags() & kBilerp_TextureFlag);
 }