remove now defunct get_paint_offset

src/core/SkPictureRecord.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPictureRecord.h"
 #include "SkDevice.h"
 #include "SkImage_Base.h"
 #include "SkPatchUtils.h"
 #include "SkPixelRef.h"
 #include "SkRRect.h"
 #include "SkRSXform.h"
 #include "SkTextBlob.h"
 #include "SkTSearch.h"
 
 #define HEAP_BLOCK_SIZE 4096
 
 enum {
     // just need a value that save or getSaveCount would never return
     kNoInitialSave = -1,
 };
 
 // A lot of basic types get stored as a uint32_t: bools, ints, paint indices, etc.
 static int const kUInt32Size = 4;
 
-static const uint32_t kSaveSize = kUInt32Size;
-#ifdef SK_DEBUG
-static const uint32_t kSaveLayerNoBoundsSize = 4 * kUInt32Size;
-static const uint32_t kSaveLayerWithBoundsSize = 4 * kUInt32Size + sizeof(SkRect);
-#endif//SK_DEBUG
-
 SkPictureRecord::SkPictureRecord(const SkISize& dimensions, uint32_t flags)
     : INHERITED(dimensions.width(), dimensions.height())
     , fRecordFlags(flags)
     , fInitialSaveCount(kNoInitialSave) {
 }
 
 SkPictureRecord::~SkPictureRecord() {
     fImageRefs.unrefAll();
     fPictureRefs.unrefAll();
     fTextBlobRefs.unrefAll();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifdef SK_DEBUG
-// Return the offset of the paint inside a given op's byte stream. A zero
-// return value means there is no paint (and you really shouldn't be calling
-// this method)
-static inline size_t get_paint_offset(DrawType op, size_t opSize) {
-    // These offsets are where the paint would be if the op size doesn't overflow
-    static const uint8_t gPaintOffsets[] = {
-        0,  // UNUSED - no paint
-        0,  // CLIP_PATH - no paint
-        0,  // CLIP_REGION - no paint
-        0,  // CLIP_RECT - no paint
-        0,  // CLIP_RRECT - no paint
-        0,  // CONCAT - no paint
-        1,  // DRAW_BITMAP - right after op code
-        1,  // DRAW_BITMAP_MATRIX - right after op code, deprecated
-        1,  // DRAW_BITMAP_NINE - right after op code
-        1,  // DRAW_BITMAP_RECT - right after op code
-        0,  // DRAW_CLEAR - no paint
-        0,  // DRAW_DATA - no paint
-        1,  // DRAW_OVAL - right after op code
-        1,  // DRAW_PAINT - right after op code
-        1,  // DRAW_PATH - right after op code
-        0,  // DRAW_PICTURE - no paint
-        1,  // DRAW_POINTS - right after op code
-        1,  // DRAW_POS_TEXT - right after op code
-        1,  // DRAW_POS_TEXT_TOP_BOTTOM - right after op code
-        1,  // DRAW_POS_TEXT_H - right after op code
-        1,  // DRAW_POS_TEXT_H_TOP_BOTTOM - right after op code
-        1,  // DRAW_RECT - right after op code
-        1,  // DRAW_RRECT - right after op code
-        1,  // DRAW_SPRITE - right after op code
-        1,  // DRAW_TEXT - right after op code
-        1,  // DRAW_TEXT_ON_PATH - right after op code
-        1,  // DRAW_TEXT_TOP_BOTTOM - right after op code
-        1,  // DRAW_VERTICES - right after op code
-        0,  // RESTORE - no paint
-        0,  // ROTATE - no paint
-        0,  // SAVE - no paint
-        0,  // SAVE_LAYER_SAVEFLAGS_DEPRECATED - see below - this paint's location varies
-        0,  // SCALE - no paint
-        0,  // SET_MATRIX - no paint
-        0,  // SKEW - no paint
-        0,  // TRANSLATE - no paint
-        0,  // NOOP - no paint
-        0,  // BEGIN_GROUP - no paint
-        0,  // COMMENT - no paint
-        0,  // END_GROUP - no paint
-        1,  // DRAWDRRECT - right after op code
-        0,  // PUSH_CULL - no paint
-        0,  // POP_CULL - no paint
-        1,  // DRAW_PATCH - right after op code
-        1,  // DRAW_PICTURE_MATRIX_PAINT - right after op code
-        1,  // DRAW_TEXT_BLOB- right after op code
-        1,  // DRAW_IMAGE - right after op code
-        1,  // DRAW_IMAGE_RECT_STRICT - right after op code
-        1,  // DRAW_ATLAS - right after op code
-        1,  // DRAW_IMAGE_NINE - right after op code
-        1,  // DRAW_IMAGE_RECT - right after op code
-        0,  // SAVE_LAYER_SAVELAYERFLAGS - see below - this paint's location varies
-    };
-
-    static_assert(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1, "need_to_be_in_sync");
-    SkASSERT((unsigned)op <= (unsigned)LAST_DRAWTYPE_ENUM);
-
-    int overflow = 0;
-    if (0 != (opSize & ~MASK_24) || opSize == MASK_24) {
-        // This op's size overflows so an extra uint32_t will be written
-        // after the op code
-        overflow = sizeof(uint32_t);
-    }
-
-    SkASSERT(SAVE_LAYER_SAVEFLAGS_DEPRECATED != op);
-    if (SAVE_LAYER_SAVELAYERFLAGS == op) {
-        static const uint32_t kSaveLayerNoBoundsPaintOffset = 2 * kUInt32Size;
-        static const uint32_t kSaveLayerWithBoundsPaintOffset = 2 * kUInt32Size + sizeof(SkRect);
-
-        if (kSaveLayerNoBoundsSize == opSize) {
-            return kSaveLayerNoBoundsPaintOffset + overflow;
-        } else {
-            SkASSERT(kSaveLayerWithBoundsSize == opSize);
-            return kSaveLayerWithBoundsPaintOffset + overflow;
-        }
-    }
-
-    SkASSERT(0 != gPaintOffsets[op]);   // really shouldn't be calling this method
-    return gPaintOffsets[op] * sizeof(uint32_t) + overflow;
-}
-#endif//SK_DEBUG
-
 void SkPictureRecord::willSave() {
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
     this->recordSave();
 
     this->INHERITED::willSave();
 }
 
 void SkPictureRecord::recordSave() {
     fContentInfo.onSave();
 
     // op only
-    size_t size = kSaveSize;
+    size_t size = sizeof(kUInt32Size);
     size_t initialOffset = this->addDraw(SAVE, &size);
 
     this->validate(initialOffset, size);
 }
 
 SkCanvas::SaveLayerStrategy SkPictureRecord::getSaveLayerStrategy(const SaveLayerRec& rec) {
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.bytesWritten());
     this->recordSaveLayer(rec);
@@ skipping 11 matching lines @@
     fContentInfo.onSaveLayer();
 
     // op + bool for 'bounds'
     size_t size = 2 * kUInt32Size;
     if (rec.fBounds) {
         size += sizeof(*rec.fBounds); // + rect
     }
     // + paint index + flags
     size += 2 * kUInt32Size;
 
-    SkASSERT(kSaveLayerNoBoundsSize == size || kSaveLayerWithBoundsSize == size);
-
     size_t initialOffset = this->addDraw(SAVE_LAYER_SAVELAYERFLAGS, &size);
     this->addRectPtr(rec.fBounds);
-    SkASSERT(initialOffset+get_paint_offset(SAVE_LAYER_SAVELAYERFLAGS, size) == fWriter.bytesWritten());
     this->addPaintPtr(rec.fPaint);
     this->addInt(rec.fSaveLayerFlags);
 
     this->validate(initialOffset, size);
 }
 
 #ifdef SK_DEBUG
 /*
  * Read the op code from 'offset' in 'writer' and extract the size too.
  */
@@ skipping 256 matching lines @@
     size_t offset = this->recordRestoreOffsetPlaceholder(op);
 
     this->validate(initialOffset, size);
     return offset;
 }
 
 void SkPictureRecord::onDrawPaint(const SkPaint& paint) {
     // op + paint index
     size_t size = 2 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_PAINT, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_PAINT, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
                                    const SkPaint& paint) {
     fContentInfo.onDrawPoints(count, paint);
 
     // op + paint index + mode + count + point data
     size_t size = 4 * kUInt32Size + count * sizeof(SkPoint);
     size_t initialOffset = this->addDraw(DRAW_POINTS, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_POINTS, size) == fWriter.bytesWritten());
     this->addPaint(paint);
 
     this->addInt(mode);
     this->addInt(SkToInt(count));
     fWriter.writeMul4(pts, count * sizeof(SkPoint));
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawOval(const SkRect& oval, const SkPaint& paint) {
     // op + paint index + rect
     size_t size = 2 * kUInt32Size + sizeof(oval);
     size_t initialOffset = this->addDraw(DRAW_OVAL, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_OVAL, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addRect(oval);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawRect(const SkRect& rect, const SkPaint& paint) {
     // op + paint index + rect
     size_t size = 2 * kUInt32Size + sizeof(rect);
     size_t initialOffset = this->addDraw(DRAW_RECT, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_RECT, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addRect(rect);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) {
     // op + paint index + rrect
     size_t size = 2 * kUInt32Size + SkRRect::kSizeInMemory;
     size_t initialOffset = this->addDraw(DRAW_RRECT, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_RRECT, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addRRect(rrect);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
                                    const SkPaint& paint) {
     // op + paint index + rrects
     size_t size = 2 * kUInt32Size + SkRRect::kSizeInMemory * 2;
     size_t initialOffset = this->addDraw(DRAW_DRRECT, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_DRRECT, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addRRect(outer);
     this->addRRect(inner);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawPath(const SkPath& path, const SkPaint& paint) {
     fContentInfo.onDrawPath(path, paint);
 
     // op + paint index + path index
     size_t size = 3 * kUInt32Size;
     size_t initialOffset = this->addDraw(DRAW_PATH, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_PATH, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addPath(path);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                                    const SkPaint* paint) {
     // op + paint index + bitmap index + left + top
     size_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(DRAW_BITMAP, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_BITMAP, size) == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addBitmap(bitmap);
     this->addScalar(left);
     this->addScalar(top);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
                                        const SkPaint* paint, SrcRectConstraint constraint) {
     // id + paint index + bitmap index + bool for 'src' + flags
     size_t size = 5 * kUInt32Size;
     if (src) {
         size += sizeof(*src);   // + rect
     }
     size += sizeof(dst);        // + rect
 
     size_t initialOffset = this->addDraw(DRAW_BITMAP_RECT, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_BITMAP_RECT, size) == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addBitmap(bitmap);
     this->addRectPtr(src);  // may be null
     this->addRect(dst);
     this->addInt(constraint);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawImage(const SkImage* image, SkScalar x, SkScalar y,
                                   const SkPaint* paint) {
     // op + paint_index + image_index + x + y
     size_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(DRAW_IMAGE, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_IMAGE, size) == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addImage(image);
     this->addScalar(x);
     this->addScalar(y);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                                       const SkPaint* paint, SrcRectConstraint constraint) {
     // id + paint_index + image_index + bool_for_src + constraint
     size_t size = 5 * kUInt32Size;
     if (src) {
         size += sizeof(*src);   // + rect
     }
     size += sizeof(dst);        // + rect
 
     size_t initialOffset = this->addDraw(DRAW_IMAGE_RECT, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_IMAGE_RECT, size)
-             == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addImage(image);
     this->addRectPtr(src);  // may be null
     this->addRect(dst);
     this->addInt(constraint);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawImageNine(const SkImage* img, const SkIRect& center, const SkRect& dst,
                                       const SkPaint* paint) {
     // id + paint_index + image_index + center + dst
     size_t size = 3 * kUInt32Size + sizeof(SkIRect) + sizeof(SkRect);
 
     size_t initialOffset = this->addDraw(DRAW_IMAGE_NINE, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_IMAGE_NINE, size) == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addImage(img);
     this->addIRect(center);
     this->addRect(dst);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
                                        const SkRect& dst, const SkPaint* paint) {
     // op + paint index + bitmap id + center + dst rect
     size_t size = 3 * kUInt32Size + sizeof(center) + sizeof(dst);
     size_t initialOffset = this->addDraw(DRAW_BITMAP_NINE, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_BITMAP_NINE, size) == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addBitmap(bitmap);
     this->addIRect(center);
     this->addRect(dst);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                                  const SkPaint& paint) {
     // op + paint index + length + 'length' worth of chars + x + y
     size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 2 * sizeof(SkScalar);
 
     DrawType op = DRAW_TEXT;
     size_t initialOffset = this->addDraw(op, &size);
-    SkASSERT(initialOffset+get_paint_offset(op, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addText(text, byteLength);
     this->addScalar(x);
     this->addScalar(y);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
                                     const SkPaint& paint) {
     int points = paint.countText(text, byteLength);
 
     // op + paint index + length + 'length' worth of data + num points + x&y point data
     size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + points * sizeof(SkPoint);
 
     DrawType op = DRAW_POS_TEXT;
 
     size_t initialOffset = this->addDraw(op, &size);
-    SkASSERT(initialOffset+get_paint_offset(op, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addText(text, byteLength);
     this->addInt(points);
     fWriter.writeMul4(pos, points * sizeof(SkPoint));
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
                                      SkScalar constY, const SkPaint& paint) {
     int points = paint.countText(text, byteLength);
@@ skipping 11 matching lines @@
     fWriter.writeMul4(xpos, points * sizeof(SkScalar));
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
                                        const SkMatrix* matrix, const SkPaint& paint) {
     // op + paint index + length + 'length' worth of data + path index + matrix
     const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
     size_t size = 3 * kUInt32Size + SkAlign4(byteLength) + kUInt32Size + m.writeToMemory(nullptr);
     size_t initialOffset = this->addDraw(DRAW_TEXT_ON_PATH, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_TEXT_ON_PATH, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addText(text, byteLength);
     this->addPath(path);
     this->addMatrix(m);
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                      const SkPaint& paint) {
 
     // op + paint index + blob index + x/y
     size_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
     size_t initialOffset = this->addDraw(DRAW_TEXT_BLOB, &size);
-    SkASSERT(initialOffset + get_paint_offset(DRAW_TEXT_BLOB, size) == fWriter.bytesWritten());
 
     this->addPaint(paint);
     this->addTextBlob(blob);
     this->addScalar(x);
     this->addScalar(y);
 
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                                     const SkPaint* paint) {
     // op + picture index
     size_t size = 2 * kUInt32Size;
     size_t initialOffset;
 
     if (nullptr == matrix && nullptr == paint) {
         initialOffset = this->addDraw(DRAW_PICTURE, &size);
         this->addPicture(picture);
     } else {
         const SkMatrix& m = matrix ? *matrix : SkMatrix::I();
         size += m.writeToMemory(nullptr) + kUInt32Size;    // matrix + paint
         initialOffset = this->addDraw(DRAW_PICTURE_MATRIX_PAINT, &size);
-        SkASSERT(initialOffset + get_paint_offset(DRAW_PICTURE_MATRIX_PAINT, size)
-                 == fWriter.bytesWritten());
         this->addPaintPtr(paint);
         this->addMatrix(m);
         this->addPicture(picture);
     }
     this->validate(initialOffset, size);
 }
 
 void SkPictureRecord::onDrawVertices(VertexMode vmode, int vertexCount,
                                      const SkPoint vertices[], const SkPoint texs[],
                                      const SkColor colors[], SkXfermode* xfer,
@@ skipping 26 matching lines @@
     }
     if (flags & DRAW_VERTICES_HAS_INDICES) {
         // + num indices + indices
         size += 1 * kUInt32Size + SkAlign4(indexCount * sizeof(uint16_t));
     }
     if (flags & DRAW_VERTICES_HAS_XFER) {
         size += kUInt32Size;    // mode enum
     }
 
     size_t initialOffset = this->addDraw(DRAW_VERTICES, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_VERTICES, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addInt(flags);
     this->addInt(vmode);
     this->addInt(vertexCount);
     this->addPoints(vertices, vertexCount);
     if (flags & DRAW_VERTICES_HAS_TEXS) {
         this->addPoints(texs, vertexCount);
     }
     if (flags & DRAW_VERTICES_HAS_COLORS) {
         fWriter.writeMul4(colors, vertexCount * sizeof(SkColor));
@@ skipping 26 matching lines @@
     }
     if (xmode) {
         SkXfermode::Mode mode;
         if (xmode->asMode(&mode) && SkXfermode::kModulate_Mode != mode) {
             flag |= DRAW_VERTICES_HAS_XFER;
             size += kUInt32Size;
         }
     }
 
     size_t initialOffset = this->addDraw(DRAW_PATCH, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_PATCH, size) == fWriter.bytesWritten());
     this->addPaint(paint);
     this->addPatch(cubics);
     this->addInt(flag);
 
     // write optional parameters
     if (colors) {
         fWriter.write(colors, SkPatchUtils::kNumCorners * sizeof(SkColor));
     }
     if (texCoords) {
         fWriter.write(texCoords, SkPatchUtils::kNumCorners * sizeof(SkPoint));
@@ skipping 16 matching lines @@
         flags |= DRAW_ATLAS_HAS_COLORS;
         size += count * sizeof(SkColor);
         size += sizeof(uint32_t);   // xfermode::mode
     }
     if (cull) {
         flags |= DRAW_ATLAS_HAS_CULL;
         size += sizeof(SkRect);
     }
 
     size_t initialOffset = this->addDraw(DRAW_ATLAS, &size);
-    SkASSERT(initialOffset+get_paint_offset(DRAW_ATLAS, size) == fWriter.bytesWritten());
     this->addPaintPtr(paint);
     this->addImage(atlas);
     this->addInt(flags);
     this->addInt(count);
     fWriter.write(xform, count * sizeof(SkRSXform));
     fWriter.write(tex, count * sizeof(SkRect));
 
     // write optional parameters
     if (colors) {
         fWriter.write(colors, count * sizeof(SkColor));
@@ skipping 185 matching lines @@
 void SkPictureRecord::addTextBlob(const SkTextBlob *blob) {
     int index = fTextBlobRefs.count();
     *fTextBlobRefs.append() = blob;
     blob->ref();
     // follow the convention of recording a 1-based index
     this->addInt(index + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////