Fuse GrReplacements and GrLayerCache

src/gpu/GrLayerCache.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlas.h"
 #include "GrGpu.h"
 #include "GrLayerCache.h"
@@ skipping 107 matching lines @@
     fLayerHash.rewind();
 
     // The atlas only lets go of its texture when the atlas is deleted.
     fAtlas.free();
 }
 
 GrCachedLayer* GrLayerCache::createLayer(uint32_t pictureID,
                                          int start, int stop,
                                          const SkIRect& bounds,
                                          const SkMatrix& initialMat,
-                                         const int* key,
+                                         const unsigned* key,
                                          int keySize,
                                          const SkPaint* paint) {
     SkASSERT(pictureID != SK_InvalidGenID && start >= 0 && stop > 0);
 
     GrCachedLayer* layer = SkNEW_ARGS(GrCachedLayer, (pictureID, start, stop, bounds, initialMat,
                                                       key, keySize, paint));
     fLayerHash.add(layer);
     return layer;
 }
 
 GrCachedLayer* GrLayerCache::findLayer(uint32_t pictureID, const SkMatrix& initialMat,
-                                       const int* key, int keySize) {
+                                       const unsigned* key, int keySize) {
     SkASSERT(pictureID != SK_InvalidGenID);
     return fLayerHash.find(GrCachedLayer::Key(pictureID, initialMat, key, keySize));
 }
 
 GrCachedLayer* GrLayerCache::findLayerOrCreate(uint32_t pictureID,
                                                int start, int stop,
                                                const SkIRect& bounds,
                                                const SkMatrix& initialMat,
-                                               const int* key,
+                                               const unsigned* key,
                                                int keySize,
                                                const SkPaint* paint) {
     SkASSERT(pictureID != SK_InvalidGenID && start >= 0 && stop > 0);
     GrCachedLayer* layer = fLayerHash.find(GrCachedLayer::Key(pictureID, initialMat, key, keySize));
     if (NULL == layer) {
         layer = this->createLayer(pictureID, start, stop, bounds, initialMat, key, keySize, paint);
     }
 
     return layer;
 }
@@ skipping 42 matching lines @@
             GrPlot* plot = fAtlas->addToAtlas(&pictInfo->fPlotUsage,
                                               desc.fWidth, desc.fHeight,
                                               NULL, &loc);
             // addToAtlas can allocate the backing texture
             SkDEBUGCODE(avl.setBackingTexture(fAtlas->getTexture()));
             if (plot) {
 #if !GR_CACHE_HOISTED_LAYERS
                 pictInfo->incPlotUsage(plot->id());
 #endif
                 // The layer was successfully added to the atlas
-                GrIRect16 bounds = GrIRect16::MakeXYWH(loc.fX, loc.fY,
-                                                       SkToS16(desc.fWidth),
-                                                       SkToS16(desc.fHeight));
+                const SkIRect bounds = SkIRect::MakeXYWH(loc.fX, loc.fY, 
+                                                         desc.fWidth, desc.fHeight);
                 layer->setTexture(fAtlas->getTexture(), bounds);
                 layer->setPlot(plot);
                 layer->setLocked(true);
                 this->incPlotLock(layer->plot()->id());
                 *needsRendering = true;
                 return true;
             }
 
             // The layer was rejected by the atlas (even though we know it is
             // plausibly atlas-able). See if a plot can be purged and try again.
@@ skipping 18 matching lines @@
         return true;
     }
 
     SkAutoTUnref<GrTexture> tex(
         fContext->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch));
 
     if (!tex) {
         return false;
     }
 
-    layer->setTexture(tex, GrIRect16::MakeWH(SkToS16(desc.fWidth), SkToS16(desc.fHeight)));
+    layer->setTexture(tex, SkIRect::MakeWH(desc.fWidth, desc.fHeight));
     layer->setLocked(true);
     *needsRendering = true;
     return true;
 }
 
 void GrLayerCache::unlock(GrCachedLayer* layer) {
     SkDEBUGCODE(GrAutoValidateLayer avl(fAtlas ? fAtlas->getTexture() : NULL, layer);)
 
     if (NULL == layer || !layer->locked()) {
         // invalid or not locked
@@ skipping 18 matching lines @@
         if (0 == pictInfo->plotUsage(plotID)) {
             GrAtlas::RemovePlot(&pictInfo->fPlotUsage, layer->plot());
 
             if (pictInfo->fPlotUsage.isEmpty()) {
                 fPictureHash.remove(pictInfo->fPictureID);
                 SkDELETE(pictInfo);
             }
         }
 
         layer->setPlot(NULL);
-        layer->setTexture(NULL, GrIRect16::MakeEmpty());
+        layer->setTexture(NULL, SkIRect::MakeEmpty());
 #endif
 
     } else {
-        layer->setTexture(NULL, GrIRect16::MakeEmpty());
+        layer->setTexture(NULL, SkIRect::MakeEmpty());
     }
 
     layer->setLocked(false);
 }
 
 #ifdef SK_DEBUG
 void GrLayerCache::validate() const {
     int plotLocks[kNumPlotsX * kNumPlotsY];
     memset(plotLocks, 0, sizeof(plotLocks));
 
@@ skipping 188 matching lines @@
         fileName.appendf("\\%d", layer->fKey.pictureID());
         for (int i = 0; i < layer->fKey.keySize(); ++i) {
             fileName.appendf("-%d", layer->fKey.key()[i]);
         }
         fileName.appendf(".png");
 
         layer->texture()->surfacePriv().savePixels(fileName.c_str());
     }
 }
 #endif