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

gfx/skia/trunk/src/core/SkPicturePlayback.h@129ffea94266 (annotated)

gfx/skia/trunk/src/core/SkPicturePlayback.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 SkPicturePlayback_DEFINED
 #define SkPicturePlayback_DEFINED
 #include "SkPicture.h"
 #include "SkReader32.h"
 #include "SkBitmap.h"
 #include "SkData.h"
 #include "SkMatrix.h"
 #include "SkReadBuffer.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkPathHeap.h"
 #include "SkRegion.h"
 #include "SkRRect.h"
 #include "SkPictureFlat.h"
 #ifdef SK_BUILD_FOR_ANDROID
 #include "SkThread.h"
 #endif
 class SkPictureRecord;
 class SkStream;
 class SkWStream;
 class SkBBoxHierarchy;
 class SkPictureStateTree;
 class SkOffsetTable;
 struct SkPictInfo {
     enum Flags {
         kCrossProcess_Flag      = 1 << 0,
         kScalarIsFloat_Flag     = 1 << 1,
         kPtrIs64Bit_Flag        = 1 << 2,
     };
     char        fMagic[8];
     uint32_t    fVersion;
     uint32_t    fWidth;
     uint32_t    fHeight;
     uint32_t    fFlags;
 };
 #define SK_PICT_READER_TAG     SkSetFourByteTag('r', 'e', 'a', 'd')
 #define SK_PICT_FACTORY_TAG    SkSetFourByteTag('f', 'a', 'c', 't')
 #define SK_PICT_TYPEFACE_TAG   SkSetFourByteTag('t', 'p', 'f', 'c')
 #define SK_PICT_PICTURE_TAG    SkSetFourByteTag('p', 'c', 't', 'r')
 // This tag specifies the size of the ReadBuffer, needed for the following tags
 #define SK_PICT_BUFFER_SIZE_TAG     SkSetFourByteTag('a', 'r', 'a', 'y')
 // these are all inside the ARRAYS tag
 #define SK_PICT_BITMAP_BUFFER_TAG  SkSetFourByteTag('b', 't', 'm', 'p')
 #define SK_PICT_PAINT_BUFFER_TAG   SkSetFourByteTag('p', 'n', 't', ' ')
 #define SK_PICT_PATH_BUFFER_TAG    SkSetFourByteTag('p', 't', 'h', ' ')
 // Always write this guy last (with no length field afterwards)
 #define SK_PICT_EOF_TAG     SkSetFourByteTag('e', 'o', 'f', ' ')
 /**
  * Container for data that is needed to deep copy a SkPicture. The container
  * enables the data to be generated once and reused for subsequent copies.
  */
 struct SkPictCopyInfo {
     SkPictCopyInfo() : initialized(false), controller(1024) {}
     bool initialized;
     SkChunkFlatController controller;
     SkTDArray<SkFlatData*> paintData;
 };
 class SkPicturePlayback {
 public:
     SkPicturePlayback();
     SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInfo* deepCopyInfo = NULL);
     explicit SkPicturePlayback(const SkPictureRecord& record, bool deepCopy = false);
     static SkPicturePlayback* CreateFromStream(SkStream*, const SkPictInfo&,
                                                SkPicture::InstallPixelRefProc);
     static SkPicturePlayback* CreateFromBuffer(SkReadBuffer&);
     virtual ~SkPicturePlayback();
     void draw(SkCanvas& canvas, SkDrawPictureCallback*);
     void serialize(SkWStream*, SkPicture::EncodeBitmap) const;
     void flatten(SkWriteBuffer&) const;
     void dumpSize() const;
     bool containsBitmaps() const;
 #ifdef SK_BUILD_FOR_ANDROID
     // Can be called in the middle of playback (the draw() call). WIll abort the
     // drawing and return from draw() after the "current" op code is done
     void abort() { fAbortCurrentPlayback = true; }
 #endif
 protected:
     bool parseStream(SkStream*, const SkPictInfo&,
                      SkPicture::InstallPixelRefProc);
     bool parseBuffer(SkReadBuffer& buffer);
 #ifdef SK_DEVELOPER
     virtual bool preDraw(int opIndex, int type);
     virtual void postDraw(int opIndex);
 #endif
     void preLoadBitmaps(const SkTDArray<void*>& results);
 private:
     class TextContainer {
     public:
         size_t length() { return fByteLength; }
         const void* text() { return (const void*) fText; }
         size_t fByteLength;
         const char* fText;
     };
     const SkBitmap& getBitmap(SkReader32& reader) {
         const int index = reader.readInt();
         if (SkBitmapHeap::INVALID_SLOT == index) {
 #ifdef SK_DEBUG
             SkDebugf("An invalid bitmap was recorded!\n");
 #endif
             return fBadBitmap;
         }
         return (*fBitmaps)[index];
     }
     void getMatrix(SkReader32& reader, SkMatrix* matrix) {
         reader.readMatrix(matrix);
     }
     const SkPath& getPath(SkReader32& reader) {
         return (*fPathHeap)[reader.readInt() - 1];
     }
     SkPicture& getPicture(SkReader32& reader) {
         int index = reader.readInt();
         SkASSERT(index > 0 && index <= fPictureCount);
         return *fPictureRefs[index - 1];
     }
     const SkPaint* getPaint(SkReader32& reader) {
         int index = reader.readInt();
         if (index == 0) {
             return NULL;
         }
         return &(*fPaints)[index - 1];
     }
     const SkRect* getRectPtr(SkReader32& reader) {
         if (reader.readBool()) {
             return &reader.skipT<SkRect>();
         } else {
             return NULL;
         }
     }
     const SkIRect* getIRectPtr(SkReader32& reader) {
         if (reader.readBool()) {
             return &reader.skipT<SkIRect>();
         } else {
             return NULL;
         }
     }
     void getRegion(SkReader32& reader, SkRegion* region) {
         reader.readRegion(region);
     }
     void getText(SkReader32& reader, TextContainer* text) {
         size_t length = text->fByteLength = reader.readInt();
         text->fText = (const char*)reader.skip(length);
     }
     void init();
 #ifdef SK_DEBUG_SIZE
 public:
     int size(size_t* sizePtr);
     int bitmaps(size_t* size);
     int paints(size_t* size);
     int paths(size_t* size);
 #endif
 #ifdef SK_DEBUG_DUMP
 private:
     void dumpBitmap(const SkBitmap& bitmap) const;
     void dumpMatrix(const SkMatrix& matrix) const;
     void dumpPaint(const SkPaint& paint) const;
     void dumpPath(const SkPath& path) const;
     void dumpPicture(const SkPicture& picture) const;
     void dumpRegion(const SkRegion& region) const;
     int dumpDrawType(char* bufferPtr, char* buffer, DrawType drawType);
     int dumpInt(char* bufferPtr, char* buffer, char* name);
     int dumpRect(char* bufferPtr, char* buffer, char* name);
     int dumpPoint(char* bufferPtr, char* buffer, char* name);
     void dumpPointArray(char** bufferPtrPtr, char* buffer, int count);
     int dumpPtr(char* bufferPtr, char* buffer, char* name, void* ptr);
     int dumpRectPtr(char* bufferPtr, char* buffer, char* name);
     int dumpScalar(char* bufferPtr, char* buffer, char* name);
     void dumpText(char** bufferPtrPtr, char* buffer);
     void dumpStream();
 public:
     void dump() const;
 #endif
 private:    // these help us with reading/writing
     bool parseStreamTag(SkStream*, const SkPictInfo&, uint32_t tag, size_t size,
                         SkPicture::InstallPixelRefProc);
     bool parseBufferTag(SkReadBuffer&, uint32_t tag, size_t size);
     void flattenToBuffer(SkWriteBuffer&) const;
 private:
     // Only used by getBitmap() if the passed in index is SkBitmapHeap::INVALID_SLOT. This empty
     // bitmap allows playback to draw nothing and move on.
     SkBitmap fBadBitmap;
     SkAutoTUnref<SkBitmapHeap> fBitmapHeap;
     SkAutoTUnref<SkPathHeap> fPathHeap;
     SkTRefArray<SkBitmap>* fBitmaps;
     SkTRefArray<SkPaint>* fPaints;
     SkData* fOpData;    // opcodes and parameters
     SkAutoTUnref<SkOffsetTable> fBitmapUseOffsets;
     SkPicture** fPictureRefs;
     int fPictureCount;
     SkBBoxHierarchy* fBoundingHierarchy;
     SkPictureStateTree* fStateTree;
     SkTypefacePlayback fTFPlayback;
     SkFactoryPlayback* fFactoryPlayback;
 #ifdef SK_BUILD_FOR_ANDROID
     SkMutex fDrawMutex;
     bool fAbortCurrentPlayback;
 #endif
 };
 #endif

The Tor Browser / annotate

gfx/skia/trunk/src/core/SkPicturePlayback.h@129ffea94266 (annotated)

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