Address MSAA rendering in layer hoisting

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 "GrRecordReplaceDraw.h"
 
 #include "SkCanvas.h"
 #include "SkGrPixelRef.h"
 #include "SkRecordDraw.h"
 #include "SkSurface.h"
 
 // Create the layer information for the hoisted layer and secure the
 // required texture/render target resources.
 static void prepare_for_hoisting(GrLayerCache* layerCache, 
                                  const SkPicture* topLevelPicture,
                                  const GrAccelData::SaveLayerInfo& info,
                                  const SkIRect& layerRect,
                                  SkTDArray<GrHoistedLayer>* needRendering,
                                  SkTDArray<GrHoistedLayer>* recycled,
-                                 bool attemptToAtlas) {
+                                 bool attemptToAtlas,
+                                 int numSamples) {
     const SkPicture* pict = info.fPicture ? info.fPicture : topLevelPicture;
 
     SkMatrix combined = SkMatrix::Concat(info.fPreMat, info.fLocalMat);
 
     GrCachedLayer* layer = layerCache->findLayerOrCreate(pict->uniqueID(),
                                                          info.fSaveLayerOpID,
                                                          info.fRestoreOpID,
                                                          layerRect,
                                                          combined,
                                                          info.fPaint);
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = layerRect.width();
     desc.fHeight = layerRect.height();
     desc.fConfig = kSkia8888_GrPixelConfig;
-    // TODO: need to deal with sample count
+    desc.fSampleCnt = numSamples;
 
     bool locked, needsRendering;
     if (attemptToAtlas) {
         locked = layerCache->tryToAtlas(layer, desc, &needsRendering);
     } else {
         locked = layerCache->lock(layer, desc, &needsRendering);
     }
     if (!locked) {
         // GPU resources could not be secured for the hoisting of this layer
         return;
@@ skipping 22 matching lines @@
     hl->fPreMat = info.fPreMat;
 }
 
 // Atlased layers must be small enough to fit in the atlas, not have a
 // paint with an image filter and be neither nested nor nesting.
 // TODO: allow leaf nested layers to appear in the atlas.
 void GrLayerHoister::FindLayersToAtlas(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* atlased,
-                                       SkTDArray<GrHoistedLayer>* recycled) {
+                                       SkTDArray<GrHoistedLayer>* recycled,
+                                       int numSamples) {
+    if (0 != numSamples) {
+        // MSAA layers are currently never atlased
+        return;
+    }
+
     GrLayerCache* layerCache = context->getLayerCache();
 
     layerCache->processDeletedPictures();
 
     SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key);
     if (!topLevelData) {
         return;
     }
@@ skipping 21 matching lines @@
             continue;
         }
 
         SkIRect ir;
         layerRect.roundOut(&ir);
 
         if (!GrLayerCache::PlausiblyAtlasable(ir.width(), ir.height())) {
             continue;
         }
 
-        prepare_for_hoisting(layerCache, topLevelPicture, info, ir, atlased, recycled, true);
+        prepare_for_hoisting(layerCache, topLevelPicture, info, ir, atlased, recycled, true, 0);
     }
 
 }
 
 void GrLayerHoister::FindLayersToHoist(GrContext* context,
                                        const SkPicture* topLevelPicture,
                                        const SkRect& query,
                                        SkTDArray<GrHoistedLayer>* needRendering,
-                                       SkTDArray<GrHoistedLayer>* recycled) {
+                                       SkTDArray<GrHoistedLayer>* recycled,
+                                       int numSamples) {
     GrLayerCache* layerCache = context->getLayerCache();
 
     layerCache->processDeletedPictures();
 
     SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
 
     const SkPicture::AccelData* topLevelData = topLevelPicture->EXPERIMENTAL_getAccelData(key);
     if (!topLevelData) {
         return;
     }
@@ skipping 13 matching lines @@
 
         SkRect layerRect = info.fBounds;
         if (!layerRect.intersect(query)) {
             continue;
         }
 
         SkIRect ir;
         layerRect.roundOut(&ir);
 
         prepare_for_hoisting(layerCache, topLevelPicture, info, ir, 
-                             needRendering, recycled, false);
+                             needRendering, recycled, false, numSamples);
     }
 }
 
 static void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
 }
 
 void GrLayerHoister::ConvertLayersToReplacements(const SkTDArray<GrHoistedLayer>& layers,
@@ skipping 140 matching lines @@
 void GrLayerHoister::PurgeCache(GrContext* context) {
 #if !GR_CACHE_HOISTED_LAYERS
     GrLayerCache* layerCache = context->getLayerCache();
 
     // 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->purgeAll();
 #endif
 }