Revert of Sketch splitting SkPicture into an interface and SkBigPicture.

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 "SkBigPicture.h"
 #include "SkCanvas.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDeviceProperties.h"
 #include "SkGpuDevice.h"
 #include "SkGrPixelRef.h"
 #include "SkLayerInfo.h"
 #include "SkRecordDraw.h"
 #include "SkSurface.h"
 #include "SkSurface_Gpu.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
-static void prepare_for_hoisting(GrLayerCache* layerCache,
+static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
                                  const SkMatrix& initialMat,
                                  const SkLayerInfo::BlockInfo& info,
                                  const SkIRect& srcIR,
                                  const SkIRect& dstIR,
                                  SkTDArray<GrHoistedLayer>* needRendering,
                                  SkTDArray<GrHoistedLayer>* recycled,
                                  bool attemptToAtlas,
                                  int numSamples) {
     const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
@@ skipping 32 matching lines @@
     GrHoistedLayer* hl;
 
     if (needsRendering) {
         if (!attemptToAtlas) {
             SkASSERT(!layer->isAtlased());
         }
         hl = needRendering->append();
     } else {
         hl = recycled->append();
     }
-
+    
     layerCache->addUse(layer);
     hl->fLayer = layer;
     hl->fPicture = pict;
     hl->fLocalMat = info.fLocalMat;
     hl->fInitialMat = initialMat;
     hl->fPreMat = initialMat;
     hl->fPreMat.preConcat(info.fPreMat);
 }
 
 // Compute the source rect and return false if it is empty.
@@ skipping 34 matching lines @@
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* atlased,
                                        SkTDArray<GrHoistedLayer>* recycled,
                                        int numSamples) {
     if (0 != numSamples) {
         // MSAA layers are currently never atlased
         return;
     }
 
     GrLayerCache* layerCache = context->getLayerCache();
+
     layerCache->processDeletedPictures();
 
-    const SkBigPicture::AccelData* topLevelData = NULL;
-    if (const SkBigPicture* bp = topLevelPicture->asSkBigPicture()) {
-        topLevelData = bp->accelData();
-    }
+    SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
+
+    const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key);
     if (!topLevelData) {
         return;
     }
 
     const SkLayerInfo *topLevelGPUData = static_cast<const SkLayerInfo*>(topLevelData);
     if (0 == topLevelGPUData->numBlocks()) {
         return;
     }
 
     atlased->setReserve(atlased->count() + topLevelGPUData->numBlocks());
@@ skipping 34 matching lines @@
                                        const SkPicture* topLevelPicture,
                                        const SkMatrix& initialMat,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* needRendering,
                                        SkTDArray<GrHoistedLayer>* recycled,
                                        int numSamples) {
     GrLayerCache* layerCache = context->getLayerCache();
 
     layerCache->processDeletedPictures();
 
-    const SkBigPicture::AccelData* topLevelData = NULL;
-    if (const SkBigPicture* bp = topLevelPicture->asSkBigPicture()) {
-        topLevelData = bp->accelData();
-    }
+    SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
+
+    const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key);
     if (!topLevelData) {
         return;
     }
 
     const SkLayerInfo *topLevelGPUData = static_cast<const SkLayerInfo*>(topLevelData);
     if (0 == topLevelGPUData->numBlocks()) {
         return;
     }
 
     // Find and prepare for hoisting all the layers that intersect the query rect
@@ skipping 27 matching lines @@
     if (atlased.count() > 0) {
         // All the atlased layers are rendered into the same GrTexture
         SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         atlased[0].fLayer->texture()->asRenderTarget(), &props));
 
         SkCanvas* atlasCanvas = surface->getCanvas();
 
         for (int i = 0; i < atlased.count(); ++i) {
             const GrCachedLayer* layer = atlased[i].fLayer;
-            const SkBigPicture* pict = atlased[i].fPicture->asSkBigPicture();
-            if (!pict) {
-                // TODO: can we assume / assert this?
-                continue;
-            }
+            const SkPicture* pict = atlased[i].fPicture;
             const SkIPoint offset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop);
             SkDEBUGCODE(const SkPaint* layerPaint = layer->paint();)
 
             SkASSERT(!layerPaint || !layerPaint->getImageFilter());
             SkASSERT(!layer->filter());
 
             atlasCanvas->save();
 
             // Add a rect clip to make sure the rendering doesn't
             // extend beyond the boundaries of the atlased sub-rect
             const SkRect bound = SkRect::Make(layer->rect());
             atlasCanvas->clipRect(bound);
             atlasCanvas->clear(0);
 
             // '-offset' maps the layer's top/left to the origin.
             // Since this layer is atlased, the top/left corner needs
             // to be offset to the correct location in the backing texture.
             SkMatrix initialCTM;
             initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY));
             initialCTM.preTranslate(bound.fLeft, bound.fTop);
             initialCTM.preConcat(atlased[i].fPreMat);
 
             atlasCanvas->setMatrix(initialCTM);
             atlasCanvas->concat(atlased[i].fLocalMat);
 
-            pict->partialPlayback(atlasCanvas, layer->start() + 1, layer->stop(), initialCTM);
+            SkRecordPartialDraw(*pict->fRecord.get(), atlasCanvas,
+                                pict->drawablePicts(), pict->drawableCount(),
+                                layer->start() + 1, layer->stop(), initialCTM);
+
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 }
 
 SkBitmap wrap_texture(GrTexture* texture) {
     SkASSERT(texture);
 
@@ skipping 39 matching lines @@
     }
 
     SkIRect newRect = SkIRect::MakeWH(filteredBitmap.width(), filteredBitmap.height());
     layer->setTexture(filteredBitmap.getTexture(), newRect);
     layer->setOffset(offset);
 }
 
 void GrLayerHoister::DrawLayers(GrContext* context, const SkTDArray<GrHoistedLayer>& layers) {
     for (int i = 0; i < layers.count(); ++i) {
         GrCachedLayer* layer = layers[i].fLayer;
-        const SkBigPicture* pict = layers[i].fPicture->asSkBigPicture();
-        if (!pict) {
-            // TODO: can we assume / assert this?
-            continue;
-        }
+        const SkPicture* pict = layers[i].fPicture;
         const SkIPoint offset = SkIPoint::Make(layer->srcIR().fLeft, layer->srcIR().fTop);
 
         // Each non-atlased layer has its own GrTexture
         SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
                                         layer->texture()->asRenderTarget(), &props));
 
         SkCanvas* layerCanvas = surface->getCanvas();
 
         SkASSERT(0 == layer->rect().fLeft && 0 == layer->rect().fTop);
 
         // Add a rect clip to make sure the rendering doesn't
         // extend beyond the boundaries of the layer
         const SkRect bound = SkRect::Make(layer->rect());
         layerCanvas->clipRect(bound);
         layerCanvas->clear(SK_ColorTRANSPARENT);
 
         SkMatrix initialCTM;
         initialCTM.setTranslate(SkIntToScalar(-offset.fX), SkIntToScalar(-offset.fY));
         initialCTM.preConcat(layers[i].fPreMat);
 
         layerCanvas->setMatrix(initialCTM);
         layerCanvas->concat(layers[i].fLocalMat);
 
-        pict->partialPlayback(layerCanvas, layer->start()+1, layer->stop(), initialCTM);
+        SkRecordPartialDraw(*pict->fRecord.get(), layerCanvas,
+                            pict->drawablePicts(), pict->drawableCount(),
+                            layer->start()+1, layer->stop(), initialCTM);
+
         layerCanvas->flush();
 
         if (layer->filter()) {
             SkSurface_Gpu* gpuSurf = static_cast<SkSurface_Gpu*>(surface.get());
 
             FilterLayer(context, gpuSurf->getDevice(), layers[i]);
         }
     }
 }
 
@@ skipping 11 matching lines @@
 void GrLayerHoister::PurgeCache(GrContext* context) {
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerCache* layerCache = context->getLayerCache();
 
     // 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
 }