Address MSAA rendering in layer hoisting

src/core/SkMultiPictureDraw.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.
  */
 
 // Need to include something before #if SK_SUPPORT_GPU so that the Android
 // framework build, which gets its defines from SkTypes rather than a makefile,
 // has the definition before checking it.
 #include "SkCanvas.h"
 #include "SkMultiPictureDraw.h"
 #include "SkPicture.h"
 #include "SkTaskGroup.h"
 
 #if SK_SUPPORT_GPU
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
+#include "GrRenderTarget.h"
 #endif
 
 void SkMultiPictureDraw::DrawData::draw() {
     fCanvas->drawPicture(fPicture, &fMatrix, fPaint);
 }
 
 void SkMultiPictureDraw::DrawData::init(SkCanvas* canvas, const SkPicture* picture,
                                         const SkMatrix* matrix, const SkPaint* paint) {
     fPicture = SkRef(picture);
     fCanvas = SkRef(canvas);
@@ skipping 84 matching lines @@
         if (!data.fPaint && data.fMatrix.isIdentity()) {
             // TODO: this path always tries to optimize pictures. Should we
             // switch to this API approach (vs. SkCanvas::EXPERIMENTAL_optimize)?
             data.fCanvas->EXPERIMENTAL_optimize(data.fPicture);
 
             SkRect clipBounds;
             if (!data.fCanvas->getClipBounds(&clipBounds)) {
                 continue;
             }
 
+            GrRenderTarget* rt = data.fCanvas->internal_private_accessTopLayerRenderTarget();
+            SkASSERT(rt);
+
             // TODO: sorting the cacheable layers from smallest to largest
             // would improve the packing and reduce the number of swaps
             // TODO: another optimization would be to make a first pass to
             // lock any required layer that is already in the atlas
             GrLayerHoister::FindLayersToAtlas(context, data.fPicture,
                                               clipBounds,
-                                              &atlasedNeedRendering, &atlasedRecycled);
+                                              &atlasedNeedRendering, &atlasedRecycled,
+                                              rt->numSamples());
         }
     }
 
     GrLayerHoister::DrawLayersToAtlas(context, atlasedNeedRendering);
 
     SkTDArray<GrHoistedLayer> needRendering, recycled;
 #endif
 
     for (int i = 0; i < count; ++i) {
         const DrawData& data = fGPUDrawData[i];
         SkCanvas* canvas = data.fCanvas;
         const SkPicture* picture = data.fPicture;
 
 #if !defined(SK_IGNORE_GPU_LAYER_HOISTING) && SK_SUPPORT_GPU
         if (!data.fPaint && data.fMatrix.isIdentity()) {
 
             SkRect clipBounds;
             if (!canvas->getClipBounds(&clipBounds)) {
                 continue;
             }
 
+            GrRenderTarget* rt = data.fCanvas->internal_private_accessTopLayerRenderTarget();
+            SkASSERT(rt);
+
             // Find the layers required by this canvas. It will return atlased
             // layers in the 'recycled' list since they have already been drawn.
             GrLayerHoister::FindLayersToHoist(context, picture,
-                                              clipBounds, &needRendering, &recycled);
+                                              clipBounds, &needRendering, &recycled,
+                                              rt->numSamples());
 
             GrLayerHoister::DrawLayers(context, needRendering);
 
             GrReplacements replacements;
 
             GrLayerHoister::ConvertLayersToReplacements(needRendering, &replacements);
             GrLayerHoister::ConvertLayersToReplacements(recycled, &replacements);
 
             const SkMatrix initialMatrix = canvas->getTotalMatrix();
 
@@ skipping 14 matching lines @@
 
 #if !defined(SK_IGNORE_GPU_LAYER_HOISTING) && SK_SUPPORT_GPU
     GrLayerHoister::UnlockLayers(context, atlasedNeedRendering);
     GrLayerHoister::UnlockLayers(context, atlasedRecycled);
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerHoister::PurgeCache(context);
 #endif
 #endif
 }