Revert of Begin atlasing

Revert of Begin atlasing (https://codereview.chromium.org/354533004/)

Reason for revert:
Sigh

Original issue's description:
> Begin atlasing
> 
> This CL makes it possible for pulled-forward-layers to be atlased. It currently has a couple glaring limitations (which is why it is disabled):
> 
> 1) the atlased layers cannot be purged nor aged out
> 2) the texture backing the atlas is not pulled from (or returned to) the resource cache
> 
> #1 is on hold until we have a recycling rectanizer
> 
> A separate major limitation (the non-atlased layers aren't cached) is blocked until we can transmute entries in the resource cache from scratch to non-scratch while potentially preserving their contents.
> 
> Committed: https://skia.googlesource.com/skia/+/55e61f0ef4e5c8c34ac107deaadc9b4ffef3111b

TBR=bsalomon@google.com
NOTREECHECKS=true
NOTRY=true

Committed: https://skia.googlesource.com/skia/+/e462f2bed33283862bb983c67776a47c5a6acb01

[robertphillips, 2014-06-30 00:03:59]

Created Revert of Begin atlasing

[commit-bot: I haz the power, 2014-06-30 00:04:18]

CQ is trying da patch. Follow status at
 https://skia-tree-status.appspot.com/cq/robertphillips@google.com/359953002/1

[commit-bot: I haz the power, 2014-06-30 00:04:21]

The CQ bit was unchecked by commit-bot@chromium.org

[commit-bot: I haz the power, 2014-06-30 00:04:21]

Failed to apply patch for src/gpu/GrLayerCache.cpp:
While running git apply --index -p1;
  error: patch failed: src/gpu/GrLayerCache.cpp:42
  error: src/gpu/GrLayerCache.cpp: patch does not apply

Patch:       src/gpu/GrLayerCache.cpp
Index: src/gpu/GrLayerCache.cpp
diff --git a/src/gpu/GrLayerCache.cpp b/src/gpu/GrLayerCache.cpp
index
5f657c73420261be07b5275d8c7ac958230c0924..c20d8090621cfc3509a4dbd817a5279930a2416e
100644
--- a/src/gpu/GrLayerCache.cpp
+++ b/src/gpu/GrLayerCache.cpp
@@ -42,14 +42,14 @@
 };
 
 GrLayerCache::GrLayerCache(GrContext* context)
-    : fContext(context) {
-    this->initAtlas();
+    : fContext(context)
+    , fLayerPool(16) {      // TODO: may need to increase this later
 }
 
 GrLayerCache::~GrLayerCache() {
 }
 
-void GrLayerCache::initAtlas() {
+void GrLayerCache::init() {
     static const int kAtlasTextureWidth = 1024;
     static const int kAtlasTextureHeight = 1024;
 
@@ -58,31 +58,19 @@
     // The layer cache only gets 1 plot
     SkISize textureSize = SkISize::Make(kAtlasTextureWidth,
kAtlasTextureHeight);
     fAtlas.reset(SkNEW_ARGS(GrAtlas, (fContext->getGpu(),
kSkia8888_GrPixelConfig,
-                                      kRenderTarget_GrTextureFlagBit,
                                       textureSize, 1, 1, false)));
 }
 
 void GrLayerCache::freeAll() {
-    SkTDArray<GrCachedLayer*>& layerArray = fLayerHash.getArray();
-    for (int i = 0; i < fLayerHash.count(); ++i) {
-        this->unlock(layerArray[i]);
-    }
-
     fLayerHash.deleteAll();
-
-    // The atlas only lets go of its texture when the atlas is deleted. 
     fAtlas.free();
-    // GrLayerCache always assumes an atlas exists so recreate it. The atlas 
-    // lazily allocates a replacement texture so reallocating a new 
-    // atlas here won't disrupt a GrContext::contextDestroyed or
freeGpuResources.
-    // TODO: Make GrLayerCache lazily allocate the atlas manager?
-    this->initAtlas();
 }
 
 GrCachedLayer* GrLayerCache::createLayer(const SkPicture* picture, int layerID)
{
+    GrCachedLayer* layer = fLayerPool.alloc();
+
     SkASSERT(picture->uniqueID() != SK_InvalidGenID);
-
-    GrCachedLayer* layer = SkNEW_ARGS(GrCachedLayer, (picture->uniqueID(),
layerID));
+    layer->init(picture->uniqueID(), layerID);
     fLayerHash.insert(PictureLayerKey(picture->uniqueID(), layerID), layer);
     return layer;
 }
@@ -103,70 +91,19 @@
 }
 
 bool GrLayerCache::lock(GrCachedLayer* layer, const GrTextureDesc& desc) {
+    SkASSERT(NULL == layer->getTexture());
 
-    if (NULL != layer->texture()) {
-        // This layer is already locked
-#ifdef SK_DEBUG
-        if (!layer->rect().isEmpty()) {
-            // It claims to be atlased
-            SkASSERT(layer->rect().width() == desc.fWidth);
-            SkASSERT(layer->rect().height() == desc.fHeight);
-        }
-#endif
-        return true;
-    }
-
-#if USE_ATLAS
-    SkIPoint16 loc;
-    GrPlot* plot = fAtlas->addToAtlas(&fPlotUsage, desc.fWidth, desc.fHeight,
NULL, &loc);
-    if (NULL != plot) {
-        GrIRect16 bounds = GrIRect16::MakeXYWH(loc.fX, loc.fY, 
-                                               SkToS16(desc.fWidth),
SkToS16(desc.fHeight));
-        layer->setTexture(fAtlas->getTexture(), bounds);
-        return false;
-    }
-#endif
-
-    // This path always uses a new scratch texture and (thus) doesn't cache
anything.
+    // This just uses scratch textures and doesn't cache the texture.
     // This can yield a lot of re-rendering
-    layer->setTexture(fContext->lockAndRefScratchTexture(desc,
GrContext::kApprox_ScratchTexMatch),
-                      GrIRect16::MakeEmpty());
+    layer->setTexture(fContext->lockAndRefScratchTexture(desc,
GrContext::kApprox_ScratchTexMatch));
     return false;
 }
 
 void GrLayerCache::unlock(GrCachedLayer* layer) {
-    if (NULL == layer || NULL == layer->texture()) {
+    if (NULL == layer || NULL == layer->getTexture()) {
         return;
     }
 
-    // The atlas doesn't currently use a scratch texture (and we would have
-    // to free up space differently anyways)
-    // TODO: unlock atlas space when a recycling rectanizer is available
-    if (layer->texture() != fAtlas->getTexture()) {
-        fContext->unlockScratchTexture(layer->texture());
-        layer->setTexture(NULL, GrIRect16::MakeEmpty());
-    }
+    fContext->unlockScratchTexture(layer->getTexture());
+    layer->setTexture(NULL);
 }
-
-void GrLayerCache::purge(const SkPicture* picture) {
-    // This is somewhat of an abuse of GrTHashTable. We need to find all the
-    // layers associated with 'picture' but the usual hash calls only look for
-    // exact key matches. This code peeks into the hash table's innards to
-    // find all the 'picture'-related layers.
-    // TODO: use a different data structure for the layer hash?
-    SkTDArray<GrCachedLayer*> toBeRemoved;
-
-    const SkTDArray<GrCachedLayer*>& layerArray = fLayerHash.getArray();
-    for (int i = 0; i < fLayerHash.count(); ++i) {
-        if (picture->uniqueID() == layerArray[i]->pictureID()) {
-            *toBeRemoved.append() = layerArray[i];
-        }
-    }
-
-    for (int i = 0; i < toBeRemoved.count(); ++i) {
-        this->unlock(toBeRemoved[i]);
-
-        PictureLayerKey key(picture->uniqueID(), toBeRemoved[i]->layerID());
-        fLayerHash.remove(key, toBeRemoved[i]);
-    }
-}

[robertphillips, 2014-06-30 00:15:51]

The CQ bit was checked by robertphillips@google.com

[commit-bot: I haz the power, 2014-06-30 00:16:20]

CQ is trying da patch. Follow status at
 https://skia-tree-status.appspot.com/cq/robertphillips@google.com/359953002/1

[commit-bot: I haz the power, 2014-06-30 00:16:31]

Change committed as e462f2bed33283862bb983c67776a47c5a6acb01