Remove support for SK_CROP_RECT_IS_INT, now that it is no longer used in Blink or Chrome.

src/core/SkImageFilter.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 "SkImageFilter.h"
 
 #include "SkBitmap.h"
 #include "SkFlattenableBuffers.h"
 #include "SkRect.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrTexture.h"
 #include "SkImageFilterUtils.h"
 #endif
 
 SK_DEFINE_INST_COUNT(SkImageFilter)
 
 SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect)
   : fInputCount(inputCount),
     fInputs(new SkImageFilter*[inputCount]),
-#ifdef SK_CROP_RECT_IS_INT
-    fCropRect(cropRect ? *cropRect : SkIRect::MakeLargest()) {
-#else
     fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
-#endif
     for (int i = 0; i < inputCount; ++i) {
         fInputs[i] = inputs[i];
         SkSafeRef(fInputs[i]);
     }
 }
 
 SkImageFilter::SkImageFilter(SkImageFilter* input, const CropRect* cropRect)
   : fInputCount(1),
     fInputs(new SkImageFilter*[1]),
-#ifdef SK_CROP_RECT_IS_INT
-    fCropRect(cropRect ? *cropRect : SkIRect::MakeLargest()) {
-#else
     fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
-#endif
     fInputs[0] = input;
     SkSafeRef(fInputs[0]);
 }
 
 SkImageFilter::SkImageFilter(SkImageFilter* input1, SkImageFilter* input2, const CropRect* cropRect)
   : fInputCount(2), fInputs(new SkImageFilter*[2]),
-#ifdef SK_CROP_RECT_IS_INT
-    fCropRect(cropRect ? *cropRect : SkIRect::MakeLargest()) {
-#else
     fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
-#endif
     fInputs[0] = input1;
     fInputs[1] = input2;
     SkSafeRef(fInputs[0]);
     SkSafeRef(fInputs[1]);
 }
 
 SkImageFilter::~SkImageFilter() {
     for (int i = 0; i < fInputCount; i++) {
         SkSafeUnref(fInputs[i]);
     }
     delete[] fInputs;
 }
 
 SkImageFilter::SkImageFilter(SkFlattenableReadBuffer& buffer)
     : fInputCount(buffer.readInt()), fInputs(new SkImageFilter*[fInputCount]) {
     for (int i = 0; i < fInputCount; i++) {
         if (buffer.readBool()) {
             fInputs[i] = buffer.readImageFilter();
         } else {
             fInputs[i] = NULL;
         }
     }
-#ifdef SK_CROP_RECT_IS_INT
-    buffer.readIRect(&fCropRect);
-#else
     buffer.readRect(&fCropRect.fRect);
     fCropRect.fFlags = buffer.readUInt();
-#endif
 }
 
 void SkImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
     buffer.writeInt(fInputCount);
     for (int i = 0; i < fInputCount; i++) {
         SkImageFilter* input = getInput(i);
         buffer.writeBool(input != NULL);
         if (input != NULL) {
             buffer.writeFlattenable(input);
         }
     }
-#ifdef SK_CROP_RECT_IS_INT
-    buffer.writeIRect(fCropRect);
-#else
     buffer.writeRect(fCropRect.fRect);
     buffer.writeUInt(fCropRect.fFlags);
-#endif
 }
 
 bool SkImageFilter::filterImage(Proxy* proxy, const SkBitmap& src,
                                 const SkMatrix& ctm,
                                 SkBitmap* result, SkIPoint* loc) {
     SkASSERT(result);
     SkASSERT(loc);
     /*
      *  Give the proxy first shot at the filter. If it returns false, ask
      *  the filter to do it.
@@ skipping 62 matching lines @@
     offset->fX += bounds.left();
     offset->fY += bounds.top();
     return true;
 #else
     return false;
 #endif
 }
 
 bool SkImageFilter::applyCropRect(SkIRect* rect, const SkMatrix& matrix) const {
     SkRect cropRect;
-#ifdef SK_CROP_RECT_IS_INT
-    matrix.mapRect(&cropRect, SkRect::Make(fCropRect));
-    SkIRect cropRectI;
-    cropRect.roundOut(&cropRectI);
-    // If the original crop rect edges were unset, max out the new crop edges
-    if (fCropRect.fLeft == SK_MinS32) cropRectI.fLeft = SK_MinS32;
-    if (fCropRect.fTop == SK_MinS32) cropRectI.fTop = SK_MinS32;
-    if (fCropRect.fRight == SK_MaxS32) cropRectI.fRight = SK_MaxS32;
-    if (fCropRect.fBottom == SK_MaxS32) cropRectI.fBottom = SK_MaxS32;
-#else
     matrix.mapRect(&cropRect, fCropRect.fRect);
     SkIRect cropRectI;
     cropRect.roundOut(&cropRectI);
     // If the original crop rect edges were unset, max out the new crop edges
     if (!(fCropRect.fFlags & CropRect::kHasLeft_CropEdge)) cropRectI.fLeft = SK_MinS32;
     if (!(fCropRect.fFlags & CropRect::kHasTop_CropEdge)) cropRectI.fTop = SK_MinS32;
     if (!(fCropRect.fFlags & CropRect::kHasRight_CropEdge)) cropRectI.fRight = SK_MaxS32;
     if (!(fCropRect.fFlags & CropRect::kHasBottom_CropEdge)) cropRectI.fBottom = SK_MaxS32;
-#endif
     return rect->intersect(cropRectI);
 }
 
 bool SkImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
                                    SkIRect* dst) {
     *dst = src;
     return true;
 }
 
 bool SkImageFilter::asNewEffect(GrEffectRef**, GrTexture*, const SkMatrix&) const {
     return false;
 }
 
 bool SkImageFilter::asColorFilter(SkColorFilter**) const {
     return false;
 }