Protect apply_paint_to_bounds_sans_imagefilter() with an #ifdef.

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 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 "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 394 matching lines @@
         // there is no existing paint colorfilter, so we can just return the imagefilter's
         return imgCF;
     }
 
     // The paint has both a colorfilter(paintCF) and an imagefilter-which-is-a-colorfilter(imgCF)
     // and we need to combine them into a single colorfilter.
     SkAutoTUnref<SkColorFilter> autoImgCF(imgCF);
     return SkColorFilter::CreateComposeFilter(imgCF, paintCF);
 }
 
+#ifndef SK_SAVE_LAYER_BOUNDS_ARE_FILTERED
 /**
  * There are many bounds in skia. A circle's bounds is just its center extended by its radius.
  * However, if we stroke a circle, then the "bounds" of that is larger, since it will now draw
  * outside of its raw-bounds by 1/2 the stroke width.  SkPaint has lots of optional
  * effects/attributes that can modify the effective bounds of a given primitive -- maskfilters,
  * patheffects, stroking, etc.  This function takes a raw bounds and a paint, and returns the
  * conservative "effective" bounds based on the settings in the paint... with one exception. This
  * function does *not* look at the imagefilter, which can also modify the effective bounds. It is
  * deliberately ignored.
  */
 static const SkRect& apply_paint_to_bounds_sans_imagefilter(const SkPaint& paint,
                                                             const SkRect& rawBounds,
                                                             SkRect* storage) {
     SkPaint tmpUnfiltered(paint);
     tmpUnfiltered.setImageFilter(nullptr);
     if (tmpUnfiltered.canComputeFastBounds()) {
         return tmpUnfiltered.computeFastBounds(rawBounds, storage);
     } else {
         return rawBounds;
     }
 }
+#endif
 
 class AutoDrawLooper {
 public:
     // "rawBounds" is the original bounds of the primitive about to be drawn, unmodified by the
     // paint. It's used to determine the size of the offscreen layer for filters.
     // If null, the clip will be used instead.
     AutoDrawLooper(SkCanvas* canvas, const SkSurfaceProps& props, const SkPaint& paint,
                    bool skipLayerForImageFilter = false,
                    const SkRect* rawBounds = nullptr) : fOrigPaint(paint) {
         fCanvas = canvas;
@@ skipping 2581 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }