remove SkBounder -- unused and unloved

src/core/SkDraw.cpp

 /*
  * Copyright 2006 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 "SkDraw.h"
 #include "SkBlitter.h"
-#include "SkBounder.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkDevice.h"
 #include "SkDeviceLooper.h"
 #include "SkFixed.h"
 #include "SkMaskFilter.h"
 #include "SkPaint.h"
 #include "SkPathEffect.h"
 #include "SkRasterClip.h"
 #include "SkRasterizer.h"
@@ skipping 231 matching lines @@
 
 void SkDraw::drawPaint(const SkPaint& paint) const {
     SkDEBUGCODE(this->validate();)
 
     if (fRC->isEmpty()) {
         return;
     }
 
     SkIRect    devRect;
     devRect.set(0, 0, fBitmap->width(), fBitmap->height());
-    if (fBounder && !fBounder->doIRect(devRect)) {
-        return;
-    }
 
     if (fRC->isBW()) {
         /*  If we don't have a shader (i.e. we're just a solid color) we may
             be faster to operate directly on the device bitmap, rather than invoking
             a blitter. Esp. true for xfermodes, which require a colorshader to be
             present, which is just redundant work. Since we're drawing everywhere
             in the clip, we don't have to worry about antialiasing.
         */
         uint32_t procData = 0;  // to avoid the warning
         BitmapXferProc proc = ChooseBitmapXferProc(*fBitmap, paint, &procData);
@@ skipping 253 matching lines @@
                 };
                 proc = gBWProcs[fMode];
             }
         } else {
             proc = bw_square_proc;
         }
     }
     return proc;
 }
 
-static bool bounder_points(SkBounder* bounder, SkCanvas::PointMode mode,
-                           size_t count, const SkPoint pts[],
-                           const SkPaint& paint, const SkMatrix& matrix) {
-    SkIRect ibounds;
-    SkRect bounds;
-    SkScalar inset = paint.getStrokeWidth();
-
-    bounds.set(pts, SkToInt(count));
-    bounds.inset(-inset, -inset);
-    matrix.mapRect(&bounds);
-
-    bounds.roundOut(&ibounds);
-    return bounder->doIRect(ibounds);
-}
-
 // each of these costs 8-bytes of stack space, so don't make it too large
 // must be even for lines/polygon to work
 #define MAX_DEV_PTS     32
 
 void SkDraw::drawPoints(SkCanvas::PointMode mode, size_t count,
                         const SkPoint pts[], const SkPaint& paint,
                         bool forceUseDevice) const {
     // if we're in lines mode, force count to be even
     if (SkCanvas::kLines_PointMode == mode) {
         count &= ~(size_t)1;
     }
 
     if ((long)count <= 0) {
         return;
     }
 
     SkASSERT(pts != NULL);
     SkDEBUGCODE(this->validate();)
 
      // nothing to draw
     if (fRC->isEmpty()) {
         return;
     }
 
-    if (fBounder) {
-        if (!bounder_points(fBounder, mode, count, pts, paint, *fMatrix)) {
-            return;
-        }
-
-        // clear the bounder and call this again, so we don't invoke the bounder
-        // later if we happen to call ourselves for drawRect, drawPath, etc.
-        SkDraw noBounder(*this);
-        noBounder.fBounder = NULL;
-        noBounder.drawPoints(mode, count, pts, paint, forceUseDevice);
-        return;
-    }
-
     PtProcRec rec;
     if (!forceUseDevice && rec.init(mode, paint, fMatrix, fRC)) {
         SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
 
         SkPoint             devPts[MAX_DEV_PTS];
         const SkMatrix*     matrix = fMatrix;
         SkBlitter*          bltr = blitter.get();
         PtProcRec::Proc     proc = rec.chooseProc(&bltr);
         // we have to back up subsequent passes if we're in polygon mode
         const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
@@ skipping 235 matching lines @@
         return;
     }
 
     const SkMatrix& matrix = *fMatrix;
     SkRect          devRect;
 
     // transform rect into devRect
     matrix.mapPoints(rect_points(devRect), rect_points(rect), 2);
     devRect.sort();
 
-    if (fBounder && !fBounder->doRect(devRect, paint)) {
-        return;
-    }
-
     // look for the quick exit, before we build a blitter
     SkIRect ir;
     devRect.roundOut(&ir);
     if (paint.getStyle() != SkPaint::kFill_Style) {
         // extra space for hairlines
         ir.inset(-1, -1);
     }
     if (fRC->quickReject(ir)) {
         return;
     }
@@ skipping 50 matching lines @@
 
     SkMask dstM;
     if (paint.getMaskFilter() &&
             paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, NULL)) {
         mask = &dstM;
     } else {
         dstM.fImage = NULL;
     }
     SkAutoMaskFreeImage ami(dstM.fImage);
 
-    if (fBounder && !fBounder->doIRect(mask->fBounds)) {
-        return;
-    }
-
     SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint);
     SkBlitter* blitter = blitterChooser.get();
 
     SkAAClipBlitterWrapper wrapper;
     const SkRegion* clipRgn;
 
     if (fRC->isBW()) {
         clipRgn = &fRC->bwRgn();
     } else {
         wrapper.init(*fRC, blitter);
@@ skipping 75 matching lines @@
         if (paint.getRasterizer()) {
             goto DRAW_PATH;
         }
     }
 
     if (paint.getMaskFilter()) {
         // Transform the rrect into device space.
         SkRRect devRRect;
         if (rrect.transform(*fMatrix, &devRRect)) {
             SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
-            if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC,
-                                                   fBounder, blitter.get(),
+            if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC, blitter.get(),
                                                    SkPaint::kFill_Style)) {
                 return; // filterRRect() called the blitter, so we're done
             }
         }
     }
 
 DRAW_PATH:
     // Now fall back to the default case of using a path.
     SkPath path;
     path.addRRect(rrect);
@@ skipping 86 matching lines @@
     SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
 
     // transform the path into device space
     pathPtr->transform(*matrix, devPathPtr);
 
     SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint, drawCoverage);
 
     if (paint->getMaskFilter()) {
         SkPaint::Style style = doFill ? SkPaint::kFill_Style :
             SkPaint::kStroke_Style;
-        if (paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC,
-                                               fBounder, blitter.get(),
-                                               style)) {
+        if (paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC, blitter.get(), style)) {
             return; // filterPath() called the blitter, so we're done
         }
     }
 
-    if (fBounder && !fBounder->doPath(*devPathPtr, *paint, doFill)) {
-        return;
-    }
-
     void (*proc)(const SkPath&, const SkRasterClip&, SkBlitter*);
     if (doFill) {
         if (paint->isAntiAlias()) {
             proc = SkScan::AntiFillPath;
         } else {
             proc = SkScan::FillPath;
         }
     } else {    // hairline
         if (paint->isAntiAlias()) {
             proc = SkScan::AntiHairPath;
@@ skipping 129 matching lines @@
     SkPaint paint(origPaint);
     paint.setStyle(SkPaint::kFill_Style);
 
     SkMatrix matrix;
     matrix.setConcat(*fMatrix, prematrix);
 
     if (clipped_out(matrix, *fRC, bitmap.width(), bitmap.height())) {
         return;
     }
 
-    if (fBounder && just_translate(matrix, bitmap)) {
-        SkIRect ir;
-        int32_t ix = SkScalarRoundToInt(matrix.getTranslateX());
-        int32_t iy = SkScalarRoundToInt(matrix.getTranslateY());
-        ir.set(ix, iy, ix + bitmap.width(), iy + bitmap.height());
-        if (!fBounder->doIRect(ir)) {
-            return;
-        }
-    }
-
-    if (bitmap.colorType() != kAlpha_8_SkColorType &&
-            just_translate(matrix, bitmap)) {
+    if (bitmap.colorType() != kAlpha_8_SkColorType && just_translate(matrix, bitmap)) {
         //
         // It is safe to call lock pixels now, since we know the matrix is
         // (more or less) identity.
         //
         SkAutoLockPixels alp(bitmap);
         if (!bitmap.readyToDraw()) {
             return;
         }
         int ix = SkScalarRoundToInt(matrix.getTranslateX());
         int iy = SkScalarRoundToInt(matrix.getTranslateY());
@@ skipping 51 matching lines @@
     SkPaint paint(origPaint);
     paint.setStyle(SkPaint::kFill_Style);
 
     if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, bitmap)) {
         SkTBlitterAllocator allocator;
         // blitter will be owned by the allocator.
         SkBlitter* blitter = SkBlitter::ChooseSprite(*fBitmap, paint, bitmap,
                                                      x, y, &allocator);
 
         if (blitter) {
-            if (fBounder && !fBounder->doIRect(bounds)) {
-                return;
-            }
-
             SkScan::FillIRect(bounds, *fRC, blitter);
             return;
         }
     }
 
     SkMatrix        matrix;
     SkRect          r;
 
     // get a scalar version of our rect
     r.set(bounds);
@@ skipping 82 matching lines @@
 }
 
 // disable warning : local variable used without having been initialized
 #if defined _WIN32 && _MSC_VER >= 1300
 #pragma warning ( push )
 #pragma warning ( disable : 4701 )
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 
-static void D1G_NoBounder_RectClip(const SkDraw1Glyph& state,
-                                   SkFixed fx, SkFixed fy,
-                                   const SkGlyph& glyph) {
+static void D1G_RectClip(const SkDraw1Glyph& state, SkFixed fx, SkFixed fy, const SkGlyph& glyph) {
     int left = SkFixedFloorToInt(fx);
     int top = SkFixedFloorToInt(fy);
     SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
-    SkASSERT(NULL == state.fBounder);
     SkASSERT((NULL == state.fClip && state.fAAClip) ||
              (state.fClip && NULL == state.fAAClip && state.fClip->isRect()));
 
     left += glyph.fLeft;
     top  += glyph.fTop;
 
     int right   = left + glyph.fWidth;
     int bottom  = top + glyph.fHeight;
 
     SkMask        mask;
@@ skipping 17 matching lines @@
             return; // can't rasterize glyph
         }
     }
 
     mask.fRowBytes = glyph.rowBytes();
     mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
     mask.fImage = aa;
     state.blitMask(mask, *bounds);
 }
 
-static void D1G_NoBounder_RgnClip(const SkDraw1Glyph& state,
-                                  SkFixed fx, SkFixed fy,
-                                  const SkGlyph& glyph) {
+static void D1G_RgnClip(const SkDraw1Glyph& state, SkFixed fx, SkFixed fy, const SkGlyph& glyph) {
     int left = SkFixedFloorToInt(fx);
     int top = SkFixedFloorToInt(fy);
     SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
     SkASSERT(!state.fClip->isRect());
-    SkASSERT(NULL == state.fBounder);
 
     SkMask  mask;
 
     left += glyph.fLeft;
     top  += glyph.fTop;
 
     mask.fBounds.set(left, top, left + glyph.fWidth, top + glyph.fHeight);
     SkRegion::Cliperator clipper(*state.fClip, mask.fBounds);
 
     if (!clipper.done()) {
         const SkIRect&  cr = clipper.rect();
         const uint8_t*  aa = (const uint8_t*)glyph.fImage;
         if (NULL == aa) {
             aa = (uint8_t*)state.fCache->findImage(glyph);
             if (NULL == aa) {
                 return;
             }
         }
 
         mask.fRowBytes = glyph.rowBytes();
         mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
         mask.fImage = (uint8_t*)aa;
         do {
             state.blitMask(mask, cr);
             clipper.next();
         } while (!clipper.done());
     }
 }
 
-static void D1G_Bounder(const SkDraw1Glyph& state,
-                        SkFixed fx, SkFixed fy,
-                        const SkGlyph& glyph) {
-    int left = SkFixedFloorToInt(fx);
-    int top = SkFixedFloorToInt(fy);
-    SkASSERT(glyph.fWidth > 0 && glyph.fHeight > 0);
-
-    SkMask  mask;
-
-    left += glyph.fLeft;
-    top  += glyph.fTop;
-
-    mask.fBounds.set(left, top, left + glyph.fWidth, top + glyph.fHeight);
-    SkRegion::Cliperator clipper(*state.fClip, mask.fBounds);
-
-    if (!clipper.done()) {
-        const SkIRect&  cr = clipper.rect();
-        const uint8_t*  aa = (const uint8_t*)glyph.fImage;
-        if (NULL == aa) {
-            aa = (uint8_t*)state.fCache->findImage(glyph);
-            if (NULL == aa) {
-                return;
-            }
-        }
-
-        // we need to pass the origin, which we approximate with our
-        // (unadjusted) left,top coordinates (the caller called fixedfloor)
-        if (state.fBounder->doIRectGlyph(cr,
-                                         left - glyph.fLeft,
-                                         top - glyph.fTop, glyph)) {
-            mask.fRowBytes = glyph.rowBytes();
-            mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
-            mask.fImage = (uint8_t*)aa;
-            do {
-                state.blitMask(mask, cr);
-                clipper.next();
-            } while (!clipper.done());
-        }
-    }
-}
-
-static void D1G_Bounder_AAClip(const SkDraw1Glyph& state,
-                               SkFixed fx, SkFixed fy,
-                               const SkGlyph& glyph) {
-    int left = SkFixedFloorToInt(fx);
-    int top = SkFixedFloorToInt(fy);
-    SkIRect bounds;
-    bounds.set(left, top, left + glyph.fWidth, top + glyph.fHeight);
-
-    if (state.fBounder->doIRectGlyph(bounds, left, top, glyph)) {
-        D1G_NoBounder_RectClip(state, fx, fy, glyph);
-    }
-}
-
 static bool hasCustomD1GProc(const SkDraw& draw) {
     return draw.fProcs && draw.fProcs->fD1GProc;
 }
 
 static bool needsRasterTextBlit(const SkDraw& draw) {
     return !hasCustomD1GProc(draw);
 }
 
-SkDraw1Glyph::Proc SkDraw1Glyph::init(const SkDraw* draw, SkBlitter* blitter,
-                                      SkGlyphCache* cache, const SkPaint& pnt) {
+SkDraw1Glyph::Proc SkDraw1Glyph::init(const SkDraw* draw, SkBlitter* blitter, SkGlyphCache* cache,
+                                      const SkPaint& pnt) {
     fDraw = draw;
-    fBounder = draw->fBounder;
     fBlitter = blitter;
     fCache = cache;
     fPaint = &pnt;
 
     if (cache->isSubpixel()) {
         fHalfSampleX = fHalfSampleY = (SK_FixedHalf >> SkGlyph::kSubBits);
     } else {
         fHalfSampleX = fHalfSampleY = SK_FixedHalf;
     }
 
     if (hasCustomD1GProc(*draw)) {
         // todo: fix this assumption about clips w/ custom
         fClip = draw->fClip;
         fClipBounds = fClip->getBounds();
         return draw->fProcs->fD1GProc;
     }
 
     if (draw->fRC->isBW()) {
         fAAClip = NULL;
         fClip = &draw->fRC->bwRgn();
         fClipBounds = fClip->getBounds();
-        if (NULL == fBounder) {
-            if (fClip->isRect()) {
-                return D1G_NoBounder_RectClip;
-            } else {
-                return D1G_NoBounder_RgnClip;
-            }
+        if (fClip->isRect()) {
+            return D1G_RectClip;
         } else {
-            return D1G_Bounder;
+            return D1G_RgnClip;
         }
     } else {    // aaclip
         fAAClip = &draw->fRC->aaRgn();
         fClip = NULL;
         fClipBounds = fAAClip->getBounds();
-        if (NULL == fBounder) {
-            return D1G_NoBounder_RectClip;
-        } else {
-            return D1G_Bounder_AAClip;
-        }
+        return D1G_RectClip;
     }
 }
 
 void SkDraw1Glyph::blitMaskAsSprite(const SkMask& mask) const {
     SkASSERT(SkMask::kARGB32_Format == mask.fFormat);
 
     SkBitmap bm;
     bm.installPixels(SkImageInfo::MakeN32Premul(mask.fBounds.width(), mask.fBounds.height()),
                      (SkPMColor*)mask.fImage, mask.fRowBytes);
 
@@ skipping 699 matching lines @@
     // abort early if there is nothing to draw
     if (count < 3 || (indices && indexCount < 3) || fRC->isEmpty()) {
         return;
     }
 
     // transform out vertices into device coordinates
     SkAutoSTMalloc<16, SkPoint> storage(count);
     SkPoint* devVerts = storage.get();
     fMatrix->mapPoints(devVerts, vertices, count);
 
-    if (fBounder) {
-        SkRect bounds;
-        bounds.set(devVerts, count);
-        if (!fBounder->doRect(bounds, paint)) {
-            return;
-        }
-    }
-
     /*
         We can draw the vertices in 1 of 4 ways:
 
         - solid color (no shader/texture[], no colors[])
         - just colors (no shader/texture[], has colors[])
         - just texture (has shader/texture[], no colors[])
         - colors * texture (has shader/texture[], has colors[])
 
         Thus for texture drawing, we need both texture[] and a shader.
     */
@@ skipping 111 matching lines @@
 
     const SkIRect&  cr = fRC->getBounds();
     SkIRect         br;
 
     br.set(0, 0, fBitmap->width(), fBitmap->height());
     SkASSERT(cr.isEmpty() || br.contains(cr));
 }
 
 #endif
 
-///////////////////////////////////////////////////////////////////////////////
-
-SkBounder::SkBounder() {
-    // initialize up front. This gets reset by SkCanvas before each draw call.
-    fClip = &SkRegion::GetEmptyRegion();
-}
-
-bool SkBounder::doIRect(const SkIRect& r) {
-    SkIRect    rr;
-    return rr.intersect(fClip->getBounds(), r) && this->onIRect(rr);
-}
-
-// TODO: change the prototype to take fixed, and update the callers
-bool SkBounder::doIRectGlyph(const SkIRect& r, int x, int y,
-                             const SkGlyph& glyph) {
-    SkIRect    rr;
-    if (!rr.intersect(fClip->getBounds(), r)) {
-        return false;
-    }
-    GlyphRec rec;
-    rec.fLSB.set(SkIntToFixed(x), SkIntToFixed(y));
-    rec.fRSB.set(rec.fLSB.fX + glyph.fAdvanceX,
-                 rec.fLSB.fY + glyph.fAdvanceY);
-    rec.fGlyphID = glyph.getGlyphID();
-    rec.fFlags = 0;
-    return this->onIRectGlyph(rr, rec);
-}
-
-bool SkBounder::doHairline(const SkPoint& pt0, const SkPoint& pt1,
-                           const SkPaint& paint) {
-    SkIRect     r;
-    SkScalar    v0, v1;
-
-    v0 = pt0.fX;
-    v1 = pt1.fX;
-    if (v0 > v1) {
-        SkTSwap<SkScalar>(v0, v1);
-    }
-    r.fLeft     = SkScalarFloorToInt(v0);
-    r.fRight    = SkScalarCeilToInt(v1);
-
-    v0 = pt0.fY;
-    v1 = pt1.fY;
-    if (v0 > v1) {
-        SkTSwap<SkScalar>(v0, v1);
-    }
-    r.fTop      = SkScalarFloorToInt(v0);
-    r.fBottom   = SkScalarCeilToInt(v1);
-
-    if (paint.isAntiAlias()) {
-        r.inset(-1, -1);
-    }
-    return this->doIRect(r);
-}
-
-bool SkBounder::doRect(const SkRect& rect, const SkPaint& paint) {
-    SkIRect    r;
-
-    if (paint.getStyle() == SkPaint::kFill_Style) {
-        rect.round(&r);
-    } else {
-        int rad = -1;
-        rect.roundOut(&r);
-        if (paint.isAntiAlias()) {
-            rad = -2;
-        }
-        r.inset(rad, rad);
-    }
-    return this->doIRect(r);
-}
-
-bool SkBounder::doPath(const SkPath& path, const SkPaint& paint, bool doFill) {
-    SkIRect       r;
-    const SkRect& bounds = path.getBounds();
-
-    if (doFill) {
-        bounds.round(&r);
-    } else {    // hairline
-        bounds.roundOut(&r);
-    }
-
-    if (paint.isAntiAlias()) {
-        r.inset(-1, -1);
-    }
-    return this->doIRect(r);
-}
-
-void SkBounder::commit() {
-    // override in subclass
-}
-
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkPath.h"
 #include "SkDraw.h"
 #include "SkRegion.h"
 #include "SkBlitter.h"
 
 static bool compute_bounds(const SkPath& devPath, const SkIRect* clipBounds,
                        const SkMaskFilter* filter, const SkMatrix* filterMatrix,
                            SkIRect* bounds) {
@@ skipping 55 matching lines @@
                      mask.fImage, mask.fRowBytes);
 
     clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
     matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
                         -SkIntToScalar(mask.fBounds.fTop));
 
     draw.fBitmap    = &bm;
     draw.fRC        = &clip;
     draw.fClip      = &clip.bwRgn();
     draw.fMatrix    = &matrix;
-    draw.fBounder   = NULL;
     paint.setAntiAlias(true);
     paint.setStyle(style);
     draw.drawPath(devPath, paint);
 }
 
 bool SkDraw::DrawToMask(const SkPath& devPath, const SkIRect* clipBounds,
                         const SkMaskFilter* filter, const SkMatrix* filterMatrix,
                         SkMask* mask, SkMask::CreateMode mode,
                         SkPaint::Style style) {
     if (SkMask::kJustRenderImage_CreateMode != mode) {
@@ skipping 12 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }