Add clip to layer cache

src/gpu/GrLayerHoister.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 "GrLayerCache.h"
 #include "GrLayerHoister.h"
+#include "GrRecordReplaceDraw.h"
+
 #include "SkCanvas.h"
+#include "SkGrPixelRef.h"
 #include "SkRecordDraw.h"
-#include "GrRecordReplaceDraw.h"
-#include "SkGrPixelRef.h"
 #include "SkSurface.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
 static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
                                  const GrAccelData::SaveLayerInfo& info,
+                                 const SkIRect& layerRect,
                                  SkTDArray<GrHoistedLayer>* atlased,
                                  SkTDArray<GrHoistedLayer>* nonAtlased,
                                  SkTDArray<GrHoistedLayer>* recycled) {
     const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
 
     GrCachedLayer* layer = layerCache->findLayerOrCreate(pict->uniqueID(),
                                                          info.fSaveLayerOpID,
                                                          info.fRestoreOpID,
+                                                         layerRect,
                                                          info.fOriginXform,
                                                          info.fPaint);
 
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit;
-    desc.fWidth = info.fSize.fWidth;
-    desc.fHeight = info.fSize.fHeight;
+    desc.fWidth = layerRect.width();
+    desc.fHeight = layerRect.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
     // TODO: need to deal with sample count
 
-    bool needsRendering = layerCache->lock(layer, desc, info.fHasNestedLayers || info.fIsNested);
+
+    bool disallowAtlasing = info.fHasNestedLayers || info.fIsNested ||
+                            (layer->paint() && layer->paint()->getImageFilter());
+
+    bool needsRendering = layerCache->lock(layer, desc, disallowAtlasing);
     if (NULL == layer->texture()) {
         // GPU resources could not be secured for the hoisting of this layer
         return;
     }
 
     GrHoistedLayer* hl;
 
     if (needsRendering) {
         if (layer->isAtlased()) {
             hl = atlased->append();
         } else {
             hl = nonAtlased->append();
         }
     } else {
         hl = recycled->append();
     }
     
     layerCache->addUse(layer);
     hl->fLayer = layer;
     hl->fPicture = pict;
-    hl->fOffset = info.fOffset;
+    hl->fOffset = SkIPoint::Make(layerRect.fLeft, layerRect.fTop);
     hl->fCTM = info.fOriginXform;
 }
 
 // Return true if any layers are suitable for hoisting
 bool GrLayerHoister::FindLayersToHoist(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* atlased,
                                        SkTDArray<GrHoistedLayer>* nonAtlased,
                                        SkTDArray<GrHoistedLayer>* recycled) {
-
     GrLayerCache* layerCache = context->getLayerCache();
 
     layerCache->processDeletedPictures();
 
     SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key);
     if (!topLevelData) {
         return false;
     }
@@ skipping 13 matching lines @@
     // Parent layers are hoisted but are never atlased (so that we never swap
     // away from the atlas rendertarget when generating the hoisted layers).
 
     atlased->setReserve(atlased->count() + topLevelGPUData->numSaveLayers());
 
     // Find and prepare for hoisting all the layers that intersect the query rect
     for (int i = 0; i < topLevelGPUData->numSaveLayers(); ++i) {
 
         const GrAccelData::SaveLayerInfo& info = topLevelGPUData->saveLayerInfo(i);
 
-        SkRect layerRect = SkRect::MakeXYWH(SkIntToScalar(info.fOffset.fX),
-                                            SkIntToScalar(info.fOffset.fY),
-                                            SkIntToScalar(info.fSize.fWidth),
-                                            SkIntToScalar(info.fSize.fHeight));
-
-        if (!SkRect::Intersects(query, layerRect)) {
+        SkRect layerRect = SkRect::Make(info.fBounds);
+        if (!layerRect.intersect(query)) {
             continue;
         }
 
+
+        SkIRect ir;
+        layerRect.roundOut(&ir);
+
         // TODO: ignore perspective projected layers here!
         // TODO: once this code is more stable unsuitable layers can
         // just be omitted during the optimization stage
         if (info.fIsNested) {
             continue;
         }
 
-        prepare_for_hoisting(layerCache, topLevelPicture, info, atlased, nonAtlased, recycled);
+        prepare_for_hoisting(layerCache, topLevelPicture, info, ir, atlased, nonAtlased, recycled);
         anyHoisted = true;
     }
 
     return anyHoisted;
 }
 
 static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
@@ skipping 153 matching lines @@
 #if DISABLE_CACHING
     // This code completely clears out the atlas. It is required when
     // caching is disabled so the atlas doesn't fill up and force more
     // free floating layers
     layerCache->purgeAll();
 #endif
 
     SkDEBUGCODE(layerCache->validate();)
 }