Moving 4 SkImageFilter derived classes from blink to skia

src/effects/SkOffsetImageFilter.cpp

 /*
  * Copyright 2012 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 "SkOffsetImageFilter.h"
 #include "SkBitmap.h"
+#include "SkCanvas.h"
+#include "SkDevice.h"
+#include "SkFlattenableBuffers.h"
 #include "SkMatrix.h"
-#include "SkFlattenableBuffers.h"
+#include "SkPaint.h"
 
 bool SkOffsetImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source,
                                         const SkMatrix& matrix,
                                         SkBitmap* result,
                                         SkIPoint* loc) {
+    SkImageFilter* input = getInput(0);
     SkBitmap src = source;
-    if (getInput(0) && !getInput(0)->filterImage(proxy, source, matrix, &src, loc)) {
-        return false;
+    if (cropRect().isLargest()) {
+        if (input && !input->filterImage(proxy, source, matrix, &src, loc)) {
+            return false;
+        }
+
+        SkVector vec;
+        matrix.mapVectors(&vec, &fOffset, 1);
+
+        loc->fX += SkScalarRoundToInt(vec.fX);
+        loc->fY += SkScalarRoundToInt(vec.fY);
+        *result = src;
+    } else {
+        SkIPoint srcOffset = SkIPoint::Make(0, 0);

[sugoi1, 2013/09/23 18:37:30]

@senorblanco : Was there a reason here why we aren't using "loc" directly and
provide a (0,0) point instead ?

[Stephen White, 2013/09/24 01:13:19]

Since this path draws its input into a buffer, it's applying the upstream offset
at draw time. We don't want to return it via the outparam, since that would
cause it to be applied twice. Note that other compositing filters (e.g.,
SkXfermodeImageFilter, SkMergeImageFilter) do the same.

[sugoi1, 2013/09/24 11:39:50]

Thanks for the explanation, I wanted to make sure this was desired and not
something on a TODO list :)

+        if (input && !input->filterImage(proxy, source, matrix, &src, &srcOffset)) {
+            return false;
+        }
+
+        SkIRect bounds;
+        src.getBounds(&bounds);
+
+        if (!applyCropRect(&bounds, matrix)) {
+            return false;
+        }
+
+        SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
+        SkCanvas canvas(device);
+        SkPaint paint;
+        paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+        canvas.drawBitmap(src, fOffset.fX - bounds.left(), fOffset.fY - bounds.top(), &paint);
+        *result = device->accessBitmap(false);
+        loc->fX += bounds.left();
+        loc->fY += bounds.top();
     }
-
-    SkVector vec;
-    matrix.mapVectors(&vec, &fOffset, 1);
-
-    loc->fX += SkScalarRoundToInt(vec.fX);
-    loc->fY += SkScalarRoundToInt(vec.fY);
-    *result = src;
     return true;
 }
 
 bool SkOffsetImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
                                          SkIRect* dst) {
     SkVector vec;
     ctm.mapVectors(&vec, &fOffset, 1);
 
     *dst = src;
     dst->offset(SkScalarRoundToInt(vec.fX), SkScalarRoundToInt(vec.fY));
     return true;
 }
 
 void SkOffsetImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writePoint(fOffset);
 }
 
-SkOffsetImageFilter::SkOffsetImageFilter(SkScalar dx, SkScalar dy,
-                                         SkImageFilter* input) : INHERITED(input) {
+SkOffsetImageFilter::SkOffsetImageFilter(SkScalar dx, SkScalar dy, SkImageFilter* input,
+                                         const SkIRect* cropRect) : INHERITED(input, cropRect) {
     fOffset.set(dx, dy);
 }
 
 SkOffsetImageFilter::SkOffsetImageFilter(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
     buffer.readPoint(&fOffset);
 }