Revert "replace SkXfermode obj with SkBlendMode enum in paints"

[platform/upstream/libSkiaSharp.git] / src / core / SkMatrixImageFilter.cpp

diff --git a/src/core/SkMatrixImageFilter.cpp b/src/core/SkMatrixImageFilter.cpp
index 4370dda..12efc64 100644 (file)
--- a/src/core/SkMatrixImageFilter.cpp
+++ b/src/core/SkMatrixImageFilter.cpp
@@ -6,35 +6,36 @@
  */
 
 #include "SkMatrixImageFilter.h"
-#include "SkBitmap.h"
+
 #include "SkCanvas.h"
-#include "SkDevice.h"
-#include "SkColorPriv.h"
 #include "SkReadBuffer.h"
+#include "SkSpecialImage.h"
+#include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
-#include "SkMatrix.h"
 #include "SkRect.h"
 
 SkMatrixImageFilter::SkMatrixImageFilter(const SkMatrix& transform,
                                          SkFilterQuality filterQuality,
-                                         SkImageFilter* input)
-  : INHERITED(1, &input),
-    fTransform(transform),
-    fFilterQuality(filterQuality) {
+                                         sk_sp<SkImageFilter> input)
+    : INHERITED(&input, 1, nullptr)
+    , fTransform(transform)
+    , fFilterQuality(filterQuality) {
 }
 
-SkMatrixImageFilter* SkMatrixImageFilter::Create(const SkMatrix& transform,
-                                                 SkFilterQuality filterQuality,
-                                                 SkImageFilter* input) {
-    return new SkMatrixImageFilter(transform, filterQuality, input);
+sk_sp<SkImageFilter> SkMatrixImageFilter::Make(const SkMatrix& transform,
+                                               SkFilterQuality filterQuality,
+                                               sk_sp<SkImageFilter> input) {
+    return sk_sp<SkImageFilter>(new SkMatrixImageFilter(transform,
+                                                        filterQuality,
+                                                        std::move(input)));
 }
 
-SkFlattenable* SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
+sk_sp<SkFlattenable> SkMatrixImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkMatrix matrix;
     buffer.readMatrix(&matrix);
     SkFilterQuality quality = static_cast<SkFilterQuality>(buffer.readInt());
-    return Create(matrix, quality, common.getInput(0));
+    return Make(matrix, quality, common.getInput(0));
 }
 
 void SkMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
@@ -43,84 +44,83 @@ void SkMatrixImageFilter::flatten(SkWriteBuffer& buffer) const {
     buffer.writeInt(fFilterQuality);
 }
 
-SkMatrixImageFilter::~SkMatrixImageFilter() {
-}
+sk_sp<SkSpecialImage> SkMatrixImageFilter::onFilterImage(SkSpecialImage* source,
+                                                         const Context& ctx,
+                                                         SkIPoint* offset) const {
 
-bool SkMatrixImageFilter::onFilterImage(Proxy* proxy,
-                                        const SkBitmap& source,
-                                        const Context& ctx,
-                                        SkBitmap* result,
-                                        SkIPoint* offset) const {
-    SkBitmap src = source;
-    SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (!this->filterInput(0, proxy, source, ctx, &src, &srcOffset)) {
-        return false;
+    SkIPoint inputOffset = SkIPoint::Make(0, 0);
+    sk_sp<SkSpecialImage> input(this->filterInput(0, source, ctx, &inputOffset));
+    if (!input) {
+        return nullptr;
     }
 
-    SkRect dstRect;
-    SkIRect srcBounds, dstBounds;
-    src.getBounds(&srcBounds);
-    srcBounds.offset(srcOffset);
-    SkRect srcRect = SkRect::Make(srcBounds);
     SkMatrix matrix;
     if (!ctx.ctm().invert(&matrix)) {
-        return false;
+        return nullptr;
     }
     matrix.postConcat(fTransform);
     matrix.postConcat(ctx.ctm());
+
+    const SkIRect srcBounds = SkIRect::MakeXYWH(inputOffset.x(), inputOffset.y(),
+                                                input->width(), input->height());
+    const SkRect srcRect = SkRect::Make(srcBounds);
+
+    SkRect dstRect;
     matrix.mapRect(&dstRect, srcRect);
+    SkIRect dstBounds;
     dstRect.roundOut(&dstBounds);
 
-    SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(dstBounds.width(), dstBounds.height()));
-    if (nullptr == device.get()) {
-        return false;
+    sk_sp<SkSpecialSurface> surf(input->makeSurface(ctx.outputProperties(), dstBounds.size()));
+    if (!surf) {
+        return nullptr;
     }
 
-    SkCanvas canvas(device.get());
-    canvas.translate(-SkIntToScalar(dstBounds.x()), -SkIntToScalar(dstBounds.y()));
-    canvas.concat(matrix);
-    SkPaint paint;
+    SkCanvas* canvas = surf->getCanvas();
+    SkASSERT(canvas);
+
+    canvas->clear(0x0);
 
+    canvas->translate(-SkIntToScalar(dstBounds.x()), -SkIntToScalar(dstBounds.y()));
+    canvas->concat(matrix);
+
+    SkPaint paint;
+    paint.setAntiAlias(true);
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     paint.setFilterQuality(fFilterQuality);
-    canvas.drawBitmap(src, srcRect.x(), srcRect.y(), &paint);
 
-    *result = device.get()->accessBitmap(false);
+    input->draw(canvas, srcRect.x(), srcRect.y(), &paint);
+
     offset->fX = dstBounds.fLeft;
     offset->fY = dstBounds.fTop;
-    return true;
+    return surf->makeImageSnapshot();
 }
 
-void SkMatrixImageFilter::computeFastBounds(const SkRect& src, SkRect* dst) const {
-    SkRect bounds = src;
-    if (getInput(0)) {
-        getInput(0)->computeFastBounds(src, &bounds);
-    }
-    fTransform.mapRect(dst, bounds);
-    dst->join(bounds);   // Work around for skia:3194
+SkRect SkMatrixImageFilter::computeFastBounds(const SkRect& src) const {
+    SkRect bounds = this->getInput(0) ? this->getInput(0)->computeFastBounds(src) : src;
+    SkRect dst;
+    fTransform.mapRect(&dst, bounds);
+    return dst;
 }
 
-bool SkMatrixImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
-                                         SkIRect* dst) const {
-    SkMatrix transformInverse;
-    if (!fTransform.invert(&transformInverse)) {
-        return false;
-    }
+SkIRect SkMatrixImageFilter::onFilterNodeBounds(const SkIRect& src, const SkMatrix& ctm,
+                                                MapDirection direction) const {
     SkMatrix matrix;
     if (!ctm.invert(&matrix)) {
-        return false;
+        return src;
+    }
+    if (kForward_MapDirection == direction) {
+        matrix.postConcat(fTransform);
+    } else {
+        SkMatrix transformInverse;
+        if (!fTransform.invert(&transformInverse)) {
+            return src;
+        }
+        matrix.postConcat(transformInverse);
     }
-    matrix.postConcat(transformInverse);
     matrix.postConcat(ctm);
     SkRect floatBounds;
     matrix.mapRect(&floatBounds, SkRect::Make(src));
-    SkIRect bounds = floatBounds.roundOut();
-    if (getInput(0) && !getInput(0)->filterBounds(bounds, ctm, &bounds)) {
-        return false;
-    }
-
-    *dst = bounds;
-    return true;
+    return floatBounds.roundOut();
 }
 
 #ifndef SK_IGNORE_TO_STRING