The Tor Browser: gfx/skia/trunk/src/pipe/SkGPipePriv.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pipe/SkGPipePriv.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pipe/SkGPipePriv.h

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 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkGPipePriv_DEFINED
 #define SkGPipePriv_DEFINED
 #include "SkTypes.h"
 #define UNIMPLEMENTED
 // these must be contiguous, 0...N-1
 enum PaintFlats {
     kColorFilter_PaintFlat,
     kDrawLooper_PaintFlat,
     kImageFilter_PaintFlat,
     kMaskFilter_PaintFlat,
     kPathEffect_PaintFlat,
     kRasterizer_PaintFlat,
     kShader_PaintFlat,
     kXfermode_PaintFlat,
     kLast_PaintFlat = kXfermode_PaintFlat
 };
 #define kCount_PaintFlats   (kLast_PaintFlat + 1)
 enum DrawOps {
     kSkip_DrawOp,   // skip an addition N bytes (N == data)
     // these match Canvas apis
     kClipPath_DrawOp,
     kClipRegion_DrawOp,
     kClipRect_DrawOp,
     kClipRRect_DrawOp,
     kConcat_DrawOp,
     kDrawBitmap_DrawOp,
     kDrawBitmapMatrix_DrawOp,
     kDrawBitmapNine_DrawOp,
     kDrawBitmapRectToRect_DrawOp,
     kDrawClear_DrawOp,
     kDrawData_DrawOp,
     kDrawDRRect_DrawOp,
     kDrawOval_DrawOp,
     kDrawPaint_DrawOp,
     kDrawPath_DrawOp,
     kDrawPicture_DrawOp,
     kDrawPoints_DrawOp,
     kDrawPosText_DrawOp,
     kDrawPosTextH_DrawOp,
     kDrawRect_DrawOp,
     kDrawRRect_DrawOp,
     kDrawSprite_DrawOp,
     kDrawText_DrawOp,
     kDrawTextOnPath_DrawOp,
     kDrawVertices_DrawOp,
     kRestore_DrawOp,
     kRotate_DrawOp,
     kSave_DrawOp,
     kSaveLayer_DrawOp,
     kScale_DrawOp,
     kSetMatrix_DrawOp,
     kSkew_DrawOp,
     kTranslate_DrawOp,
     kPaintOp_DrawOp,
     kSetTypeface_DrawOp,
     kSetAnnotation_DrawOp,
     kDef_Typeface_DrawOp,
     kDef_Flattenable_DrawOp,
     kDef_Bitmap_DrawOp,
     kDef_Factory_DrawOp,
     // these are signals to playback, not drawing verbs
     kReportFlags_DrawOp,
     kShareBitmapHeap_DrawOp,
     kDone_DrawOp,
 };
 /**
  *  DrawOp packs into a 32bit int as follows
  *
  *  DrawOp:8 - Flags:4 - Data:20
  *
  *  Flags and Data are called out separately, so we can reuse Data between
  *  different Ops that might have different Flags. e.g. Data might be a Paint
  *  index for both drawRect (no flags) and saveLayer (does have flags).
  *
  *  All Ops that take a SkPaint use their Data field to store the index to
  *  the paint (previously defined with kPaintOp_DrawOp).
  */
 #define DRAWOPS_OP_BITS     8
 #define DRAWOPS_FLAG_BITS   4
 #define DRAWOPS_DATA_BITS   20
 #define DRAWOPS_OP_MASK     ((1 << DRAWOPS_OP_BITS) - 1)
 #define DRAWOPS_FLAG_MASK   ((1 << DRAWOPS_FLAG_BITS) - 1)
 #define DRAWOPS_DATA_MASK   ((1 << DRAWOPS_DATA_BITS) - 1)
 static inline unsigned DrawOp_unpackOp(uint32_t op32) {
     return (op32 >> (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS));
 }
 static inline unsigned DrawOp_unpackFlags(uint32_t op32) {
     return (op32 >> DRAWOPS_DATA_BITS) & DRAWOPS_FLAG_MASK;
 }
 static inline unsigned DrawOp_unpackData(uint32_t op32) {
     return op32 & DRAWOPS_DATA_MASK;
 }
 static inline uint32_t DrawOp_packOpFlagData(DrawOps op, unsigned flags, unsigned data) {
     SkASSERT(0 == (op & ~DRAWOPS_OP_MASK));
     SkASSERT(0 == (flags & ~DRAWOPS_FLAG_MASK));
     SkASSERT(0 == (data & ~DRAWOPS_DATA_MASK));
     return (op << (DRAWOPS_FLAG_BITS + DRAWOPS_DATA_BITS)) |
            (flags << DRAWOPS_DATA_BITS) |
             data;
 }
 /** DrawOp specific flag bits
  */
 enum {
     kSaveLayer_HasBounds_DrawOpFlag = 1 << 0,
     kSaveLayer_HasPaint_DrawOpFlag = 1 << 1,
 };
 enum {
     kClear_HasColor_DrawOpFlag  = 1 << 0
 };
 enum {
     kDrawTextOnPath_HasMatrix_DrawOpFlag = 1 << 0
 };
 enum {
     kDrawVertices_HasTexs_DrawOpFlag     = 1 << 0,
     kDrawVertices_HasColors_DrawOpFlag   = 1 << 1,
     kDrawVertices_HasIndices_DrawOpFlag  = 1 << 2,
     kDrawVertices_HasXfermode_DrawOpFlag = 1 << 3,
 };
 enum {
     kDrawBitmap_HasPaint_DrawOpFlag   = 1 << 0,
     // Specific to drawBitmapRect, but needs to be different from HasPaint,
     // which is used for all drawBitmap calls, so include it here.
     kDrawBitmap_HasSrcRect_DrawOpFlag = 1 << 1,
     // SkCanvas::DrawBitmapRectFlags::kBleed_DrawBitmapRectFlag is
     // converted into and out of this flag to save space
     kDrawBitmap_Bleed_DrawOpFlag      = 1 << 2,
 };
 enum {
     kClip_HasAntiAlias_DrawOpFlag = 1 << 0,
 };
 ///////////////////////////////////////////////////////////////////////////////
 class BitmapInfo : SkNoncopyable {
 public:
     BitmapInfo(SkBitmap* bitmap, uint32_t genID, int toBeDrawnCount)
         : fBitmap(bitmap)
         , fGenID(genID)
         , fBytesAllocated(0)
         , fMoreRecentlyUsed(NULL)
         , fLessRecentlyUsed(NULL)
         , fToBeDrawnCount(toBeDrawnCount)
     {}
     ~BitmapInfo() {
         SkASSERT(0 == fToBeDrawnCount);
         SkDELETE(fBitmap);
     }
     void addDraws(int drawsToAdd) {
         if (0 == fToBeDrawnCount) {
             // The readers will only ever decrement the count, so once the
             // count is zero, the writer will be the only one modifying it,
             // so it does not need to be an atomic operation.
             fToBeDrawnCount = drawsToAdd;
         } else {
             sk_atomic_add(&fToBeDrawnCount, drawsToAdd);
         }
     }
     void decDraws() {
         sk_atomic_dec(&fToBeDrawnCount);
     }
     int drawCount() const {
         return fToBeDrawnCount;
     }
     SkBitmap* fBitmap;
     // Store the generation ID of the original bitmap, since copying does
     // not copy this field, so fBitmap's generation ID will not be useful
     // for comparing.
     // FIXME: Is it reasonable to make copying a bitmap/pixelref copy the
     // generation ID?
     uint32_t fGenID;
     // Keep track of the bytes allocated for this bitmap. When replacing the
     // bitmap or removing this BitmapInfo we know how much memory has been
     // reclaimed.
     size_t fBytesAllocated;
     // TODO: Generalize the LRU caching mechanism
     BitmapInfo* fMoreRecentlyUsed;
     BitmapInfo* fLessRecentlyUsed;
 private:
     int      fToBeDrawnCount;
 };
 static inline bool shouldFlattenBitmaps(uint32_t flags) {
     return SkToBool(flags & SkGPipeWriter::kCrossProcess_Flag
             && !(flags & SkGPipeWriter::kSharedAddressSpace_Flag));
 }
 ///////////////////////////////////////////////////////////////////////////////
 enum PaintOps {
     kReset_PaintOp,     // no arg
     kFlags_PaintOp,     // arg inline
     kColor_PaintOp,     // arg 32
     kStyle_PaintOp,     // arg inline
     kJoin_PaintOp,      // arg inline
     kCap_PaintOp,       // arg inline
     kWidth_PaintOp,     // arg scalar
     kMiter_PaintOp,     // arg scalar
     kEncoding_PaintOp,  // arg inline - text
     kHinting_PaintOp,   // arg inline - text
     kAlign_PaintOp,     // arg inline - text
     kTextSize_PaintOp,  // arg scalar - text
     kTextScaleX_PaintOp,// arg scalar - text
     kTextSkewX_PaintOp, // arg scalar - text
     kTypeface_PaintOp,  // arg inline (index) - text
     kFlatIndex_PaintOp, // flags=paintflat, data=index
 };
 #define PAINTOPS_OP_BITS     8
 #define PAINTOPS_FLAG_BITS   4
 #define PAINTOPS_DATA_BITS   20
 #define PAINTOPS_OP_MASK     ((1 << PAINTOPS_OP_BITS) - 1)
 #define PAINTOPS_FLAG_MASK   ((1 << PAINTOPS_FLAG_BITS) - 1)
 #define PAINTOPS_DATA_MASK   ((1 << PAINTOPS_DATA_BITS) - 1)
 static inline unsigned PaintOp_unpackOp(uint32_t op32) {
     return (op32 >> (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS));
 }
 static inline unsigned PaintOp_unpackFlags(uint32_t op32) {
     return (op32 >> PAINTOPS_DATA_BITS) & PAINTOPS_FLAG_MASK;
 }
 static inline unsigned PaintOp_unpackData(uint32_t op32) {
     return op32 & PAINTOPS_DATA_MASK;
 }
 static inline uint32_t PaintOp_packOp(PaintOps op) {
     SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
     return op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS);
 }
 static inline uint32_t PaintOp_packOpData(PaintOps op, unsigned data) {
     SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
     SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
     return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) | data;
 }
 static inline uint32_t PaintOp_packOpFlagData(PaintOps op, unsigned flags, unsigned data) {
     SkASSERT(0 == (op & ~PAINTOPS_OP_MASK));
     SkASSERT(0 == (flags & ~PAINTOPS_FLAG_MASK));
     SkASSERT(0 == (data & ~PAINTOPS_DATA_MASK));
     return (op << (PAINTOPS_FLAG_BITS + PAINTOPS_DATA_BITS)) |
     (flags << PAINTOPS_DATA_BITS) |
     data;
 }
 #endif

The Tor Browser / annotate

gfx/skia/trunk/src/pipe/SkGPipePriv.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pipe/SkGPipePriv.h