Add specialized content key class for resources.

bench/GrResourceCacheBench.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Benchmark.h"
 
@@ skipping 10 matching lines @@
 };
 
 class BenchResource : public GrGpuResource {
 public:
     SK_DECLARE_INST_COUNT(BenchResource);
     BenchResource (GrGpu* gpu)
         : INHERITED(gpu, kCached_LifeCycle) {
         this->registerWithCache();
     }
 
-    static GrResourceKey ComputeKey(int i) {
-        GrCacheID::Key key;
-        memset(&key, 0, sizeof(key));
-        key.fData32[0] = i;
-        static int gDomain = GrCacheID::GenerateDomain();
-        return GrResourceKey(GrCacheID(gDomain, key), 0);
+    static void ComputeKey(int i, GrContentKey* key) {
+        static GrContentKey::Domain kDomain = GrContentKey::GenerateDomain();
+        GrContentKey::Builder builder(key, kDomain, 1);
+        builder[0] = i;
     }
 
-
 private:
     size_t onGpuMemorySize() const SK_OVERRIDE { return 100; }
 
     typedef GrGpuResource INHERITED;
 };
 
 static void populate_cache(GrGpu* gpu, int resourceCount) {
     for (int i = 0; i < resourceCount; ++i) {
-        GrResourceKey key = BenchResource::ComputeKey(i);
+        GrContentKey key;
+        BenchResource::ComputeKey(i, &key);
         GrGpuResource* resource = SkNEW_ARGS(BenchResource, (gpu));
         resource->cacheAccess().setContentKey(key);
         resource->unref();
     }
 }
 
 class GrResourceCacheBenchAdd : public Benchmark {
 public:
     bool isSuitableFor(Backend backend) SK_OVERRIDE {
         return backend == kNonRendering_Backend;
@@ skipping 61 matching lines @@
     }
 
     void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
         if (!fContext) {
             return;
         }
         GrResourceCache2* cache2 = fContext->getResourceCache2();
         SkASSERT(CACHE_SIZE_COUNT == cache2->getResourceCount());
         for (int i = 0; i < loops; ++i) {
             for (int k = 0; k < CACHE_SIZE_COUNT; ++k) {
-                GrResourceKey key = BenchResource::ComputeKey(k);
+                GrContentKey key;
+                BenchResource::ComputeKey(k, &key);
                 SkAutoTUnref<GrGpuResource> resource(cache2->findAndRefContentResource(key));
                 SkASSERT(resource);
             }
         }
     }
 
 private:
     SkAutoTUnref<GrContext> fContext;
     typedef Benchmark INHERITED;
 };
 
 DEF_BENCH( return new GrResourceCacheBenchAdd(); )
 DEF_BENCH( return new GrResourceCacheBenchFind(); )
 
 #endif