The Tor Browser: gfx/skia/trunk/src/core/SkPicture.cpp@deefc01c0e14 (annotated)

gfx/skia/trunk/src/core/SkPicture.cpp@deefc01c0e14 (annotated)

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

Thu, 15 Jan 2015 21:03:48 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 21:03:48 +0100
branch: TOR_BUG_9701
changeset 11: deefc01c0e14
permissions: -rw-r--r--

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

 /*
  * Copyright 2007 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 "SkPictureFlat.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkChunkAlloc.h"
 #include "SkPicture.h"
 #include "SkRegion.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTSearch.h"
 #include "SkTime.h"
 #include "SkReader32.h"
 #include "SkWriter32.h"
 #include "SkRTree.h"
 #include "SkBBoxHierarchyRecord.h"
 #define DUMP_BUFFER_SIZE 65536
 //#define ENABLE_TIME_DRAW    // dumps milliseconds for each draw
 #ifdef SK_DEBUG
 // enable SK_DEBUG_TRACE to trace DrawType elements when
 //     recorded and played back
 // #define SK_DEBUG_TRACE
 // enable SK_DEBUG_SIZE to see the size of picture components
 // #define SK_DEBUG_SIZE
 // enable SK_DEBUG_DUMP to see the contents of recorded elements
 // #define SK_DEBUG_DUMP
 // enable SK_DEBUG_VALIDATE to check internal structures for consistency
 // #define SK_DEBUG_VALIDATE
 #endif
 #if defined SK_DEBUG_TRACE || defined SK_DEBUG_DUMP
 const char* DrawTypeToString(DrawType drawType) {
     switch (drawType) {
         case UNUSED: SkDebugf("DrawType UNUSED\n"); SkASSERT(0); break;
         case CLIP_PATH: return "CLIP_PATH";
         case CLIP_REGION: return "CLIP_REGION";
         case CLIP_RECT: return "CLIP_RECT";
         case CLIP_RRECT: return "CLIP_RRECT";
         case CONCAT: return "CONCAT";
         case DRAW_BITMAP: return "DRAW_BITMAP";
         case DRAW_BITMAP_MATRIX: return "DRAW_BITMAP_MATRIX";
         case DRAW_BITMAP_NINE: return "DRAW_BITMAP_NINE";
         case DRAW_BITMAP_RECT_TO_RECT: return "DRAW_BITMAP_RECT_TO_RECT";
         case DRAW_CLEAR: return "DRAW_CLEAR";
         case DRAW_DATA: return "DRAW_DATA";
         case DRAW_OVAL: return "DRAW_OVAL";
         case DRAW_PAINT: return "DRAW_PAINT";
         case DRAW_PATH: return "DRAW_PATH";
         case DRAW_PICTURE: return "DRAW_PICTURE";
         case DRAW_POINTS: return "DRAW_POINTS";
         case DRAW_POS_TEXT: return "DRAW_POS_TEXT";
         case DRAW_POS_TEXT_TOP_BOTTOM: return "DRAW_POS_TEXT_TOP_BOTTOM";
         case DRAW_POS_TEXT_H: return "DRAW_POS_TEXT_H";
         case DRAW_POS_TEXT_H_TOP_BOTTOM: return "DRAW_POS_TEXT_H_TOP_BOTTOM";
         case DRAW_RECT: return "DRAW_RECT";
         case DRAW_RRECT: return "DRAW_RRECT";
         case DRAW_SPRITE: return "DRAW_SPRITE";
         case DRAW_TEXT: return "DRAW_TEXT";
         case DRAW_TEXT_ON_PATH: return "DRAW_TEXT_ON_PATH";
         case DRAW_TEXT_TOP_BOTTOM: return "DRAW_TEXT_TOP_BOTTOM";
         case DRAW_VERTICES: return "DRAW_VERTICES";
         case RESTORE: return "RESTORE";
         case ROTATE: return "ROTATE";
         case SAVE: return "SAVE";
         case SAVE_LAYER: return "SAVE_LAYER";
         case SCALE: return "SCALE";
         case SET_MATRIX: return "SET_MATRIX";
         case SKEW: return "SKEW";
         case TRANSLATE: return "TRANSLATE";
         case NOOP: return "NOOP";
         default:
             SkDebugf("DrawType error 0x%08x\n", drawType);
             SkASSERT(0);
             break;
     }
     SkASSERT(0);
     return NULL;
 }
 #endif
 #ifdef SK_DEBUG_VALIDATE
 static void validateMatrix(const SkMatrix* matrix) {
     SkScalar scaleX = matrix->getScaleX();
     SkScalar scaleY = matrix->getScaleY();
     SkScalar skewX = matrix->getSkewX();
     SkScalar skewY = matrix->getSkewY();
     SkScalar perspX = matrix->getPerspX();
     SkScalar perspY = matrix->getPerspY();
     if (scaleX != 0 && skewX != 0)
         SkDebugf("scaleX != 0 && skewX != 0\n");
     SkASSERT(scaleX == 0 || skewX == 0);
     SkASSERT(scaleY == 0 || skewY == 0);
     SkASSERT(perspX == 0);
     SkASSERT(perspY == 0);
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////
 SkPicture::SkPicture() {
     fRecord = NULL;
     fPlayback = NULL;
     fWidth = fHeight = 0;
     fAccelData = NULL;
 }
 SkPicture::SkPicture(const SkPicture& src)
     : INHERITED()
     , fAccelData(NULL) {
     fWidth = src.fWidth;
     fHeight = src.fHeight;
     fRecord = NULL;
     /*  We want to copy the src's playback. However, if that hasn't been built
         yet, we need to fake a call to endRecording() without actually calling
         it (since it is destructive, and we don't want to change src).
      */
     if (src.fPlayback) {
         fPlayback = SkNEW_ARGS(SkPicturePlayback, (*src.fPlayback));
     } else if (src.fRecord) {
         // here we do a fake src.endRecording()
         fPlayback = SkNEW_ARGS(SkPicturePlayback, (*src.fRecord));
     } else {
         fPlayback = NULL;
     }
 }
 SkPicture::~SkPicture() {
     SkSafeUnref(fRecord);
     SkDELETE(fPlayback);
     SkSafeUnref(fAccelData);
 }
 void SkPicture::internalOnly_EnableOpts(bool enableOpts) {
     if (NULL != fRecord) {
         fRecord->internalOnly_EnableOpts(enableOpts);
     }
 }
 void SkPicture::swap(SkPicture& other) {
     SkTSwap(fRecord, other.fRecord);
     SkTSwap(fPlayback, other.fPlayback);
     SkTSwap(fAccelData, other.fAccelData);
     SkTSwap(fWidth, other.fWidth);
     SkTSwap(fHeight, other.fHeight);
 }
 SkPicture* SkPicture::clone() const {
     SkPicture* clonedPicture = SkNEW(SkPicture);
     clone(clonedPicture, 1);
     return clonedPicture;
 }
 void SkPicture::clone(SkPicture* pictures, int count) const {
     SkPictCopyInfo copyInfo;
     for (int i = 0; i < count; i++) {
         SkPicture* clone = &pictures[i];
         clone->fWidth = fWidth;
         clone->fHeight = fHeight;
         SkSafeSetNull(clone->fRecord);
         SkDELETE(clone->fPlayback);
         /*  We want to copy the src's playback. However, if that hasn't been built
             yet, we need to fake a call to endRecording() without actually calling
             it (since it is destructive, and we don't want to change src).
          */
         if (fPlayback) {
             clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fPlayback, &copyInfo));
         } else if (fRecord) {
             // here we do a fake src.endRecording()
             clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fRecord, true));
         } else {
             clone->fPlayback = NULL;
         }
     }
 }
 SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
     static int32_t gNextID = 0;
     int32_t id = sk_atomic_inc(&gNextID);
     if (id >= 1 << (8 * sizeof(Domain))) {
         SK_CRASH();
     }
     return static_cast<Domain>(id);
 }
 ///////////////////////////////////////////////////////////////////////////////
 SkCanvas* SkPicture::beginRecording(int width, int height,
                                     uint32_t recordingFlags) {
     if (fPlayback) {
         SkDELETE(fPlayback);
         fPlayback = NULL;
     }
     SkSafeUnref(fAccelData);
     SkSafeSetNull(fRecord);
     // Must be set before calling createBBoxHierarchy
     fWidth = width;
     fHeight = height;
     const SkISize size = SkISize::Make(width, height);
     if (recordingFlags & kOptimizeForClippedPlayback_RecordingFlag) {
         SkBBoxHierarchy* tree = this->createBBoxHierarchy();
         SkASSERT(NULL != tree);
         fRecord = SkNEW_ARGS(SkBBoxHierarchyRecord, (size, recordingFlags, tree));
         tree->unref();
     } else {
         fRecord = SkNEW_ARGS(SkPictureRecord, (size, recordingFlags));
     }
     fRecord->beginRecording();
     return fRecord;
 }
 SkBBoxHierarchy* SkPicture::createBBoxHierarchy() const {
     // These values were empirically determined to produce reasonable
     // performance in most cases.
     static const int kRTreeMinChildren = 6;
     static const int kRTreeMaxChildren = 11;
     SkScalar aspectRatio = SkScalarDiv(SkIntToScalar(fWidth),
                                        SkIntToScalar(fHeight));
     bool sortDraws = false;  // Do not sort draw calls when bulk loading.
     return SkRTree::Create(kRTreeMinChildren, kRTreeMaxChildren,
                            aspectRatio, sortDraws);
 }
 SkCanvas* SkPicture::getRecordingCanvas() const {
     // will be null if we are not recording
     return fRecord;
 }
 void SkPicture::endRecording() {
     if (NULL == fPlayback) {
         if (NULL != fRecord) {
             fRecord->endRecording();
             fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
             SkSafeSetNull(fRecord);
         }
     }
     SkASSERT(NULL == fRecord);
 }
 void SkPicture::draw(SkCanvas* surface, SkDrawPictureCallback* callback) {
     this->endRecording();
     if (NULL != fPlayback) {
         fPlayback->draw(*surface, callback);
     }
 }
 ///////////////////////////////////////////////////////////////////////////////
 #include "SkStream.h"
 static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
 bool SkPicture::IsValidPictInfo(const SkPictInfo& info) {
     if (0 != memcmp(info.fMagic, kMagic, sizeof(kMagic))) {
         return false;
     }
     if (info.fVersion < MIN_PICTURE_VERSION ||
         info.fVersion > CURRENT_PICTURE_VERSION) {
         return false;
     }
     return true;
 }
 bool SkPicture::InternalOnly_StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) {
     if (NULL == stream) {
         return false;
     }
     // Check magic bytes.
     SkPictInfo info;
     SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
     if (!stream->read(&info, sizeof(info)) || !IsValidPictInfo(info)) {
         return false;
     }
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 bool SkPicture::InternalOnly_BufferIsSKP(SkReadBuffer& buffer, SkPictInfo* pInfo) {
     // Check magic bytes.
     SkPictInfo info;
     SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
     if (!buffer.readByteArray(&info, sizeof(info)) || !IsValidPictInfo(info)) {
         return false;
     }
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
     : fPlayback(playback)
     , fRecord(NULL)
     , fWidth(width)
     , fHeight(height)
     , fAccelData(NULL) {}
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
         return NULL;
     }
     SkPicturePlayback* playback;
     // Check to see if there is a playback to recreate.
     if (stream->readBool()) {
         playback = SkPicturePlayback::CreateFromStream(stream, info, proc);
         if (NULL == playback) {
             return NULL;
         }
     } else {
         playback = NULL;
     }
     return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
 }
 SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
     SkPictInfo info;
     if (!InternalOnly_BufferIsSKP(buffer, &info)) {
         return NULL;
     }
     SkPicturePlayback* playback;
     // Check to see if there is a playback to recreate.
     if (buffer.readBool()) {
         playback = SkPicturePlayback::CreateFromBuffer(buffer);
         if (NULL == playback) {
             return NULL;
         }
     } else {
         playback = NULL;
     }
     return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
 }
 void SkPicture::createHeader(SkPictInfo* info) const {
     // Copy magic bytes at the beginning of the header
     SkASSERT(sizeof(kMagic) == 8);
     SkASSERT(sizeof(kMagic) == sizeof(info->fMagic));
     memcpy(info->fMagic, kMagic, sizeof(kMagic));
     // Set picture info after magic bytes in the header
     info->fVersion = CURRENT_PICTURE_VERSION;
     info->fWidth = fWidth;
     info->fHeight = fHeight;
     info->fFlags = SkPictInfo::kCrossProcess_Flag;
     // TODO: remove this flag, since we're always float (now)
     info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
     if (8 == sizeof(void*)) {
         info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
     }
 }
 void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
     SkPicturePlayback* playback = fPlayback;
     if (NULL == playback && fRecord) {
         playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
     }
     SkPictInfo header;
     this->createHeader(&header);
     stream->write(&header, sizeof(header));
     if (playback) {
         stream->writeBool(true);
         playback->serialize(stream, encoder);
         // delete playback if it is a local version (i.e. cons'd up just now)
         if (playback != fPlayback) {
             SkDELETE(playback);
         }
     } else {
         stream->writeBool(false);
     }
 }
 void SkPicture::flatten(SkWriteBuffer& buffer) const {
     SkPicturePlayback* playback = fPlayback;
     if (NULL == playback && fRecord) {
         playback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
     }
     SkPictInfo header;
     this->createHeader(&header);
     buffer.writeByteArray(&header, sizeof(header));
     if (playback) {
         buffer.writeBool(true);
         playback->flatten(buffer);
         // delete playback if it is a local version (i.e. cons'd up just now)
         if (playback != fPlayback) {
             SkDELETE(playback);
         }
     } else {
         buffer.writeBool(false);
     }
 }
 bool SkPicture::willPlayBackBitmaps() const {
     if (!fPlayback) {
         return false;
     }
     return fPlayback->containsBitmaps();
 }
 #ifdef SK_BUILD_FOR_ANDROID
 void SkPicture::abortPlayback() {
     if (NULL == fPlayback) {
         return;
     }
     fPlayback->abort();
 }
 #endif

The Tor Browser / annotate

gfx/skia/trunk/src/core/SkPicture.cpp@deefc01c0e14 (annotated)

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