Templetized SkWriter32 readTAt() & overwriteTAt()

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 "SkTSearch.h"
 #include "SkPixelRef.h"
@@ skipping 187 matching lines @@
 }
 
 bool SkPictureRecord::isDrawingToLayer() const {
     return fFirstSavedLayerIndex != kNoSavedLayerIndex;
 }
 
 /*
  * Read the op code from 'offset' in 'writer' and extract the size too.
  */
 static DrawType peek_op_and_size(SkWriter32* writer, int32_t offset, uint32_t* size) {
-    uint32_t peek = writer->read32At(offset);
+    uint32_t peek = writer->readTAt<uint32_t>(offset);
 
     uint32_t op;
     UNPACK_8_24(peek, op, *size);
     if (MASK_24 == *size) {
         // size required its own slot right after the op code
-        *size = writer->read32At(offset+kUInt32Size);
+        *size = writer->readTAt<uint32_t>(offset + kUInt32Size);
     }
     return (DrawType) op;
 }
 
 #ifdef TRACK_COLLAPSE_STATS
     static int gCollapseCount, gCollapseCalls;
 #endif
 
 // Is the supplied paint simply a color?
 static bool is_simple(const SkPaint& p) {
@@ skipping 82 matching lines @@
  *   SAVE_LAYER
  *       DRAW_BITMAP|DRAW_BITMAP_MATRIX|DRAW_BITMAP_NINE|DRAW_BITMAP_RECT_TO_RECT
  *   RESTORE
  * where the saveLayer's color can be moved into the drawBitmap*'s paint
  */
 static bool remove_save_layer1(SkWriter32* writer, int32_t offset,
                                SkPaintDictionary* paintDict) {
     // back up to the save block
     // TODO: add a stack to track save*/restore offsets rather than searching backwards
     while (offset > 0) {
-        offset = writer->read32At(offset);
+        offset = writer->readTAt<uint32_t>(offset);
     }
 
     int pattern[] = { SAVE_LAYER, kDRAW_BITMAP_FLAVOR, /* RESTORE */ };
     CommandInfo result[SK_ARRAY_COUNT(pattern)];
 
     if (!match(writer, -offset, pattern, result, SK_ARRAY_COUNT(pattern))) {
         return false;
     }
 
     if (kSaveLayerWithBoundsSize == result[0].fSize) {
         // The saveLayer's bound can offset where the dbm is drawn
         return false;
     }
 
     return merge_savelayer_paint_into_drawbitmp(writer, paintDict,
                                                 result[0], result[1]);
 }
 
 /*
  * Convert the command code located at 'offset' to a NOOP. Leave the size
  * field alone so the NOOP can be skipped later.
  */
 static void convert_command_to_noop(SkWriter32* writer, uint32_t offset) {
-    uint32_t command = writer->read32At(offset);
-    writer->write32At(offset, (command & MASK_24) | (NOOP << 24));
+    uint32_t command = writer->readTAt<uint32_t>(offset);
+    writer->overwriteTAt((command & MASK_24) | (NOOP << 24), offset);
 }
 
 /*
  * Attempt to merge the saveLayer's paint into the drawBitmap*'s paint.
  * Return true on success; false otherwise.
  */
 static bool merge_savelayer_paint_into_drawbitmp(SkWriter32* writer,
                                                  SkPaintDictionary* paintDict,
                                                  const CommandInfo& saveLayerInfo,
                                                  const CommandInfo& dbmInfo) {
     SkASSERT(SAVE_LAYER == saveLayerInfo.fActualOp);
     SkASSERT(DRAW_BITMAP == dbmInfo.fActualOp ||
              DRAW_BITMAP_MATRIX == dbmInfo.fActualOp ||
              DRAW_BITMAP_NINE == dbmInfo.fActualOp ||
              DRAW_BITMAP_RECT_TO_RECT == dbmInfo.fActualOp);
 
     uint32_t dbmPaintOffset = getPaintOffset(dbmInfo.fActualOp, dbmInfo.fSize);
     uint32_t slPaintOffset = getPaintOffset(SAVE_LAYER, saveLayerInfo.fSize);
 
     // we have a match, now we need to get the paints involved
-    uint32_t dbmPaintId = writer->read32At(dbmInfo.fOffset+dbmPaintOffset);
-    uint32_t saveLayerPaintId = writer->read32At(saveLayerInfo.fOffset+slPaintOffset);
+    uint32_t dbmPaintId = writer->readTAt<uint32_t>(dbmInfo.fOffset + dbmPaintOffset);
+    uint32_t saveLayerPaintId = writer->readTAt<uint32_t>(saveLayerInfo.fOffset + slPaintOffset);
 
     if (0 == saveLayerPaintId) {
         // In this case the saveLayer/restore isn't needed at all - just kill the saveLayer
         // and signal the caller (by returning true) to not add the RESTORE op
         convert_command_to_noop(writer, saveLayerInfo.fOffset);
         return true;
     }
 
     if (0 == dbmPaintId) {
         // In this case just make the DBM* use the saveLayer's paint, kill the saveLayer
         // and signal the caller (by returning true) to not add the RESTORE op
         convert_command_to_noop(writer, saveLayerInfo.fOffset);
-        writer->write32At(dbmInfo.fOffset+dbmPaintOffset, saveLayerPaintId);
+        writer->overwriteTAt(saveLayerPaintId, dbmInfo.fOffset + dbmPaintOffset);
         return true;
     }
 
     SkAutoTDelete<SkPaint> saveLayerPaint(paintDict->unflatten(saveLayerPaintId));
     if (NULL == saveLayerPaint.get() || !is_simple(*saveLayerPaint)) {
         return false;
     }
 
     // For this optimization we only fold the saveLayer and drawBitmapRect
     // together if the saveLayer's draw is simple (i.e., no fancy effects) and
@@ skipping 12 matching lines @@
                                    SkColorGetA(saveLayerPaint->getColor()));
     dbmPaint->setColor(newColor);
 
     const SkFlatData* data = paintDict->findAndReturnFlat(*dbmPaint);
     if (NULL == data) {
         return false;
     }
 
     // kill the saveLayer and alter the DBMR2R's paint to be the modified one
     convert_command_to_noop(writer, saveLayerInfo.fOffset);
-    writer->write32At(dbmInfo.fOffset+dbmPaintOffset, data->index());
+    writer->overwriteTAt(data->index(), dbmInfo.fOffset + dbmPaintOffset);
     return true;
 }
 
 /*
  * Restore has just been called (but not recorded), look back at the
  * matching save* and see if we are in the configuration:
  *   SAVE_LAYER (with NULL == bounds)
  *      SAVE
  *         CLIP_RECT
  *         DRAW_BITMAP|DRAW_BITMAP_MATRIX|DRAW_BITMAP_NINE|DRAW_BITMAP_RECT_TO_RECT
  *      RESTORE
  *   RESTORE
  * where the saveLayer's color can be moved into the drawBitmap*'s paint
  */
 static bool remove_save_layer2(SkWriter32* writer, int32_t offset,
                                SkPaintDictionary* paintDict) {
 
     // back up to the save block
     // TODO: add a stack to track save*/restore offsets rather than searching backwards
     while (offset > 0) {
-        offset = writer->read32At(offset);
+        offset = writer->readTAt<uint32_t>(offset);
     }
 
     int pattern[] = { SAVE_LAYER, SAVE, CLIP_RECT, kDRAW_BITMAP_FLAVOR, RESTORE, /* RESTORE */ };
     CommandInfo result[SK_ARRAY_COUNT(pattern)];
 
     if (!match(writer, -offset, pattern, result, SK_ARRAY_COUNT(pattern))) {
         return false;
     }
 
     if (kSaveLayerWithBoundsSize == result[0].fSize) {
@@ skipping 16 matching lines @@
 static bool collapse_save_clip_restore(SkWriter32* writer, int32_t offset,
                                        SkPaintDictionary* paintDict) {
 #ifdef TRACK_COLLAPSE_STATS
     gCollapseCalls += 1;
 #endif
 
     int32_t restoreOffset = (int32_t)writer->bytesWritten();
 
     // back up to the save block
     while (offset > 0) {
-        offset = writer->read32At(offset);
+        offset = writer->readTAt<uint32_t>(offset);
     }
 
     // now offset points to a save
     offset = -offset;
     uint32_t opSize;
     DrawType op = peek_op_and_size(writer, offset, &opSize);
     if (SAVE_LAYER == op) {
         // not ready to cull these out yet (mrr)
         return false;
     }
     SkASSERT(SAVE == op);
     SkASSERT(kSaveSize == opSize);
 
     // get the save flag (last 4-bytes of the space allocated for the opSize)
-    SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags) writer->read32At(offset+4);
+    SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags) writer->readTAt<uint32_t>(offset + 4);
     if (SkCanvas::kMatrixClip_SaveFlag != saveFlags) {
         // This function's optimization is only correct for kMatrixClip style saves.
         // TODO: set checkMatrix & checkClip booleans here and then check for the
         // offending operations in the following loop.
         return false;
     }
 
     // Walk forward until we get back to either a draw-verb (abort) or we hit
     // our restore (success).
     int32_t saveOffset = offset;
@@ skipping 202 matching lines @@
             return false;
         default:
             SkDEBUGFAIL("unknown region op");
             return false;
     }
 }
 
 void SkPictureRecord::fillRestoreOffsetPlaceholdersForCurrentStackLevel(uint32_t restoreOffset) {
     int32_t offset = fRestoreOffsetStack.top();
     while (offset > 0) {
-        uint32_t peek = fWriter.read32At(offset);
-        fWriter.write32At(offset, restoreOffset);
+        uint32_t peek = fWriter.readTAt<uint32_t>(offset);
+        fWriter.overwriteTAt(restoreOffset, offset);
         offset = peek;
     }
 
 #ifdef SK_DEBUG
     // assert that the final offset value points to a save verb
     uint32_t opSize;
     DrawType drawOp = peek_op_and_size(&fWriter, -offset, &opSize);
     SkASSERT(SAVE == drawOp || SAVE_LAYER == drawOp);
 #endif
 }
@@ skipping 845 matching lines @@
 void SkPictureRecord::validateRegions() const {
     int count = fRegions.count();
     SkASSERT((unsigned) count < 0x1000);
     for (int index = 0; index < count; index++) {
         const SkFlatData* region = fRegions[index];
         SkASSERT(region);
 //        region->validate();
     }
 }
 #endif