Make CropRect immutable after construction.

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"
@@ skipping 43 matching lines @@
 
 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;
         }
     }
-    buffer.readRect(&fCropRect.fRect);
-    fCropRect.fFlags = buffer.readUInt();
+    SkRect rect;
+    buffer.readRect(&rect);
+    uint32_t flags = buffer.readUInt();
+    fCropRect = CropRect(rect, flags);
 }
 
 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);
         }
     }
-    buffer.writeRect(fCropRect.fRect);
-    buffer.writeUInt(fCropRect.fFlags);
+    buffer.writeRect(fCropRect.rect());
+    buffer.writeUInt(fCropRect.flags());
 }
 
 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;
-    matrix.mapRect(&cropRect, fCropRect.fRect);
+    matrix.mapRect(&cropRect, fCropRect.rect());
     SkIRect cropRectI;
     cropRect.roundOut(&cropRectI);
+    uint32_t flags = fCropRect.flags();
     // 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;
+    if (!(flags & CropRect::kHasLeft_CropEdge)) cropRectI.fLeft = SK_MinS32;
+    if (!(flags & CropRect::kHasTop_CropEdge)) cropRectI.fTop = SK_MinS32;
+    if (!(flags & CropRect::kHasRight_CropEdge)) cropRectI.fRight = SK_MaxS32;
+    if (!(flags & CropRect::kHasBottom_CropEdge)) cropRectI.fBottom = SK_MaxS32;
     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;
 }