The Tor Browser: gfx/skia/trunk/src/core/SkScan_AntiPath.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkScan_AntiPath.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkScan_AntiPath.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * 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 "SkScanPriv.h"
 #include "SkPath.h"
 #include "SkMatrix.h"
 #include "SkBlitter.h"
 #include "SkRegion.h"
 #include "SkAntiRun.h"
 #define SHIFT   2
 #define SCALE   (1 << SHIFT)
 #define MASK    (SCALE - 1)
 /** @file
     We have two techniques for capturing the output of the supersampler:
     - SUPERMASK, which records a large mask-bitmap
         this is often faster for small, complex objects
     - RLE, which records a rle-encoded scanline
         this is often faster for large objects with big spans
     These blitters use two coordinate systems:
     - destination coordinates, scale equal to the output - often
         abbreviated with 'i' or 'I' in variable names
     - supersampled coordinates, scale equal to the output * SCALE
     Enabling SK_USE_LEGACY_AA_COVERAGE keeps the aa coverage calculations as
     they were before the fix that unified the output of the RLE and MASK
     supersamplers.
  */
 //#define FORCE_SUPERMASK
 //#define FORCE_RLE
 //#define SK_USE_LEGACY_AA_COVERAGE
 ///////////////////////////////////////////////////////////////////////////////
 /// Base class for a single-pass supersampled blitter.
 class BaseSuperBlitter : public SkBlitter {
 public:
     BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                      const SkRegion& clip);
     /// Must be explicitly defined on subclasses.
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
                            const int16_t runs[]) SK_OVERRIDE {
         SkDEBUGFAIL("How did I get here?");
     }
     /// May not be called on BaseSuperBlitter because it blits out of order.
     virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
         SkDEBUGFAIL("How did I get here?");
     }
 protected:
     SkBlitter*  fRealBlitter;
     /// Current y coordinate, in destination coordinates.
     int         fCurrIY;
     /// Widest row of region to be blitted, in destination coordinates.
     int         fWidth;
     /// Leftmost x coordinate in any row, in destination coordinates.
     int         fLeft;
     /// Leftmost x coordinate in any row, in supersampled coordinates.
     int         fSuperLeft;
     SkDEBUGCODE(int fCurrX;)
     /// Current y coordinate in supersampled coordinates.
     int fCurrY;
     /// Initial y coordinate (top of bounds).
     int fTop;
 };
 BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                                    const SkRegion& clip) {
     fRealBlitter = realBlitter;
     /*
      *  We use the clip bounds instead of the ir, since we may be asked to
      *  draw outside of the rect if we're a inverse filltype
      */
     const int left = clip.getBounds().fLeft;
     const int right = clip.getBounds().fRight;
     fLeft = left;
     fSuperLeft = left << SHIFT;
     fWidth = right - left;
 #if 0
     fCurrIY = -1;
     fCurrY = -1;
 #else
     fTop = ir.fTop;
     fCurrIY = ir.fTop - 1;
     fCurrY = (ir.fTop << SHIFT) - 1;
 #endif
     SkDEBUGCODE(fCurrX = -1;)
 }
 /// Run-length-encoded supersampling antialiased blitter.
 class SuperBlitter : public BaseSuperBlitter {
 public:
     SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                  const SkRegion& clip);
     virtual ~SuperBlitter() {
         this->flush();
         sk_free(fRuns.fRuns);
     }
     /// Once fRuns contains a complete supersampled row, flush() blits
     /// it out through the wrapped blitter.
     void flush();
     /// Blits a row of pixels, with location and width specified
     /// in supersampled coordinates.
     virtual void blitH(int x, int y, int width) SK_OVERRIDE;
     /// Blits a rectangle of pixels, with location and size specified
     /// in supersampled coordinates.
     virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
 private:
     SkAlphaRuns fRuns;
     int         fOffsetX;
 };
 SuperBlitter::SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                            const SkRegion& clip)
         : BaseSuperBlitter(realBlitter, ir, clip) {
     const int width = fWidth;
     // extra one to store the zero at the end
     fRuns.fRuns = (int16_t*)sk_malloc_throw((width + 1 + (width + 2)/2) * sizeof(int16_t));
     fRuns.fAlpha = (uint8_t*)(fRuns.fRuns + width + 1);
     fRuns.reset(width);
     fOffsetX = 0;
 }
 void SuperBlitter::flush() {
     if (fCurrIY >= fTop) {
         if (!fRuns.empty()) {
         //  SkDEBUGCODE(fRuns.dump();)
             fRealBlitter->blitAntiH(fLeft, fCurrIY, fRuns.fAlpha, fRuns.fRuns);
             fRuns.reset(fWidth);
             fOffsetX = 0;
         }
         fCurrIY = fTop - 1;
         SkDEBUGCODE(fCurrX = -1;)
     }
 }
 /** coverage_to_partial_alpha() is being used by SkAlphaRuns, which
     *accumulates* SCALE pixels worth of "alpha" in [0,(256/SCALE)]
     to produce a final value in [0, 255] and handles clamping 256->255
     itself, with the same (alpha - (alpha >> 8)) correction as
     coverage_to_exact_alpha().
 */
 static inline int coverage_to_partial_alpha(int aa) {
     aa <<= 8 - 2*SHIFT;
 #ifdef SK_USE_LEGACY_AA_COVERAGE
     aa -= aa >> (8 - SHIFT - 1);
 #endif
     return aa;
 }
 /** coverage_to_exact_alpha() is being used by our blitter, which wants
     a final value in [0, 255].
 */
 static inline int coverage_to_exact_alpha(int aa) {
     int alpha = (256 >> SHIFT) * aa;
     // clamp 256->255
     return alpha - (alpha >> 8);
 }
 void SuperBlitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     int iy = y >> SHIFT;
     SkASSERT(iy >= fCurrIY);
     x -= fSuperLeft;
     // hack, until I figure out why my cubics (I think) go beyond the bounds
     if (x < 0) {
         width += x;
         x = 0;
     }
 #ifdef SK_DEBUG
     SkASSERT(y != fCurrY || x >= fCurrX);
 #endif
     SkASSERT(y >= fCurrY);
     if (fCurrY != y) {
         fOffsetX = 0;
         fCurrY = y;
     }
     if (iy != fCurrIY) {  // new scanline
         this->flush();
         fCurrIY = iy;
     }
     int start = x;
     int stop = x + width;
     SkASSERT(start >= 0 && stop > start);
     // integer-pixel-aligned ends of blit, rounded out
     int fb = start & MASK;
     int fe = stop & MASK;
     int n = (stop >> SHIFT) - (start >> SHIFT) - 1;
     if (n < 0) {
         fb = fe - fb;
         n = 0;
         fe = 0;
     } else {
         if (fb == 0) {
             n += 1;
         } else {
             fb = SCALE - fb;
         }
     }
     fOffsetX = fRuns.add(x >> SHIFT, coverage_to_partial_alpha(fb),
                          n, coverage_to_partial_alpha(fe),
                          (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT),
                          fOffsetX);
 #ifdef SK_DEBUG
     fRuns.assertValid(y & MASK, (1 << (8 - SHIFT)));
     fCurrX = x + width;
 #endif
 }
 #if 0 // UNUSED
 static void set_left_rite_runs(SkAlphaRuns& runs, int ileft, U8CPU leftA,
                                int n, U8CPU riteA) {
     SkASSERT(leftA <= 0xFF);
     SkASSERT(riteA <= 0xFF);
     int16_t* run = runs.fRuns;
     uint8_t* aa = runs.fAlpha;
     if (ileft > 0) {
         run[0] = ileft;
         aa[0] = 0;
         run += ileft;
         aa += ileft;
     }
     SkASSERT(leftA < 0xFF);
     if (leftA > 0) {
         *run++ = 1;
         *aa++ = leftA;
     }
     if (n > 0) {
         run[0] = n;
         aa[0] = 0xFF;
         run += n;
         aa += n;
     }
     SkASSERT(riteA < 0xFF);
     if (riteA > 0) {
         *run++ = 1;
         *aa++ = riteA;
     }
     run[0] = 0;
 }
 #endif
 void SuperBlitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(width > 0);
     SkASSERT(height > 0);
     // blit leading rows
     while ((y & MASK)) {
         this->blitH(x, y++, width);
         if (--height <= 0) {
             return;
         }
     }
     SkASSERT(height > 0);
     // Since this is a rect, instead of blitting supersampled rows one at a
     // time and then resolving to the destination canvas, we can blit
     // directly to the destintion canvas one row per SCALE supersampled rows.
     int start_y = y >> SHIFT;
     int stop_y = (y + height) >> SHIFT;
     int count = stop_y - start_y;
     if (count > 0) {
         y += count << SHIFT;
         height -= count << SHIFT;
         // save original X for our tail blitH() loop at the bottom
         int origX = x;
         x -= fSuperLeft;
         // hack, until I figure out why my cubics (I think) go beyond the bounds
         if (x < 0) {
             width += x;
             x = 0;
         }
         // There is always a left column, a middle, and a right column.
         // ileft is the destination x of the first pixel of the entire rect.
         // xleft is (SCALE - # of covered supersampled pixels) in that
         // destination pixel.
         int ileft = x >> SHIFT;
         int xleft = x & MASK;
         // irite is the destination x of the last pixel of the OPAQUE section.
         // xrite is the number of supersampled pixels extending beyond irite;
         // xrite/SCALE should give us alpha.
         int irite = (x + width) >> SHIFT;
         int xrite = (x + width) & MASK;
         if (!xrite) {
             xrite = SCALE;
             irite--;
         }
         // Need to call flush() to clean up pending draws before we
         // even consider blitV(), since otherwise it can look nonmonotonic.
         SkASSERT(start_y > fCurrIY);
         this->flush();
         int n = irite - ileft - 1;
         if (n < 0) {
             // If n < 0, we'll only have a single partially-transparent column
             // of pixels to render.
             xleft = xrite - xleft;
             SkASSERT(xleft <= SCALE);
             SkASSERT(xleft > 0);
             xrite = 0;
             fRealBlitter->blitV(ileft + fLeft, start_y, count,
                 coverage_to_exact_alpha(xleft));
         } else {
             // With n = 0, we have two possibly-transparent columns of pixels
             // to render; with n > 0, we have opaque columns between them.
             xleft = SCALE - xleft;
             // Using coverage_to_exact_alpha is not consistent with blitH()
             const int coverageL = coverage_to_exact_alpha(xleft);
             const int coverageR = coverage_to_exact_alpha(xrite);
             SkASSERT(coverageL > 0 || n > 0 || coverageR > 0);
             SkASSERT((coverageL != 0) + n + (coverageR != 0) <= fWidth);
             fRealBlitter->blitAntiRect(ileft + fLeft, start_y, n, count,
                                        coverageL, coverageR);
         }
         // preamble for our next call to blitH()
         fCurrIY = stop_y - 1;
         fOffsetX = 0;
         fCurrY = y - 1;
         fRuns.reset(fWidth);
         x = origX;
     }
     // catch any remaining few rows
     SkASSERT(height <= MASK);
     while (--height >= 0) {
         this->blitH(x, y++, width);
     }
 }
 ///////////////////////////////////////////////////////////////////////////////
 /// Masked supersampling antialiased blitter.
 class MaskSuperBlitter : public BaseSuperBlitter {
 public:
     MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                      const SkRegion& clip);
     virtual ~MaskSuperBlitter() {
         fRealBlitter->blitMask(fMask, fClipRect);
     }
     virtual void blitH(int x, int y, int width) SK_OVERRIDE;
     static bool CanHandleRect(const SkIRect& bounds) {
 #ifdef FORCE_RLE
         return false;
 #endif
         int width = bounds.width();
         int64_t rb = SkAlign4(width);
         // use 64bits to detect overflow
         int64_t storage = rb * bounds.height();
         return (width <= MaskSuperBlitter::kMAX_WIDTH) &&
                (storage <= MaskSuperBlitter::kMAX_STORAGE);
     }
 private:
     enum {
 #ifdef FORCE_SUPERMASK
         kMAX_WIDTH = 2048,
         kMAX_STORAGE = 1024 * 1024 * 2
 #else
         kMAX_WIDTH = 32,    // so we don't try to do very wide things, where the RLE blitter would be faster
         kMAX_STORAGE = 1024
 #endif
     };
     SkMask      fMask;
     SkIRect     fClipRect;
     // we add 1 because add_aa_span can write (unchanged) 1 extra byte at the end, rather than
     // perform a test to see if stopAlpha != 0
     uint32_t    fStorage[(kMAX_STORAGE >> 2) + 1];
 };
 MaskSuperBlitter::MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
                                    const SkRegion& clip)
         : BaseSuperBlitter(realBlitter, ir, clip) {
     SkASSERT(CanHandleRect(ir));
     fMask.fImage    = (uint8_t*)fStorage;
     fMask.fBounds   = ir;
     fMask.fRowBytes = ir.width();
     fMask.fFormat   = SkMask::kA8_Format;
     fClipRect = ir;
     fClipRect.intersect(clip.getBounds());
     // For valgrind, write 1 extra byte at the end so we don't read
     // uninitialized memory. See comment in add_aa_span and fStorage[].
     memset(fStorage, 0, fMask.fBounds.height() * fMask.fRowBytes + 1);
 }
 static void add_aa_span(uint8_t* alpha, U8CPU startAlpha) {
     /*  I should be able to just add alpha[x] + startAlpha.
         However, if the trailing edge of the previous span and the leading
         edge of the current span round to the same super-sampled x value,
         I might overflow to 256 with this add, hence the funny subtract.
     */
     unsigned tmp = *alpha + startAlpha;
     SkASSERT(tmp <= 256);
     *alpha = SkToU8(tmp - (tmp >> 8));
 }
 static inline uint32_t quadplicate_byte(U8CPU value) {
     uint32_t pair = (value << 8) | value;
     return (pair << 16) | pair;
 }
 // Perform this tricky subtract, to avoid overflowing to 256. Our caller should
 // only ever call us with at most enough to hit 256 (never larger), so it is
 // enough to just subtract the high-bit. Actually clamping with a branch would
 // be slower (e.g. if (tmp > 255) tmp = 255;)
 //
 static inline void saturated_add(uint8_t* ptr, U8CPU add) {
     unsigned tmp = *ptr + add;
     SkASSERT(tmp <= 256);
     *ptr = SkToU8(tmp - (tmp >> 8));
 }
 // minimum count before we want to setup an inner loop, adding 4-at-a-time
 #define MIN_COUNT_FOR_QUAD_LOOP  16
 static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount,
                         U8CPU stopAlpha, U8CPU maxValue) {
     SkASSERT(middleCount >= 0);
     saturated_add(alpha, startAlpha);
     alpha += 1;
     if (middleCount >= MIN_COUNT_FOR_QUAD_LOOP) {
         // loop until we're quad-byte aligned
         while (SkTCast<intptr_t>(alpha) & 0x3) {
             alpha[0] = SkToU8(alpha[0] + maxValue);
             alpha += 1;
             middleCount -= 1;
         }
         int bigCount = middleCount >> 2;
         uint32_t* qptr = reinterpret_cast<uint32_t*>(alpha);
         uint32_t qval = quadplicate_byte(maxValue);
         do {
             *qptr++ += qval;
         } while (--bigCount > 0);
         middleCount &= 3;
         alpha = reinterpret_cast<uint8_t*> (qptr);
         // fall through to the following while-loop
     }
     while (--middleCount >= 0) {
         alpha[0] = SkToU8(alpha[0] + maxValue);
         alpha += 1;
     }
     // potentially this can be off the end of our "legal" alpha values, but that
     // only happens if stopAlpha is also 0. Rather than test for stopAlpha != 0
     // every time (slow), we just do it, and ensure that we've allocated extra space
     // (see the + 1 comment in fStorage[]
     saturated_add(alpha, stopAlpha);
 }
 void MaskSuperBlitter::blitH(int x, int y, int width) {
     int iy = (y >> SHIFT);
     SkASSERT(iy >= fMask.fBounds.fTop && iy < fMask.fBounds.fBottom);
     iy -= fMask.fBounds.fTop;   // make it relative to 0
     // This should never happen, but it does.  Until the true cause is
     // discovered, let's skip this span instead of crashing.
     // See http://crbug.com/17569.
     if (iy < 0) {
         return;
     }
 #ifdef SK_DEBUG
     {
         int ix = x >> SHIFT;
         SkASSERT(ix >= fMask.fBounds.fLeft && ix < fMask.fBounds.fRight);
     }
 #endif
     x -= (fMask.fBounds.fLeft << SHIFT);
     // hack, until I figure out why my cubics (I think) go beyond the bounds
     if (x < 0) {
         width += x;
         x = 0;
     }
     uint8_t* row = fMask.fImage + iy * fMask.fRowBytes + (x >> SHIFT);
     int start = x;
     int stop = x + width;
     SkASSERT(start >= 0 && stop > start);
     int fb = start & MASK;
     int fe = stop & MASK;
     int n = (stop >> SHIFT) - (start >> SHIFT) - 1;
     if (n < 0) {
         SkASSERT(row >= fMask.fImage);
         SkASSERT(row < fMask.fImage + kMAX_STORAGE + 1);
         add_aa_span(row, coverage_to_partial_alpha(fe - fb));
     } else {
         fb = SCALE - fb;
         SkASSERT(row >= fMask.fImage);
         SkASSERT(row + n + 1 < fMask.fImage + kMAX_STORAGE + 1);
         add_aa_span(row,  coverage_to_partial_alpha(fb),
                     n, coverage_to_partial_alpha(fe),
                     (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT));
     }
 #ifdef SK_DEBUG
     fCurrX = x + width;
 #endif
 }
 ///////////////////////////////////////////////////////////////////////////////
 static bool fitsInsideLimit(const SkRect& r, SkScalar max) {
     const SkScalar min = -max;
     return  r.fLeft > min && r.fTop > min &&
             r.fRight < max && r.fBottom < max;
 }
 static int overflows_short_shift(int value, int shift) {
     const int s = 16 + shift;
     return (value << s >> s) - value;
 }
 /**
   Would any of the coordinates of this rectangle not fit in a short,
   when left-shifted by shift?
 */
 static int rect_overflows_short_shift(SkIRect rect, int shift) {
     SkASSERT(!overflows_short_shift(8191, SHIFT));
     SkASSERT(overflows_short_shift(8192, SHIFT));
     SkASSERT(!overflows_short_shift(32767, 0));
     SkASSERT(overflows_short_shift(32768, 0));
     // Since we expect these to succeed, we bit-or together
     // for a tiny extra bit of speed.
     return overflows_short_shift(rect.fLeft, SHIFT) |
            overflows_short_shift(rect.fRight, SHIFT) |
            overflows_short_shift(rect.fTop, SHIFT) |
            overflows_short_shift(rect.fBottom, SHIFT);
 }
 static bool safeRoundOut(const SkRect& src, SkIRect* dst, int32_t maxInt) {
     const SkScalar maxScalar = SkIntToScalar(maxInt);
     if (fitsInsideLimit(src, maxScalar)) {
         src.roundOut(dst);
         return true;
     }
     return false;
 }
 void SkScan::AntiFillPath(const SkPath& path, const SkRegion& origClip,
                           SkBlitter* blitter, bool forceRLE) {
     if (origClip.isEmpty()) {
         return;
     }
     SkIRect ir;
     if (!safeRoundOut(path.getBounds(), &ir, SK_MaxS32 >> SHIFT)) {
 #if 0
         const SkRect& r = path.getBounds();
         SkDebugf("--- bounds can't fit in SkIRect\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
 #endif
         return;
     }
     if (ir.isEmpty()) {
         if (path.isInverseFillType()) {
             blitter->blitRegion(origClip);
         }
         return;
     }
     // If the intersection of the path bounds and the clip bounds
     // will overflow 32767 when << by SHIFT, we can't supersample,
     // so draw without antialiasing.
     SkIRect clippedIR;
     if (path.isInverseFillType()) {
        // If the path is an inverse fill, it's going to fill the entire
        // clip, and we care whether the entire clip exceeds our limits.
        clippedIR = origClip.getBounds();
     } else {
        if (!clippedIR.intersect(ir, origClip.getBounds())) {
            return;
        }
     }
     if (rect_overflows_short_shift(clippedIR, SHIFT)) {
         SkScan::FillPath(path, origClip, blitter);
         return;
     }
     // Our antialiasing can't handle a clip larger than 32767, so we restrict
     // the clip to that limit here. (the runs[] uses int16_t for its index).
     //
     // A more general solution (one that could also eliminate the need to
     // disable aa based on ir bounds (see overflows_short_shift) would be
     // to tile the clip/target...
     SkRegion tmpClipStorage;
     const SkRegion* clipRgn = &origClip;
     {
         static const int32_t kMaxClipCoord = 32767;
         const SkIRect& bounds = origClip.getBounds();
         if (bounds.fRight > kMaxClipCoord || bounds.fBottom > kMaxClipCoord) {
             SkIRect limit = { 0, 0, kMaxClipCoord, kMaxClipCoord };
             tmpClipStorage.op(origClip, limit, SkRegion::kIntersect_Op);
             clipRgn = &tmpClipStorage;
         }
     }
     // for here down, use clipRgn, not origClip
     SkScanClipper   clipper(blitter, clipRgn, ir);
     const SkIRect*  clipRect = clipper.getClipRect();
     if (clipper.getBlitter() == NULL) { // clipped out
         if (path.isInverseFillType()) {
             blitter->blitRegion(*clipRgn);
         }
         return;
     }
     // now use the (possibly wrapped) blitter
     blitter = clipper.getBlitter();
     if (path.isInverseFillType()) {
         sk_blit_above(blitter, ir, *clipRgn);
     }
     SkIRect superRect, *superClipRect = NULL;
     if (clipRect) {
         superRect.set(  clipRect->fLeft << SHIFT, clipRect->fTop << SHIFT,
                         clipRect->fRight << SHIFT, clipRect->fBottom << SHIFT);
         superClipRect = &superRect;
     }
     SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
     // MaskSuperBlitter can't handle drawing outside of ir, so we can't use it
     // if we're an inverse filltype
     if (!path.isInverseFillType() && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {
         MaskSuperBlitter    superBlit(blitter, ir, *clipRgn);
         SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
     } else {
         SuperBlitter    superBlit(blitter, ir, *clipRgn);
         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
     }
     if (path.isInverseFillType()) {
         sk_blit_below(blitter, ir, *clipRgn);
     }
 }
 ///////////////////////////////////////////////////////////////////////////////
 #include "SkRasterClip.h"
 void SkScan::FillPath(const SkPath& path, const SkRasterClip& clip,
                           SkBlitter* blitter) {
     if (clip.isEmpty()) {
         return;
     }
     if (clip.isBW()) {
         FillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         SkScan::FillPath(path, tmp, &aaBlitter);
     }
 }
 void SkScan::AntiFillPath(const SkPath& path, const SkRasterClip& clip,
                           SkBlitter* blitter) {
     if (clip.isEmpty()) {
         return;
     }
     if (clip.isBW()) {
         AntiFillPath(path, clip.bwRgn(), blitter);
     } else {
         SkRegion        tmp;
         SkAAClipBlitter aaBlitter;
         tmp.setRect(clip.getBounds());
         aaBlitter.init(blitter, &clip.aaRgn());
         SkScan::AntiFillPath(path, tmp, &aaBlitter, true);
     }
 }

The Tor Browser / annotate

gfx/skia/trunk/src/core/SkScan_AntiPath.cpp@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkScan_AntiPath.cpp