The Tor Browser: gfx/skia/trunk/src/core/SkDrawProcs.h@129ffea94266

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.

     2 /*

     3  * Copyright 2011 Google Inc.

     4  *

     5  * Use of this source code is governed by a BSD-style license that can be

     6  * found in the LICENSE file.

     7  */

     8 #ifndef SkDrawProcs_DEFINED

     9 #define SkDrawProcs_DEFINED

    11 #include "SkBlitter.h"

    12 #include "SkDraw.h"

    14 class SkAAClip;

    15 class SkBlitter;

    17 struct SkDraw1Glyph {

    18     const SkDraw* fDraw;

    19     SkBounder* fBounder;

    20     const SkRegion* fClip;

    21     const SkAAClip* fAAClip;

    22     SkBlitter* fBlitter;

    23     SkGlyphCache* fCache;

    24     const SkPaint* fPaint;

    25     SkIRect fClipBounds;

    26     /** Half the sampling frequency of the rasterized glyph in x. */

    27     SkFixed fHalfSampleX;

    28     /** Half the sampling frequency of the rasterized glyph in y. */

    29     SkFixed fHalfSampleY;

    31     /** Draws one glyph.

    32      *

    33      *  The x and y are pre-biased, so implementations may just truncate them.

    34      *  i.e. half the sampling frequency has been added.

    35      *  e.g. 1/2 or 1/(2^(SkGlyph::kSubBits+1)) has already been added.

    36      *  This added bias can be found in fHalfSampleX,Y.

    37      */

    38     typedef void (*Proc)(const SkDraw1Glyph&, SkFixed x, SkFixed y, const SkGlyph&);

    40     Proc init(const SkDraw* draw, SkBlitter* blitter, SkGlyphCache* cache,

    41               const SkPaint&);

    43     // call this instead of fBlitter->blitMask() since this wrapper will handle

    44     // the case when the mask is ARGB32_Format

    45     //

    46     void blitMask(const SkMask& mask, const SkIRect& clip) const {

    47         if (SkMask::kARGB32_Format == mask.fFormat) {

    48             this->blitMaskAsSprite(mask);

    49         } else {

    50             fBlitter->blitMask(mask, clip);

    51         }

    52     }

    54     // mask must be kARGB32_Format

    55     void blitMaskAsSprite(const SkMask& mask) const;

    56 };

    58 struct SkDrawProcs {

    59     SkDraw1Glyph::Proc  fD1GProc;

    60 };

    62 bool SkDrawTreatAAStrokeAsHairline(SkScalar strokeWidth, const SkMatrix&,

    63                                    SkScalar* coverage);

    65 /**

    66  *  If the current paint is set to stroke and the stroke-width when applied to

    67  *  the matrix is <= 1.0, then this returns true, and sets coverage (simulating

    68  *  a stroke by drawing a hairline with partial coverage). If any of these

    69  *  conditions are false, then this returns false and coverage is ignored.

    70  */

    71 inline bool SkDrawTreatAsHairline(const SkPaint& paint, const SkMatrix& matrix,

    72                                   SkScalar* coverage) {

    73     if (SkPaint::kStroke_Style != paint.getStyle()) {

    74         return false;

    75     }

    77     SkScalar strokeWidth = paint.getStrokeWidth();

    78     if (0 == strokeWidth) {

    79         *coverage = SK_Scalar1;

    80         return true;

    81     }

    83     if (!paint.isAntiAlias()) {

    84         return false;

    85     }

    87     return SkDrawTreatAAStrokeAsHairline(strokeWidth, matrix, coverage);

    88 }

    90 #endif

The Tor Browser / file revision

gfx/skia/trunk/src/core/SkDrawProcs.h@129ffea94266

gfx/skia/trunk/src/core/SkDrawProcs.h