Image filters: optimize crop rect application

include/core/SkImageFilter.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageFilter_DEFINED
 #define SkImageFilter_DEFINED
 
@@ skipping 70 matching lines @@
         explicit CropRect(const SkRect& rect, uint32_t flags = kHasAll_CropEdge)
             : fRect(rect), fFlags(flags) {}
         uint32_t flags() const { return fFlags; }
         const SkRect& rect() const { return fRect; }
 #ifndef SK_IGNORE_TO_STRING
         void toString(SkString* str) const;
 #endif
 
         /**
          *  Apply this cropRect to the imageBounds. If a given edge of the cropRect is not
-         *  set, then the corresponding edge from imageBounds will be used.
+         *  set, then the corresponding edge from imageBounds will be used. If "embiggen"
+         *  is true, the crop rect is allowed to enlarge the size of the rect, otherwise
+         *  it may only reduce the rect. Filters that can affect transparent black should 
+         *  pass "true", while all other filters should pass "false".
          *
          *  Note: imageBounds is in "device" space, as the output cropped rectangle will be,
          *  so the matrix is ignored for those. It is only applied the croprect's bounds.
          */
-        void applyTo(const SkIRect& imageBounds, const SkMatrix&, SkIRect* cropped) const;
+        void applyTo(const SkIRect& imageBounds, const SkMatrix&, bool embiggen,
+                     SkIRect* cropped) const;
 
     private:
         SkRect fRect;
         uint32_t fFlags;
     };
 
     enum TileUsage {
         kPossible_TileUsage,    //!< the created device may be drawn tiled
         kNever_TileUsage,       //!< the created device will never be drawn tiled
     };
@@ skipping 135 matching lines @@
      *  drawn in the correct location.)
      */
     bool cropRectIsSet() const { return fCropRect.flags() != 0x0; }
 
     CropRect getCropRect() const { return fCropRect; }
 
     // Default impl returns union of all input bounds.
     virtual SkRect computeFastBounds(const SkRect&) const;
 
     // Can this filter DAG compute the resulting bounds of an object-space rectangle?
-    virtual bool canComputeFastBounds() const;
+    bool canComputeFastBounds() const;
 
     /**
      *  If this filter can be represented by another filter + a localMatrix, return that filter,
      *  else return null.
      */
     sk_sp<SkImageFilter> makeWithLocalMatrix(const SkMatrix&) const;
 
 #ifdef SK_SUPPORT_LEGACY_IMAGEFILTER_PTR
     SkImageFilter* newWithLocalMatrix(const SkMatrix& matrix) const {
         return this->makeWithLocalMatrix(matrix).release();
@@ skipping 196 matching lines @@
     Context mapContext(const Context& ctx) const;
 
 private:
     friend class SkGraphics;
     static void PurgeCache();
 
     bool filterImageDeprecated(Proxy*, const SkBitmap& src, const Context&,
                                SkBitmap* result, SkIPoint* offset) const;
 
     bool usesSrcInput() const { return fUsesSrcInput; }
+    virtual bool affectsTransparentBlack() const { return false; }
 
     typedef SkFlattenable INHERITED;
     int fInputCount;
     SkImageFilter** fInputs;
     bool fUsesSrcInput;
     CropRect fCropRect;
     uint32_t fUniqueID; // Globally unique
     mutable SkTArray<Cache::Key> fCacheKeys;
     mutable SkMutex fMutex;
 };
 
 /**
  *  Helper to unflatten the common data, and return NULL if we fail.
  */
 #define SK_IMAGEFILTER_UNFLATTEN_COMMON(localVar, expectedCount)    \
     Common localVar;                                                \
     do {                                                            \
         if (!localVar.unflatten(buffer, expectedCount)) {           \
             return NULL;                                            \
         }                                                           \
     } while (0)
 
 #endif