Switch Layer Hoisting over to SkRecord backend

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"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "GrContext.h"
 #include "GrBitmapTextContext.h"
 #include "GrDistanceFieldTextContext.h"
 #include "GrLayerCache.h"
 #include "GrLayerHoister.h"
 #include "GrPictureUtils.h"
+#include "GrRecordReplaceDraw.h"
 #include "GrStrokeInfo.h"
 #include "GrTracing.h"
 
 #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 "SkPictureRangePlayback.h"
-#include "SkPictureReplacementPlayback.h"
+#include "SkRecord.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkXfermode.h"
 #include "SkErrorInternals.h"
 
 enum { kDefaultImageFilterCacheSize = 32 * 1024 * 1024 };
@@ skipping 1822 matching lines @@
 
     SkRect clipBounds;
     if (!mainCanvas->getClipBounds(&clipBounds)) {
         return true;
     }
 
     if (!GrLayerHoister::FindLayersToHoist(gpuData, clipBounds, pullForward.get())) {
         return false;
     }
 
-    SkPictureReplacementPlayback::PlaybackReplacements replacements;
+    GrReplacements replacements;
 
     SkTDArray<GrCachedLayer*> atlased, nonAtlased;
     atlased.setReserve(gpuData->numSaveLayers());
 
     // Generate the layer and/or ensure it is locked
     for (int i = 0; i < gpuData->numSaveLayers(); ++i) {
         if (pullForward[i]) {
             const GrAccelData::SaveLayerInfo& info = gpuData->saveLayerInfo(i);
 
             GrCachedLayer* layer = fContext->getLayerCache()->findLayerOrCreate(picture->uniqueID(), 
                                                                                 info.fSaveLayerOpID, 
                                                                                 info.fRestoreOpID, 
                                                                                 info.fOriginXform);
 
-            SkPictureReplacementPlayback::PlaybackReplacements::ReplacementInfo* layerInfo =
-                                                                        replacements.push();
+            GrReplacements::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;
             // TODO: need to deal with sample count
 
             bool needsRendering = fContext->getLayerCache()->lock(layer, desc,
                                                     info.fHasNestedLayers || info.fIsNested);
             if (NULL == layer->texture()) {
                 continue;
             }
 
-            layerInfo->fBM = SkNEW(SkBitmap);  // fBM is allocated so ReplacementInfo can be POD
+            SkBitmap bm;
             wrap_texture(layer->texture(),
                          !layer->isAtlased() ? desc.fWidth : layer->texture()->width(),
                          !layer->isAtlased() ? desc.fHeight : layer->texture()->height(),
-                         layerInfo->fBM);
+                         &bm);
+            layerInfo->fImage = SkImage::NewTexture(bm);
 
             SkASSERT(info.fPaint);
             layerInfo->fPaint = info.fPaint;
 
             layerInfo->fSrcRect = SkIRect::MakeXYWH(layer->rect().fLeft,
                                                     layer->rect().fTop,
                                                     layer->rect().width(),
                                                     layer->rect().height());
 
             if (needsRendering) {
                 if (layer->isAtlased()) {
                     *atlased.append() = layer;
                 } else {
                     *nonAtlased.append() = layer;
                 }
             }
         }
     }
 
     GrLayerHoister::DrawLayers(picture, atlased, nonAtlased);
 
     // Render the entire picture using new layers
-    SkPictureReplacementPlayback playback(picture, &replacements, NULL);
-
-    playback.draw(mainCanvas, NULL);
+    GrRecordReplaceDraw(*picture->fRecord, mainCanvas, picture->fBBH.get(), &replacements, NULL);
 
     GrLayerHoister::UnlockLayers(fContext->getLayerCache(), picture);
 
     return true;
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }