Update layer hoisting code to correctly render sub-picture layers

src/gpu/GrLayerHoister.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrLayerHoister_DEFINED
 #define GrLayerHoister_DEFINED
 
 #include "SkPicture.h"
 #include "SkTDArray.h"
 
 class GrAccelData;
 struct GrCachedLayer;
 class GrReplacements;
 struct SkRect;
 
 // This class collects the layer hoisting functionality in one place.
 // For each picture rendering:
 //  FindLayersToHoist should be called once to collect the required layers
 //  DrawLayers should be called once to render them
 //  UnlockLayers should be called once to allow the texture resources to be recycled
 class GrLayerHoister {
 public:
-    /** Find the layers in 'gpuData' that need hoisting.
-        @param gpuData    Acceleration structure containing layer information for a picture
-        @param query      The rectangle that is about to be drawn.
-        @param atlased    Out parameter storing the layers that should be hoisted to the atlas
-        @param nonAtlased Out parameter storing the layers that should be hoisted stand alone
+    struct HoistingInfo {

[bsalomon, 2014/09/23 14:57:35]

I can't think of anything much better but this name doesn't capture that this is
for a particular layer...

HoistedLayer?

or maybe just mimic the Gr thing's name: CachedLayer?

Also, shouldn't the fields be 'f' prefixed?

[robertphillips, 2014/09/24 14:49:04]

Done. Went with HoistedLayer.

+        const SkPicture* picture;
+        GrCachedLayer*   layer;
+    };
+
+    /** Find the layers in 'mainPicture' that need hoisting. Note that the discovered

[bsalomon, 2014/09/23 14:57:35]

"topLevel", "root", or "base" seem clearer to me than "main"

[robertphillips, 2014/09/24 14:49:03]

Done. Went with topLevel.

+        layers can be inside nested sub-pictures.
+        @param mainPicture The top-level picture that is about to be rendered
+        @param query       The rectangle that is about to be drawn.
+        @param atlased     Out parameter storing the layers that should be hoisted to the atlas
+        @param nonAtlased  Out parameter storing the layers that should be hoisted stand alone
         @param layerCache The source of new layers
         Return true if any layers are suitable for hoisting; false otherwise
     */
-    static bool FindLayersToHoist(const GrAccelData *gpuData,
+    static bool FindLayersToHoist(const SkPicture* mainPicture,
                                   const SkRect& query,
-                                  SkTDArray<GrCachedLayer*>* altased,
-                                  SkTDArray<GrCachedLayer*>* nonAtlased,
+                                  SkTDArray<HoistingInfo>* altased,
+                                  SkTDArray<HoistingInfo>* nonAtlased,
                                   GrLayerCache* layerCache);
 
-    /** Draw the specified layers of 'picture' into either the atlas or free
-        floating textures.
-        @param picture      The picture containing the layers
+    /** Draw the specified layers into either the atlas or free floating textures.
         @param atlased      The layers to be drawn into the atlas
         @param nonAtlased   The layers to be drawn into their own textures
         @oaram replacements The replacement structure to fill in with the rendered layer info
     */
-    static void DrawLayers(const SkPicture* picture,
-                           const SkTDArray<GrCachedLayer*>& atlased,
-                           const SkTDArray<GrCachedLayer*>& nonAtlased,
+    static void DrawLayers(const SkTDArray<HoistingInfo>& atlased,
+                           const SkTDArray<HoistingInfo>& nonAtlased,
                            GrReplacements* replacements);
 
-    /** Unlock all the layers associated with picture in the layer cache.
+    /** Unlock unneeded layers in the layer cache.
         @param layerCache holder of the locked layers
-        @pmara picture    the source of the locked layers
+        @param atlased    Unneeded layers in the atlas
+        @param nonAtlased Unneeded layers in their own textures
     */
-    static void UnlockLayers(GrLayerCache* layerCache, const SkPicture* picture);
+    static void UnlockLayers(GrLayerCache* layerCache,
+                             const SkTDArray<HoistingInfo>& atlased,
+                             const SkTDArray<HoistingInfo>& nonAtlased);
 };
 
 #endif