Revert of Revert of Revert of Revert of Revert of Change device creation to see the (optional) layer-paint

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
 #include "SkBitmapDevice.h"
@@ skipping 281 matching lines @@
         fFilter = canvas->getDrawFilter();
         fPaint = &fOrigPaint;
         fSaveCount = canvas->getSaveCount();
         fDoClearImageFilter = false;
         fDone = false;
 
         if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
             SkPaint tmp;
             tmp.setImageFilter(fOrigPaint.getImageFilter());
             (void)canvas->internalSaveLayer(bounds, &tmp, SkCanvas::kARGB_ClipLayer_SaveFlag,
-                                            SkCanvas::kFullLayer_SaveLayerStrategy);
+                                            true, SkCanvas::kFullLayer_SaveLayerStrategy);
             // we'll clear the imageFilter for the actual draws in next(), so
             // it will only be applied during the restore().
             fDoClearImageFilter = true;
         }
 
         if (SkDrawLooper* looper = paint.getLooper()) {
             void* buffer = fLooperContextAllocator.reserveT<SkDrawLooper::Context>(
                     looper->contextSize());
             fLooperContext = looper->createContext(canvas, buffer);
             fIsSimple = false;
@@ skipping 560 matching lines @@
     }
     return true;
 }
 
 int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint) {
     if (gIgnoreSaveLayerBounds) {
         bounds = NULL;
     }
     SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, kARGB_ClipLayer_SaveFlag);
     fSaveCount += 1;
-    this->internalSaveLayer(bounds, paint, kARGB_ClipLayer_SaveFlag, strategy);
+    this->internalSaveLayer(bounds, paint, kARGB_ClipLayer_SaveFlag, false, strategy);
     return this->getSaveCount() - 1;
 }
 
 int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags) {
     if (gIgnoreSaveLayerBounds) {
         bounds = NULL;
     }
     SaveLayerStrategy strategy = this->willSaveLayer(bounds, paint, flags);
     fSaveCount += 1;
-    this->internalSaveLayer(bounds, paint, flags, strategy);
+    this->internalSaveLayer(bounds, paint, flags, false, strategy);
     return this->getSaveCount() - 1;
 }
 
 void SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint, SaveFlags flags,
-                                 SaveLayerStrategy strategy) {
+                                bool justForImageFilter, SaveLayerStrategy strategy) {
 #ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     flags |= kClipToLayer_SaveFlag;
 #endif
 
     // do this before we create the layer. We don't call the public save() since
     // that would invoke a possibly overridden virtual
     this->internalSave();
 
     fDeviceCMDirty = true;
 
     SkIRect ir;
     if (!this->clipRectBounds(bounds, flags, &ir, paint ? paint->getImageFilter() : NULL)) {
         return;
     }
 
     // FIXME: do willSaveLayer() overriders returning kNoLayer_SaveLayerStrategy really care about
     // the clipRectBounds() call above?
     if (kNoLayer_SaveLayerStrategy == strategy) {
         return;
     }
 
-    bool isOpaque = !SkToBool(flags & kHasAlphaLayer_SaveFlag);
-    if (isOpaque && paint) {
-        // TODO: perhaps add a query to filters so we might preserve opaqueness...
-        if (paint->getImageFilter() || paint->getColorFilter()) {
-            isOpaque = false;
+    // Kill the imagefilter if our device doesn't allow it
+    SkLazyPaint lazyP;
+    if (paint && paint->getImageFilter()) {
+        if (!this->getTopDevice()->allowImageFilter(paint->getImageFilter())) {
+            if (justForImageFilter) {
+                // early exit if the layer was just for the imageFilter
+                return;
+            }
+            SkPaint* p = lazyP.set(*paint);
+            p->setImageFilter(NULL);
+            paint = p;
         }
     }
+
+    bool isOpaque = !SkToBool(flags & kHasAlphaLayer_SaveFlag);
     SkImageInfo info = SkImageInfo::MakeN32(ir.width(), ir.height(),
                         isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 
     SkBaseDevice* device = this->getTopDevice();
     if (NULL == device) {
         SkDebugf("Unable to find device for layer.");
         return;
     }
 
-    SkBaseDevice::TileUsage usage = SkBaseDevice::kNever_TileUsage;
-#if 1
-    // this seems needed for current GMs, but makes us draw slower on the GPU
-    // Related to https://code.google.com/p/skia/issues/detail?id=3519 ?
-    //
+    SkBaseDevice::Usage usage = SkBaseDevice::kSaveLayer_Usage;
     if (paint && paint->getImageFilter()) {
-        usage = SkBaseDevice::kPossible_TileUsage;
+        usage = SkBaseDevice::kImageFilter_Usage;
     }
-#endif
-    device = device->onCreateDevice(SkBaseDevice::CreateInfo(info, usage, fProps.pixelGeometry()),
-                                    paint);
+    device = device->onCreateCompatibleDevice(SkBaseDevice::CreateInfo(info, usage,
+                                                                       fProps.pixelGeometry()));
     if (NULL == device) {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "Unable to create device for layer.");
         return;
     }
 
     device->setOrigin(ir.fLeft, ir.fTop);
     DeviceCM* layer = SkNEW_ARGS(DeviceCM, (device, paint, this, fConservativeRasterClip));
     device->unref();
 
@@ skipping 1562 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }