Revert[2] of "add backdrop option to SaveLayerRec"

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 "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 96 matching lines @@
 static bool gTreatSpriteAsBitmap;
 void SkCanvas::Internal_Private_SetTreatSpriteAsBitmap(bool spriteAsBitmap) {
     gTreatSpriteAsBitmap = spriteAsBitmap;
 }
 bool SkCanvas::Internal_Private_GetTreatSpriteAsBitmap() {
     return gTreatSpriteAsBitmap;
 }
 
 // experimental for faster tiled drawing...
 //#define SK_ENABLE_CLIP_QUICKREJECT
-
 //#define SK_TRACE_SAVERESTORE
 
 #ifdef SK_TRACE_SAVERESTORE
     static int gLayerCounter;
     static void inc_layer() { ++gLayerCounter; printf("----- inc layer %d\n", gLayerCounter); }
     static void dec_layer() { --gLayerCounter; printf("----- dec layer %d\n", gLayerCounter); }
 
     static int gRecCounter;
     static void inc_rec() { ++gRecCounter; printf("----- inc rec %d\n", gRecCounter); }
     static void dec_rec() { --gRecCounter; printf("----- dec rec %d\n", gRecCounter); }
@@ skipping 346 matching lines @@
              *      draw onto the previous layer using the xfermode from the original paint.
              */
             SkPaint tmp;
             tmp.setImageFilter(fPaint->getImageFilter());
             tmp.setXfermode(fPaint->getXfermode());
             SkRect storage;
             if (rawBounds) {
                 // Make rawBounds include all paint outsets except for those due to image filters.
                 rawBounds = &apply_paint_to_bounds_sans_imagefilter(*fPaint, *rawBounds, &storage);
             }
-            (void)canvas->internalSaveLayer(SkCanvas::SaveLayerRec(rawBounds, &tmp, 0),
+            (void)canvas->internalSaveLayer(SkCanvas::SaveLayerRec(rawBounds, &tmp),
                                             SkCanvas::kFullLayer_SaveLayerStrategy);
             fTempLayerForImageFilter = true;
             // we remove the imagefilter/xfermode inside doNext()
         }
 
         if (SkDrawLooper* looper = paint.getLooper()) {
             void* buffer = fLooperContextAllocator.reserveT<SkDrawLooper::Context>(
                     looper->contextSize());
             fLooperContext = looper->createContext(canvas, buffer);
             fIsSimple = false;
@@ skipping 671 matching lines @@
     SaveLayerRec rec(origRec);
     if (gIgnoreSaveLayerBounds) {
         rec.fBounds = nullptr;
     }
     SaveLayerStrategy strategy = this->getSaveLayerStrategy(rec);
     fSaveCount += 1;
     this->internalSaveLayer(rec, strategy);
     return this->getSaveCount() - 1;
 }
 
-static void draw_filter_into_device(SkBaseDevice* src, SkImageFilter* filter, SkBaseDevice* dst) {
+static void draw_filter_into_device(SkBaseDevice* src, const SkImageFilter* filter,
+                                    SkBaseDevice* dst, const SkMatrix& ctm) {
 
     SkBitmap srcBM;
 
 #if SK_SUPPORT_GPU
     GrRenderTarget* srcRT = src->accessRenderTarget();
     if (srcRT && !srcRT->asTexture() && dst->accessRenderTarget()) {
         // When both the src & the dst are on the gpu but the src doesn't have a texture,
         // we create a temporary texture for the draw.
         // TODO: we should actually only copy the portion of the source needed to apply the image
         // filter
         GrContext* context = srcRT->getContext();
         SkAutoTUnref<GrTexture> tex(context->textureProvider()->createTexture(srcRT->desc(), true));
 
         context->copySurface(tex, srcRT);
 
         GrWrapTextureInBitmap(tex, src->width(), src->height(), src->isOpaque(), &srcBM);
     } else
 #endif
     {
         srcBM = src->accessBitmap(false);
     }
 
     SkCanvas c(dst);
 
+    SkAutoTUnref<SkImageFilter> localF(filter->newWithLocalMatrix(ctm));
     SkPaint p;
-    p.setImageFilter(filter);
-    c.drawBitmap(srcBM, 0, 0, &p);
+    p.setImageFilter(localF);
+    const SkScalar x = SkIntToScalar(src->getOrigin().x());
+    const SkScalar y = SkIntToScalar(src->getOrigin().y());
+    c.drawBitmap(srcBM, x, y, &p);
 }
 
 void SkCanvas::internalSaveLayer(const SaveLayerRec& rec, SaveLayerStrategy strategy) {
     const SkRect* bounds = rec.fBounds;
     const SkPaint* paint = rec.fPaint;
     SaveLayerFlags saveLayerFlags = rec.fSaveLayerFlags;
 
 #ifndef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     saveLayerFlags &= ~kDontClipToLayer_PrivateSaveLayerFlag;
 #endif
@@ skipping 47 matching lines @@
             newDev = SkBitmapDevice::Create(createInfo.fInfo, surfaceProps);
             if (nullptr == newDev) {
                 SkErrorInternals::SetError(kInternalError_SkError,
                                            "Unable to create device for layer.");
                 return;
             }
             forceSpriteOnRestore = true;
         }
         device = newDev;
     }
-
     device->setOrigin(ir.fLeft, ir.fTop);
 
-    if (0) {
-        draw_filter_into_device(fMCRec->fTopLayer->fDevice, nullptr, device);
+    if (rec.fBackdrop) {
+        draw_filter_into_device(fMCRec->fTopLayer->fDevice, rec.fBackdrop, device, fMCRec->fMatrix);
     }
 
     DeviceCM* layer =
             new DeviceCM(device, paint, this, fConservativeRasterClip, forceSpriteOnRestore);
     device->unref();
 
     layer->fNext = fMCRec->fTopLayer;
     fMCRec->fLayer = layer;
     fMCRec->fTopLayer = layer;    // this field is NOT an owner of layer
 }
@@ skipping 1735 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }