Switch Layer Hoisting over to SkRecord backend

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 "SkPictureRangePlayback.h"
 #include "SkCanvas.h"
+#include "SkRecordDraw.h"
 #include "SkSurface.h"
 
 // Return true if any layers are suitable for hoisting
 bool GrLayerHoister::FindLayersToHoist(const GrAccelData *gpuData,
                                        const SkRect& query,
                                        bool pullForward[]) {
     bool anyHoisted = false;
 
     // Layer hoisting 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
@@ skipping 65 matching lines @@
             // Since 'clear' doesn't respect the clip we need to draw a rect
             // TODO: ensure none of the atlased layers contain a clear call!
             atlasCanvas->drawRect(bound, paint);
 
             // 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 the correct location in the backing texture.
             atlasCanvas->translate(bound.fLeft, bound.fTop);
             atlasCanvas->concat(layer->ctm());
 
-            SkPictureRangePlayback rangePlayback(picture,
-                                                 layer->start(),
-                                                 layer->stop());
-            rangePlayback.draw(atlasCanvas, NULL);
+            SkRecordPartialDraw(*picture->fRecord.get(), atlasCanvas, bound,
+                                layer->start(), layer->stop());
 
             atlasCanvas->restore();
         }
 
         atlasCanvas->flush();
     }
 
     // Render the non-atlased layers that require it
     for (int i = 0; i < nonAtlased.count(); ++i) {
         GrCachedLayer* layer = nonAtlased[i];
 
         // Each non-atlased layer has its own GrTexture
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(
-            layer->texture()->asRenderTarget(),
-            SkSurface::kStandard_TextRenderMode,
-            SkSurface::kDontClear_RenderTargetFlag));
+                                                layer->texture()->asRenderTarget(),
+                                                SkSurface::kStandard_TextRenderMode,
+                                                SkSurface::kDontClear_RenderTargetFlag));
 
         SkCanvas* layerCanvas = surface->getCanvas();
 
         // Add a rect clip to make sure the rendering doesn't
         // extend beyond the boundaries of the atlased sub-rect
         SkRect bound = SkRect::MakeXYWH(SkIntToScalar(layer->rect().fLeft),
                                         SkIntToScalar(layer->rect().fTop),
                                         SkIntToScalar(layer->rect().width()),
                                         SkIntToScalar(layer->rect().height()));
 
         layerCanvas->clipRect(bound); // TODO: still useful?
 
         layerCanvas->clear(SK_ColorTRANSPARENT);
 
         layerCanvas->concat(layer->ctm());
 
-        SkPictureRangePlayback rangePlayback(picture,
-                                             layer->start(),
-                                             layer->stop());
-        rangePlayback.draw(layerCanvas, NULL);
+        SkRecordPartialDraw(*picture->fRecord.get(), layerCanvas, bound,
+                            layer->start(), layer->stop());
 
         layerCanvas->flush();
     }
 }
 
 void GrLayerHoister::UnlockLayers(GrLayerCache* layerCache, const SkPicture* picture) {
     SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* data = picture->EXPERIMENTAL_getAccelData(key);
     SkASSERT(NULL != data);
@@ skipping 15 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->purge(picture->uniqueID());
 
     layerCache->purgeAll();
 #endif
 }