Expose layer hoisting API in GrContext

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 "SkCanvas.h"
 #include "SkRecordDraw.h"
 #include "GrRecordReplaceDraw.h"
 #include "SkGrPixelRef.h"
 #include "SkSurface.h"
 
 // Return true if any layers are suitable for hoisting
-bool GrLayerHoister::FindLayersToHoist(const SkPicture* topLevelPicture,
+bool GrLayerHoister::FindLayersToHoist(GrContext* context,
+                                       const SkPicture* topLevelPicture,
                                        const SkRect& query,
-                                       SkTDArray<HoistedLayer>* atlased,
-                                       SkTDArray<HoistedLayer>* nonAtlased,
-                                       SkTDArray<HoistedLayer>* recycled,
-                                       GrLayerCache* layerCache) {
+                                       SkTDArray<GrHoistedLayer>* atlased,
+                                       SkTDArray<GrHoistedLayer>* nonAtlased,
+                                       SkTDArray<GrHoistedLayer>* recycled) {
     bool anyHoisted = false;
 
+    GrLayerCache* layerCache = context->getLayerCache();
+
+    layerCache->processDeletedPictures();
+
     SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key);
     if (NULL == topLevelData) {
         return false;
     }
 
     const GrAccelData *topLevelGPUData = static_cast<const GrAccelData*>(topLevelData);
     if (0 == topLevelGPUData->numSaveLayers()) {
         return false;
@@ skipping 60 matching lines @@
             desc.fHeight = info.fSize.fHeight;
             desc.fConfig = kSkia8888_GrPixelConfig;
             // TODO: need to deal with sample count
 
             bool needsRendering = layerCache->lock(layer, desc,
                                                    info.fHasNestedLayers || info.fIsNested);
             if (NULL == layer->texture()) {
                 continue;
             }
 
-            HoistedLayer* hl;
+            GrHoistedLayer* hl;
 
             if (needsRendering) {
                 if (layer->isAtlased()) {
                     hl = atlased->append();
                 } else {
                     hl = nonAtlased->append();
                 }
             } else {
                 hl = recycled->append();
             }
         
             hl->fLayer = layer;
             hl->fPicture = pict;
             hl->fOffset = info.fOffset;
             hl->fCTM = info.fOriginXform;
         }
     }
 
     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();
 }
 
-static void convert_layers_to_replacements(const SkTDArray<GrLayerHoister::HoistedLayer>& layers,
+static void convert_layers_to_replacements(const SkTDArray<GrHoistedLayer>& layers,
                                            GrReplacements* replacements) {
     // TODO: just replace GrReplacements::ReplacementInfo with GrCachedLayer?
     for (int i = 0; i < layers.count(); ++i) {
         GrCachedLayer* layer = layers[i].fLayer;
         const SkPicture* picture = layers[i].fPicture;
 
         GrReplacements::ReplacementInfo* layerInfo =
                     replacements->newReplacement(picture->uniqueID(),
                                                  layer->start(),
                                                  layers[i].fCTM);
@@ skipping 13 matching lines @@
                                 ? SkNEW_ARGS(SkPaint, (*layers[i].fLayer->paint()))
                                 : NULL;
 
         layerInfo->fSrcRect = SkIRect::MakeXYWH(layers[i].fLayer->rect().fLeft,
                                                 layers[i].fLayer->rect().fTop,
                                                 layers[i].fLayer->rect().width(),
                                                 layers[i].fLayer->rect().height());
     }
 }
 
-void GrLayerHoister::DrawLayers(const SkTDArray<HoistedLayer>& atlased,
-                                const SkTDArray<HoistedLayer>& nonAtlased,
-                                const SkTDArray<HoistedLayer>& recycled,
+void GrLayerHoister::DrawLayers(const SkTDArray<GrHoistedLayer>& atlased,
+                                const SkTDArray<GrHoistedLayer>& nonAtlased,
+                                const SkTDArray<GrHoistedLayer>& recycled,
                                 GrReplacements* replacements) {
     // Render the atlased layers that require it
     if (atlased.count() > 0) {
         // All the atlased layers are rendered into the same GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         atlased[0].fLayer->texture()->asRenderTarget(), NULL));
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
         SkPaint paint;
@@ skipping 89 matching lines @@
     layerCache->unlock(layer);
 
 #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->purge(picture->uniqueID());
 #endif
 }
 
-void GrLayerHoister::UnlockLayers(GrLayerCache* layerCache,
-                                  const SkTDArray<HoistedLayer>& atlased,
-                                  const SkTDArray<HoistedLayer>& nonAtlased,
-                                  const SkTDArray<HoistedLayer>& recycled) {
+void GrLayerHoister::UnlockLayers(GrContext* context,
+                                  const SkTDArray<GrHoistedLayer>& atlased,
+                                  const SkTDArray<GrHoistedLayer>& nonAtlased,
+                                  const SkTDArray<GrHoistedLayer>& recycled) {
+    GrLayerCache* layerCache = context->getLayerCache();
 
     for (int i = 0; i < atlased.count(); ++i) {
         unlock_layer_in_cache(layerCache, atlased[i].fPicture, atlased[i].fLayer);
     }
 
     for (int i = 0; i < nonAtlased.count(); ++i) {
         unlock_layer_in_cache(layerCache, nonAtlased[i].fPicture, nonAtlased[i].fLayer);
     }
 
     for (int i = 0; i < recycled.count(); ++i) {
         unlock_layer_in_cache(layerCache, recycled[i].fPicture, recycled[i].fLayer);
     }
 
 #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
 }