Templetized SkWriter32 readTAt() & overwriteTAt()

src/pipe/SkGPipeWrite.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 "SkAnnotation.h"
 #include "SkBitmapDevice.h"
@@ skipping 439 matching lines @@
     }
 
     if (shouldFlattenBitmaps(flags)) {
         fBitmapShuttle.reset(SkNEW_ARGS(BitmapShuttle, (this)));
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap, (fBitmapShuttle.get(), BITMAPS_TO_KEEP));
     } else {
         fBitmapHeap = SkNEW_ARGS(SkBitmapHeap,
                                  (BITMAPS_TO_KEEP, controller->numberOfReaders()));
         if (this->needOpBytes(sizeof(void*))) {
             this->writeOp(kShareBitmapHeap_DrawOp);
-            fWriter.writePtr(static_cast<void*>(fBitmapHeap));
+            fWriter.writeT<void*>(fBitmapHeap);

[mtklein, 2014/02/06 21:38:16]

This guy strikes me as weird now.  If we're going to have a writeT, we shouldn't
have to say void* any more.  void* was our poor man's T*.

[f(malita), 2014/02/10 16:10:35]

Good point (mechanical refactor). Since we're not exposing writeT(), we'll have
to revert to using writePtr.

         }
     }
     fFlattenableHeap.setBitmapStorage(fBitmapHeap);
     this->doNotify();
 }
 
 SkGPipeCanvas::~SkGPipeCanvas() {
     this->finish(true);
     SkSafeUnref(fFactorySet);
     SkSafeUnref(fBitmapHeap);
@@ skipping 63 matching lines @@
         size += sizeof(SkRect);
     }
     if (paint) {
         opFlags |= kSaveLayer_HasPaint_DrawOpFlag;
         this->writePaint(*paint);
     }
 
     if (this->needOpBytes(size)) {
         this->writeOp(kSaveLayer_DrawOp, opFlags, saveFlags);
         if (bounds) {
-            fWriter.writeRect(*bounds);
+            fWriter.writeT<SkRect>(*bounds);
         }
     }
 
     if (kNoSaveLayer == fFirstSaveLayerStackLevel){
         fFirstSaveLayerStackLevel = this->getSaveCount();
     }
     // we just pass on the save, so we don't create a layer
     return this->INHERITED::save(saveFlags);
 }
 
@@ skipping 12 matching lines @@
 
 bool SkGPipeCanvas::isDrawingToLayer() const {
     return kNoSaveLayer != fFirstSaveLayerStackLevel;
 }
 
 bool SkGPipeCanvas::translate(SkScalar dx, SkScalar dy) {
     if (dx || dy) {
         NOTIFY_SETUP(this);
         if (this->needOpBytes(2 * sizeof(SkScalar))) {
             this->writeOp(kTranslate_DrawOp);
-            fWriter.writeScalar(dx);
-            fWriter.writeScalar(dy);
+            fWriter.writeT<SkScalar>(dx);
+            fWriter.writeT<SkScalar>(dy);
         }
     }
     return this->INHERITED::translate(dx, dy);
 }
 
 bool SkGPipeCanvas::scale(SkScalar sx, SkScalar sy) {
     if (sx || sy) {
         NOTIFY_SETUP(this);
         if (this->needOpBytes(2 * sizeof(SkScalar))) {
             this->writeOp(kScale_DrawOp);
-            fWriter.writeScalar(sx);
-            fWriter.writeScalar(sy);
+            fWriter.writeT<SkScalar>(sx);
+            fWriter.writeT<SkScalar>(sy);
         }
     }
     return this->INHERITED::scale(sx, sy);
 }
 
 bool SkGPipeCanvas::rotate(SkScalar degrees) {
     if (degrees) {
         NOTIFY_SETUP(this);
         if (this->needOpBytes(sizeof(SkScalar))) {
             this->writeOp(kRotate_DrawOp);
-            fWriter.writeScalar(degrees);
+            fWriter.writeT<SkScalar>(degrees);
         }
     }
     return this->INHERITED::rotate(degrees);
 }
 
 bool SkGPipeCanvas::skew(SkScalar sx, SkScalar sy) {
     if (sx || sy) {
         NOTIFY_SETUP(this);
         if (this->needOpBytes(2 * sizeof(SkScalar))) {
             this->writeOp(kSkew_DrawOp);
-            fWriter.writeScalar(sx);
-            fWriter.writeScalar(sy);
+            fWriter.writeT<SkScalar>(sx);
+            fWriter.writeT<SkScalar>(sy);
         }
     }
     return this->INHERITED::skew(sx, sy);
 }
 
 bool SkGPipeCanvas::concat(const SkMatrix& matrix) {
     if (!matrix.isIdentity()) {
         NOTIFY_SETUP(this);
         if (this->needOpBytes(matrix.writeToMemory(NULL))) {
             this->writeOp(kConcat_DrawOp);
@@ skipping 11 matching lines @@
     }
     this->INHERITED::setMatrix(matrix);
 }
 
 bool SkGPipeCanvas::clipRect(const SkRect& rect, SkRegion::Op rgnOp,
                              bool doAntiAlias) {
     NOTIFY_SETUP(this);
     if (this->needOpBytes(sizeof(SkRect))) {
         unsigned flags = doAntiAlias & kClip_HasAntiAlias_DrawOpFlag;
         this->writeOp(kClipRect_DrawOp, flags, rgnOp);
-        fWriter.writeRect(rect);
+        fWriter.writeT<SkRect>(rect);
     }
     return this->INHERITED::clipRect(rect, rgnOp, doAntiAlias);
 }
 
 bool SkGPipeCanvas::clipRRect(const SkRRect& rrect, SkRegion::Op rgnOp,
                               bool doAntiAlias) {
     NOTIFY_SETUP(this);
     if (this->needOpBytes(kSizeOfFlatRRect)) {
         unsigned flags = doAntiAlias & kClip_HasAntiAlias_DrawOpFlag;
         this->writeOp(kClipRRect_DrawOp, flags, rgnOp);
@@ skipping 58 matching lines @@
             fWriter.write(pts, count * sizeof(SkPoint));
         }
     }
 }
 
 void SkGPipeCanvas::drawOval(const SkRect& rect, const SkPaint& paint) {
     NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(sizeof(SkRect))) {
         this->writeOp(kDrawOval_DrawOp);
-        fWriter.writeRect(rect);
+        fWriter.writeT<SkRect>(rect);
     }
 }
 
 void SkGPipeCanvas::drawRect(const SkRect& rect, const SkPaint& paint) {
     NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(sizeof(SkRect))) {
         this->writeOp(kDrawRect_DrawOp);
-        fWriter.writeRect(rect);
+        fWriter.writeT<SkRect>(rect);
     }
 }
 
 void SkGPipeCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
     NOTIFY_SETUP(this);
     this->writePaint(paint);
     if (this->needOpBytes(kSizeOfFlatRRect)) {
         this->writeOp(kDrawRRect_DrawOp);
         fWriter.writeRRect(rrect);
     }
@@ skipping 27 matching lines @@
     }
     return false;
 }
 
 void SkGPipeCanvas::drawBitmap(const SkBitmap& bm, SkScalar left, SkScalar top,
                                const SkPaint* paint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(SkScalar) * 2;
 
     if (this->commonDrawBitmap(bm, kDrawBitmap_DrawOp, 0, opBytesNeeded, paint)) {
-        fWriter.writeScalar(left);
-        fWriter.writeScalar(top);
+        fWriter.writeT<SkScalar>(left);
+        fWriter.writeT<SkScalar>(top);
     }
 }
 
 void SkGPipeCanvas::drawBitmapRectToRect(const SkBitmap& bm, const SkRect* src,
                                          const SkRect& dst, const SkPaint* paint,
                                          DrawBitmapRectFlags dbmrFlags) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(SkRect);
     bool hasSrc = src != NULL;
     unsigned flags;
     if (hasSrc) {
         flags = kDrawBitmap_HasSrcRect_DrawOpFlag;
         opBytesNeeded += sizeof(int32_t) * 4;
     } else {
         flags = 0;
     }
     if (dbmrFlags & kBleed_DrawBitmapRectFlag) {
         flags |= kDrawBitmap_Bleed_DrawOpFlag;
     }
 
     if (this->commonDrawBitmap(bm, kDrawBitmapRectToRect_DrawOp, flags, opBytesNeeded, paint)) {
         if (hasSrc) {
-            fWriter.writeRect(*src);
+            fWriter.writeT<SkRect>(*src);
         }
-        fWriter.writeRect(dst);
+        fWriter.writeT<SkRect>(dst);
     }
 }
 
 void SkGPipeCanvas::drawBitmapMatrix(const SkBitmap& bm, const SkMatrix& matrix,
                                      const SkPaint* paint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = matrix.writeToMemory(NULL);
 
     if (this->commonDrawBitmap(bm, kDrawBitmapMatrix_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.writeMatrix(matrix);
     }
 }
 
 void SkGPipeCanvas::drawBitmapNine(const SkBitmap& bm, const SkIRect& center,
                                    const SkRect& dst, const SkPaint* paint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(int32_t) * 4 + sizeof(SkRect);
 
     if (this->commonDrawBitmap(bm, kDrawBitmapNine_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.write32(center.fLeft);
         fWriter.write32(center.fTop);
         fWriter.write32(center.fRight);
         fWriter.write32(center.fBottom);
-        fWriter.writeRect(dst);
+        fWriter.writeT<SkRect>(dst);
     }
 }
 
 void SkGPipeCanvas::drawSprite(const SkBitmap& bm, int left, int top,
                                    const SkPaint* paint) {
     NOTIFY_SETUP(this);
     size_t opBytesNeeded = sizeof(int32_t) * 2;
 
     if (this->commonDrawBitmap(bm, kDrawSprite_DrawOp, 0, opBytesNeeded, paint)) {
         fWriter.write32(left);
         fWriter.write32(top);
     }
 }
 
 void SkGPipeCanvas::drawText(const void* text, size_t byteLength, SkScalar x,
                                  SkScalar y, const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 2 * sizeof(SkScalar))) {
             this->writeOp(kDrawText_DrawOp);
             fWriter.write32(byteLength);
             fWriter.writePad(text, byteLength);
-            fWriter.writeScalar(x);
-            fWriter.writeScalar(y);
+            fWriter.writeT<SkScalar>(x);
+            fWriter.writeT<SkScalar>(y);
         }
     }
 }
 
 void SkGPipeCanvas::drawPosText(const void* text, size_t byteLength,
                                 const SkPoint pos[], const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
@@ skipping 13 matching lines @@
     if (byteLength) {
         NOTIFY_SETUP(this);
         this->writePaint(paint);
         int count = paint.textToGlyphs(text, byteLength, NULL);
         if (this->needOpBytes(4 + SkAlign4(byteLength) + 4 + count * sizeof(SkScalar) + 4)) {
             this->writeOp(kDrawPosTextH_DrawOp);
             fWriter.write32(byteLength);
             fWriter.writePad(text, byteLength);
             fWriter.write32(count);
             fWriter.write(xpos, count * sizeof(SkScalar));
-            fWriter.writeScalar(constY);
+            fWriter.writeT<SkScalar>(constY);
         }
     }
 }
 
 void SkGPipeCanvas::drawTextOnPath(const void* text, size_t byteLength,
                                    const SkPath& path, const SkMatrix* matrix,
                                    const SkPaint& paint) {
     if (byteLength) {
         NOTIFY_SETUP(this);
         unsigned flags = 0;
@@ skipping 198 matching lines @@
         if (isCrossProcess(fFlags)) {
             uint32_t id = this->getTypefaceID(paint.getTypeface());
             *ptr++ = PaintOp_packOpData(kTypeface_PaintOp, id);
         } else if (this->needOpBytes(sizeof(void*))) {
             // Add to the set for ref counting.
             fTypefaceSet.add(paint.getTypeface());
             // It is safe to write the typeface to the stream before the rest
             // of the paint unless we ever send a kReset_PaintOp, which we
             // currently never do.
             this->writeOp(kSetTypeface_DrawOp);
-            fWriter.writePtr(paint.getTypeface());
+            fWriter.writeT<void*>(paint.getTypeface());
         }
         base.setTypeface(paint.getTypeface());
     }
 
     // This is a new paint, so all old flats can be safely purged, if necessary.
     fFlattenableHeap.markAllFlatsSafeToDelete();
     for (int i = 0; i < kCount_PaintFlats; i++) {
         int index = this->flattenToIndex(get_paintflat(paint, i), (PaintFlats)i);
         bool replaced = index < 0;
         if (replaced) {
@@ skipping 115 matching lines @@
     return fCanvas->shuttleBitmap(bitmap, slot);
 }
 
 void BitmapShuttle::removeCanvas() {
     if (NULL == fCanvas) {
         return;
     }
     fCanvas->unref();
     fCanvas = NULL;
 }