Split SkPicturePlayback out of SkPictureData

src/gpu/SkGpuDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkGpuDevice.h"
 
 #include "effects/GrBicubicEffect.h"
@@ skipping 12 matching lines @@
 #include "SkGrTexturePixelRef.h"
 
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkMaskFilter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
+#include "SkPicturePlayback.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkErrorInternals.h"
 
 #define CACHE_COMPATIBLE_DEVICE_TEXTURES 1
 
@@ skipping 1809 matching lines @@
         pullForward[i] = false;
     }
 
     SkRect clipBounds;
     if (!canvas->getClipBounds(&clipBounds)) {
         return true;
     }
     SkIRect query;
     clipBounds.roundOut(&query);
 
-    const SkPicture::OperationList& ops = picture->EXPERIMENTAL_getActiveOps(query);
+    SkAutoTDelete<const SkPicture::OperationList> ops(picture->EXPERIMENTAL_getActiveOps(query));
 
     // This code pre-renders the entire layer since it will be cached and potentially
     // reused with different clips (e.g., in different tiles). Because of this the
     // clip will not be limiting the size of the pre-rendered layer. kSaveLayerMaxSize
     // is used to limit which clips are pre-rendered.
     static const int kSaveLayerMaxSize = 256;
 
-    if (ops.valid()) {
+    if (NULL != ops.get()) {
         // In this case the picture has been generated with a BBH so we use
         // the BBH to limit the pre-rendering to just the layers needed to cover
         // the region being drawn
-        for (int i = 0; i < ops.numOps(); ++i) {
-            uint32_t offset = ops.offset(i);
+        for (int i = 0; i < ops->numOps(); ++i) {
+            uint32_t offset = ops->offset(i);
 
             // For now we're saving all the layers in the GPUAccelData so they
             // can be nested. Additionally, the nested layers appear before
             // their parent in the list.
             for (int j = 0 ; j < gpuData->numSaveLayers(); ++j) {
                 const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(j);
 
                 if (pullForward[j]) {
                     continue;            // already pulling forward
                 }
@@ skipping 35 matching lines @@
                 kSaveLayerMaxSize < info.fSize.fWidth ||
                 kSaveLayerMaxSize < info.fSize.fHeight ||
                 info.fIsNested) {
                 continue;
             }
 
             pullForward[j] = true;
         }
     }
 
-    SkPictureData::PlaybackReplacements replacements;
+    SkPicturePlayback::PlaybackReplacements replacements;
 
     // Generate the layer and/or ensure it is locked
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         if (pullForward[i]) {
             GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture, i);
 
             const GPUAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
 
-            SkPictureData::PlaybackReplacements::ReplacementInfo* layerInfo =
+            SkPicturePlayback::PlaybackReplacements::ReplacementInfo* layerInfo =
                                                                         replacements.push();
             layerInfo->fStart = info.fSaveLayerOpID;
             layerInfo->fStop = info.fRestoreOpID;
             layerInfo->fPos = info.fOffset;
 
             GrTextureDesc desc;
             desc.fFlags = kRenderTarget_GrTextureFlagBit;
             desc.fWidth = info.fSize.fWidth;
             desc.fHeight = info.fSize.fHeight;
             desc.fConfig = kSkia8888_GrPixelConfig;
@@ skipping 51 matching lines @@
 
                 if (!layer->rect().isEmpty()) {
                     // info.fCTM maps the layer's top/left to the origin.
                     // Since this layer is atlased the top/left corner needs
                     // to be offset to some arbitrary location in the backing 
                     // texture.
                     canvas->translate(SkIntToScalar(layer->rect().fLeft),
                                       SkIntToScalar(layer->rect().fTop));
                 } 
 
-                picture->fData->setDrawLimits(info.fSaveLayerOpID, info.fRestoreOpID);
-                picture->fData->draw(*canvas, NULL);
-                picture->fData->setDrawLimits(0, 0);
+                SkPicturePlayback playback(picture);
+                playback.setDrawLimits(info.fSaveLayerOpID, info.fRestoreOpID);
+                playback.draw(canvas, NULL);
 
                 canvas->flush();
             }
         }
     }
 
     // Playback using new layers
-    picture->fData->setReplacements(&replacements);
-    picture->fData->draw(*canvas, NULL);
-    picture->fData->setReplacements(NULL);
+    SkPicturePlayback playback(picture);
+
+    playback.setReplacements(&replacements);
+    playback.draw(canvas, NULL);
 
     // unlock the layers
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         GrCachedLayer* layer = fContext->getLayerCache()->findLayer(picture, i);
         fContext->getLayerCache()->unlock(layer);
     }
 
     return true;
 }