Adding option in SkPicture to record device-space bounds of draw commands.

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 12 matching lines @@
 // 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 kSaveLayerNoBoundsSize = 4 * kUInt32Size;
 static const uint32_t kSaveLayerWithBoundsSize = 4 * kUInt32Size + sizeof(SkRect);
 
 SkPictureRecord::SkPictureRecord(uint32_t flags, SkDevice* device) :
         INHERITED(device),
         fBoundingHierarchy(NULL),
         fStateTree(NULL),
+        fLastDrawRejected(false),
         fFlattenableHeap(HEAP_BLOCK_SIZE),
         fMatrices(&fFlattenableHeap),
         fPaints(&fFlattenableHeap),
         fRegions(&fFlattenableHeap),
         fWriter(MIN_WRITER_SIZE),
         fRecordFlags(flags) {
 #ifdef SK_DEBUG_SIZE
     fPointBytes = fRectBytes = fTextBytes = 0;
     fPointWrites = fRectWrites = fTextWrites = 0;
 #endif
@@ skipping 12 matching lines @@
     SkSafeUnref(fBitmapHeap);
     SkSafeUnref(fPathHeap);
     SkSafeUnref(fBoundingHierarchy);
     SkSafeUnref(fStateTree);
     fFlattenableHeap.setBitmapStorage(NULL);
     fPictureRefs.unrefAll();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+bool SkPictureRecord::canRecordBounds(DrawType op) {
+    SkASSERT(op != DRAW_POS_TEXT_TOP_BOTTOM);  // Should never be used when encoding bounds
+    SkASSERT(op != DRAW_POS_TEXT_H_TOP_BOTTOM);
+    return
+        op == DRAW_BITMAP ||
+        op == DRAW_BITMAP_MATRIX ||
+        op == DRAW_BITMAP_NINE ||
+        op == DRAW_BITMAP_RECT_TO_RECT ||
+        op == DRAW_OVAL ||
+        op == DRAW_PATH ||
+        op == DRAW_POINTS ||
+        op == DRAW_POS_TEXT ||
+        op == DRAW_POS_TEXT_H ||
+        op == DRAW_RECT ||
+        op == DRAW_RRECT ||
+        op == DRAW_TEXT ||
+        op == DRAW_TEXT_ON_PATH ||
+        op == DRAW_VERTICES;
+}
+
 // 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 uint32_t getPaintOffset(DrawType op, uint32_t opSize) {
+static inline uint32_t getPaintOffset(DrawType op, uint32_t opSize, bool recordBounds) {
     // These offsets are where the paint would be if the op size doesn't overflow
     static const uint8_t gPaintOffsets[LAST_DRAWTYPE_ENUM + 1] = {
         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
@@ skipping 30 matching lines @@
 
     SkASSERT(sizeof(gPaintOffsets) == LAST_DRAWTYPE_ENUM + 1);
     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);
     }
+    if (recordBounds && SkPictureRecord::canRecordBounds(op)) {
+        overflow += sizeof(SkIRect);
+    }
 
     if (SAVE_LAYER == 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;
@@ skipping 10 matching lines @@
 }
 
 int SkPictureRecord::save(SaveFlags flags) {
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.size());
 
     // op + flags
     uint32_t size = 2 * kUInt32Size;
     uint32_t initialOffset = this->addDraw(SAVE, &size);
+    SkASSERT(kInvalidOffset != initialOffset);
     addInt(flags);
 
     validate(initialOffset, size);
     return this->INHERITED::save(flags);
 }
 
 int SkPictureRecord::saveLayer(const SkRect* bounds, const SkPaint* paint,
                                SaveFlags flags) {
     // record the offset to us, making it non-positive to distinguish a save
     // from a clip entry.
     fRestoreOffsetStack.push(-(int32_t)fWriter.size());
 
     // op + bool for 'bounds'
     uint32_t size = 2 * kUInt32Size;
     if (NULL != bounds) {
         size += sizeof(*bounds); // + rect
     }
     // + paint index + flags
     size += 2 * kUInt32Size;
 
     SkASSERT(kSaveLayerNoBoundsSize == size || kSaveLayerWithBoundsSize == size);
 
     uint32_t initialOffset = this->addDraw(SAVE_LAYER, &size);
+    SkASSERT(kInvalidOffset != initialOffset);
     addRectPtr(bounds);
-    SkASSERT(initialOffset+getPaintOffset(SAVE_LAYER, size) == fWriter.size());
+    SkASSERT(initialOffset + getPaintOffset(SAVE_LAYER, size, false) == fWriter.size());
     addPaintPtr(paint);
     addInt(flags);
 
     if (kNoSavedLayerIndex == fFirstSavedLayerIndex) {
         fFirstSavedLayerIndex = fRestoreOffsetStack.count();
     }
 
     validate(initialOffset, size);
     /*  Don't actually call saveLayer, because that will try to allocate an
         offscreen device (potentially very big) which we don't actually need
@@ skipping 44 matching lines @@
 
 /*
  * Restore has just been called (but not recorded), look back at the
  * matching save* and see if we are in the configuration:
  *   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) {
+                               SkPaintDictionary* paintDict, bool recordBounds) {
 
 #ifdef SK_IGNORE_PICTURE_RECORD_SAVE_LAYER_OPT
     return false;
 #endif
 
     int32_t restoreOffset = (int32_t)writer->size();
 
     // back up to the save block
     // TODO: add a stack to track save*/restore offsets rather than searching backwards
     while (offset > 0) {
@@ skipping 27 matching lines @@
     if (DRAW_BITMAP != op && DRAW_BITMAP_MATRIX != op &&
         DRAW_BITMAP_NINE != op && DRAW_BITMAP_RECT_TO_RECT != op) {
         return false;       // not a match
     }
 
     offset = dbmOffset + dbmSize;
     if (offset < restoreOffset) {
         return false;       // something else between the dbm* and the restore
     }
 
-    uint32_t dbmPaintOffset = getPaintOffset(op, dbmSize);
-    uint32_t slPaintOffset = getPaintOffset(SAVE_LAYER, saveLayerSize);
+    uint32_t dbmPaintOffset = getPaintOffset(op, dbmSize, recordBounds);
+    uint32_t slPaintOffset = getPaintOffset(SAVE_LAYER, saveLayerSize, false);
 
     // we have a match, now we need to get the paints involved
     int dbmPaintId = *((int32_t*)writer->peek32(dbmOffset+dbmPaintOffset));
     int saveLayerPaintId = *((int32_t*)writer->peek32(saveLayerOffset+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
         uint32_t* ptr = writer->peek32(saveLayerOffset);
         *ptr = (*ptr & MASK_24) | (NOOP << 24);
@@ skipping 113 matching lines @@
     if (fRestoreOffsetStack.count() == 0) {
         return;
     }
 
     if (fRestoreOffsetStack.count() == fFirstSavedLayerIndex) {
         fFirstSavedLayerIndex = kNoSavedLayerIndex;
     }
 
     uint32_t initialOffset, size;
     if (!collapseSaveClipRestore(&fWriter, fRestoreOffsetStack.top()) &&
-        !remove_save_layer1(&fWriter, fRestoreOffsetStack.top(), &fPaints)) {
+        !remove_save_layer1(&fWriter, fRestoreOffsetStack.top(), &fPaints,

[robertphillips, 2013/03/06 23:02:02]

SkToBool?

+        0 != (fRecordFlags & SkPicture::kRecordBounds_RecordingFlag))) {
         fillRestoreOffsetPlaceholdersForCurrentStackLevel((uint32_t)fWriter.size());
         // op
         size = 1 * kUInt32Size;
         initialOffset = this->addDraw(RESTORE, &size);
     } else {
         size = 0;
         initialOffset = fWriter.size();
     }
 
     fRestoreOffsetStack.pop();
 
     validate(initialOffset, size);
     return this->INHERITED::restore();
 }
 
+uint32_t SkPictureRecord::addDrawWithBounds(DrawType drawType, uint32_t* size,
+                                            const SkPaint* paint, const SkRect* localBounds) {
+    SkASSERT(canRecordBounds(drawType));
+
+    SkIRect clippedDevBounds;
+    if (recordBounds()) {
+        SkIRect devClipBounds;
+        if (!this->getClipDeviceBounds(&devClipBounds)) {

[robertphillips, 2013/03/06 23:02:02]

Comment here about this optimization and why it is valid with rescaling?

+            fLastDrawRejected = true;
+            return 0;
+        }
+        if (NULL == localBounds || (NULL != paint && !paint->canComputeFastBounds())) {
+            clippedDevBounds = devClipBounds;
+        } else {
+            SkRect paintBounds;
+            SkRect rectifiedBounds = *localBounds;
+            rectifiedBounds.sort();
+            if (NULL != paint) {
+                if (drawType == DRAW_POINTS) {
+                    paintBounds = paint->computeFastStrokeBounds(rectifiedBounds, &paintBounds);
+                } else {
+                    paintBounds = paint->computeFastBounds(rectifiedBounds, &paintBounds);
+                }
+            } else {
+                paintBounds = *localBounds;
+            }
+            if (paintBounds.isEmpty()) {
+                fLastDrawRejected = true;
+                return 0;
+            }
+            SkRect devBounds;
+            this->getTotalMatrix().mapRect(&devBounds, paintBounds);
+            devBounds.roundOut(&clippedDevBounds);
+            if (!clippedDevBounds.intersect(devClipBounds)) {
+                fLastDrawRejected = true;
+                return 0;
+            }
+        }
+        *size += sizeof(SkIRect);
+    }
+
+    uint32_t offset = addDraw(drawType, size);
+
+    if (recordBounds()) {
+        fWriter.write(&clippedDevBounds, sizeof(clippedDevBounds));
+    }
+    return offset;
+}
+
 bool SkPictureRecord::translate(SkScalar dx, SkScalar dy) {
     // op + dx + dy
     uint32_t size = 1 * kUInt32Size + 2 * sizeof(SkScalar);
     uint32_t initialOffset = this->addDraw(TRANSLATE, &size);
     addScalar(dx);
     addScalar(dy);
     validate(initialOffset, size);
     return this->INHERITED::translate(dx, dy);
 }
 
@@ skipping 206 matching lines @@
     uint32_t size = 2 * kUInt32Size;
     uint32_t initialOffset = this->addDraw(DRAW_CLEAR, &size);
     addInt(color);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawPaint(const SkPaint& paint) {
     // op + paint index
     uint32_t size = 2 * kUInt32Size;
     uint32_t initialOffset = this->addDraw(DRAW_PAINT, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_PAINT, size) == fWriter.size());
+    SkASSERT(initialOffset + getPaintOffset(DRAW_PAINT, size, false) == fWriter.size());
     addPaint(paint);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawPoints(PointMode mode, size_t count, const SkPoint pts[],
                                  const SkPaint& paint) {
     // op + paint index + mode + count + point data
     uint32_t size = 4 * kUInt32Size + count * sizeof(SkPoint);
-    uint32_t initialOffset = this->addDraw(DRAW_POINTS, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_POINTS, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        SkRect bbox;
+        bbox.set(pts, count);
+        initialOffset = this->addDrawWithBounds(DRAW_POINTS, &size, &paint, &bbox);

[robertphillips, 2013/03/06 23:02:02]

Could fLastDrawRejected be passed in as a parameter instead? It seems like that
might be clearer.

[Justin Novosad, 2013/03/07 14:41:42]

It could, but I need to have as a member anyways because BBoxHierarchy code will
have to be able to query this after the fact (in an upcoming CL).  Another
solution I thought of (heavy handed approach) would be to add a bool return val
to all canvas draw calls, and make them return false when we know nothing was
drawn.

+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_POINTS, &size);
+    }

[robertphillips, 2013/03/06 23:02:02]

this->recordBounds()? Also in following changes too?

+    SkASSERT(initialOffset + getPaintOffset(DRAW_POINTS, size, recordBounds()) == fWriter.size());
     addPaint(paint);
     addInt(mode);
     addInt(count);
     fWriter.writeMul4(pts, count * sizeof(SkPoint));
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawOval(const SkRect& oval, const SkPaint& paint) {
     // op + paint index + rect
     uint32_t size = 2 * kUInt32Size + sizeof(oval);
-    uint32_t initialOffset = this->addDraw(DRAW_OVAL, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_OVAL, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        initialOffset = this->addDrawWithBounds(DRAW_OVAL, &size, &paint, &oval);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_OVAL, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_OVAL, size, recordBounds()) == fWriter.size());
     addPaint(paint);
     addRect(oval);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawRect(const SkRect& rect, const SkPaint& paint) {
     // op + paint index + rect
     uint32_t size = 2 * kUInt32Size + sizeof(rect);
-    uint32_t initialOffset = this->addDraw(DRAW_RECT, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_RECT, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        initialOffset = this->addDrawWithBounds(DRAW_RECT, &size, &paint, &rect);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_RECT, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_RECT, size, recordBounds()) == fWriter.size());
     addPaint(paint);
     addRect(rect);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
-    uint32_t initialOffset, size;
     if (rrect.isRect()) {
-        // op + paint index + rect
-        size = 2 * kUInt32Size + sizeof(SkRect);
-        initialOffset = this->addDraw(DRAW_RECT, &size);
-        SkASSERT(initialOffset+getPaintOffset(DRAW_RECT, size) == fWriter.size());
-        addPaint(paint);
-        addRect(rrect.getBounds());
+        this->drawRect(rrect.getBounds(), paint);
     } else if (rrect.isOval()) {
-        // op + paint index + rect
-        size = 2 * kUInt32Size + sizeof(SkRect);
-        initialOffset = this->addDraw(DRAW_OVAL, &size);
-        SkASSERT(initialOffset+getPaintOffset(DRAW_OVAL, size) == fWriter.size());
-        addPaint(paint);
-        addRect(rrect.getBounds());
+        this->drawOval(rrect.getBounds(), paint);
     } else {
         // op + paint index + rrect
+        uint32_t initialOffset, size;
         size = 2 * kUInt32Size + SkRRect::kSizeInMemory;
-        initialOffset = this->addDraw(DRAW_RRECT, &size);
-        SkASSERT(initialOffset+getPaintOffset(DRAW_RRECT, size) == fWriter.size());
+        if (recordBounds()) {

[robertphillips, 2013/03/06 23:02:02]

What do you think about modifying addDraw to always take a bounds parameter so
we don't have the addDraw/addDrawWithBounds bifurcation? Boundless ops could
pass in NULL. The "if (recordBounds())" logic could then be handled inside
addDraw.

We would also have addDraw always return if the op was rejected.

[Justin Novosad, 2013/03/07 14:41:42]

Well, I also want to avoid computing the bounds that are passed to
addDrawWithBounds because it is not always a trivial computation.  Half the call
sites would have to end up looking something like this:
SkRect* bounds = NULL;
SkRect boundsStorage;
if (this->recordBounds()) {
   //Compute bounds in boundsStorage
   (...)
   bounds = &boundsStorage;
}
addDraw(..., bounds);

Maybe that's not so bad... not sure which I dislike more.

+            initialOffset = this->addDrawWithBounds(DRAW_RRECT, &size, &paint, &rrect.getBounds());
+            if (fLastDrawRejected) {
+                return;
+            }
+        } else {
+            initialOffset = this->addDraw(DRAW_RRECT, &size);
+        }
+        SkASSERT(initialOffset + getPaintOffset(DRAW_RRECT, size, recordBounds()) \
+            == fWriter.size());
         addPaint(paint);
         addRRect(rrect);
+        validate(initialOffset, size);
     }
-    validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawPath(const SkPath& path, const SkPaint& paint) {
     // op + paint index + path index
     uint32_t size = 3 * kUInt32Size;
-    uint32_t initialOffset = this->addDraw(DRAW_PATH, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_PATH, size) == fWriter.size());
+    const SkRect* bounds = path.isInverseFillType() ? NULL : &path.getBounds();
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        initialOffset = this->addDrawWithBounds(DRAW_PATH, &size, &paint, bounds);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_PATH, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_PATH, size, recordBounds()) == fWriter.size());
     addPaint(paint);
     addPath(path);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
                         const SkPaint* paint = NULL) {
     // op + paint index + bitmap index + left + top
     uint32_t size = 3 * kUInt32Size + 2 * sizeof(SkScalar);
-    uint32_t initialOffset = this->addDraw(DRAW_BITMAP, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP, size) == fWriter.size());
+    SkRect bounds = SkRect::MakeXYWH(left, top, bitmap.width(), bitmap.height());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        initialOffset = this->addDrawWithBounds(DRAW_BITMAP, &size, paint, &bounds);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_BITMAP, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_BITMAP, size, recordBounds()) == fWriter.size());
     addPaintPtr(paint);
     addBitmap(bitmap);
     addScalar(left);
     addScalar(top);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
                             const SkRect& dst, const SkPaint* paint) {
     // id + paint index + bitmap index + bool for 'src'
     uint32_t size = 4 * kUInt32Size;
     if (NULL != src) {
         size += sizeof(*src);   // + rect
     }
     size += sizeof(dst);        // + rect
 
-    uint32_t initialOffset = this->addDraw(DRAW_BITMAP_RECT_TO_RECT, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP_RECT_TO_RECT, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        initialOffset = this->addDrawWithBounds(DRAW_BITMAP_RECT_TO_RECT, &size, paint, &dst);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_BITMAP_RECT_TO_RECT, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_BITMAP_RECT_TO_RECT, size, recordBounds()) \
+             == fWriter.size());
     addPaintPtr(paint);
     addBitmap(bitmap);
     addRectPtr(src);  // may be null
     addRect(dst);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& matrix,
                                        const SkPaint* paint) {
     // id + paint index + bitmap index + matrix index
     uint32_t size = 4 * kUInt32Size;
-    uint32_t initialOffset = this->addDraw(DRAW_BITMAP_MATRIX, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP_MATRIX, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        SkRect bounds = SkRect::MakeWH(bitmap.width(), bitmap.height());
+        matrix.mapRect(&bounds);
+        initialOffset = this->addDrawWithBounds(DRAW_BITMAP_MATRIX, &size, paint, &bounds);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_BITMAP_MATRIX, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_BITMAP_MATRIX, size, recordBounds()) \
+        == fWriter.size());
     addPaintPtr(paint);
     addBitmap(bitmap);
     addMatrix(matrix);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
                                      const SkRect& dst, const SkPaint* paint) {
     // op + paint index + bitmap id + center + dst rect
     uint32_t size = 3 * kUInt32Size + sizeof(center) + sizeof(dst);
-    uint32_t initialOffset = this->addDraw(DRAW_BITMAP_NINE, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_BITMAP_NINE, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        initialOffset = this->addDrawWithBounds(DRAW_BITMAP_NINE, &size, paint, &dst);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_BITMAP_NINE, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_BITMAP_NINE, size, recordBounds()) == \
+        fWriter.size());
     addPaintPtr(paint);
     addBitmap(bitmap);
     addIRect(center);
     addRect(dst);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawSprite(const SkBitmap& bitmap, int left, int top,
-                        const SkPaint* paint = NULL) {
+                                 const SkPaint* paint) {
     // op + paint index + bitmap index + left + top
     uint32_t size = 5 * kUInt32Size;
-    uint32_t initialOffset = this->addDraw(DRAW_SPRITE, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_SPRITE, size) == fWriter.size());
+    uint32_t initialOffset;
+    // Note: Bounds encoding not supported.
+    initialOffset = this->addDraw(DRAW_SPRITE, &size);
+    SkASSERT(initialOffset + getPaintOffset(DRAW_SPRITE, size, false) == fWriter.size());
     addPaintPtr(paint);
     addBitmap(bitmap);
     addInt(left);
     addInt(top);
     validate(initialOffset, size);
 }
 
 // Return fontmetrics.fTop,fBottom in topbot[0,1], after they have been
 // tweaked by paint.computeFastBounds().
 //
@@ skipping 13 matching lines @@
                                               SkScalar minY, SkScalar maxY) {
     if (!flat.isTopBotWritten()) {
         computeFontMetricsTopBottom(paint, flat.writableTopBot());
         SkASSERT(flat.isTopBotWritten());
     }
     addScalar(flat.topBot()[0] + minY);
     addScalar(flat.topBot()[1] + maxY);
 }
 
 void SkPictureRecord::drawText(const void* text, size_t byteLength, SkScalar x,
                       SkScalar y, const SkPaint& paint) {

[robertphillips, 2013/03/06 23:02:02]

// We disallow DRAW_TEXT_TOP_BOTTOM when saving bounds b.c. ...

-    bool fast = !paint.isVerticalText() && paint.canComputeFastBounds();
+    bool fast = !paint.isVerticalText() && paint.canComputeFastBounds() &&
+        (fRecordFlags & SkPicture::kRecordBounds_RecordingFlag) == 0;
 
     // op + paint index + length + 'length' worth of chars + x + y
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 2 * sizeof(SkScalar);
     if (fast) {
         size += 2 * sizeof(SkScalar); // + top & bottom
     }
 
     DrawType op = fast ? DRAW_TEXT_TOP_BOTTOM : DRAW_TEXT;
-    uint32_t initialOffset = this->addDraw(op, &size);
-    SkASSERT(initialOffset+getPaintOffset(op, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        SkRect bbox;
+        paint.measureText(text, byteLength, &bbox);
+        SkPaint::FontMetrics metrics;
+        paint.getFontMetrics(&metrics);
+
+        // Vertical and aligned text need to be offset
+        if (paint.isVerticalText()) {
+            SkScalar h = bbox.fBottom - bbox.fTop;
+            if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+                bbox.fTop    -= h / 2;
+                bbox.fBottom -= h / 2;
+            }
+            // Pad top and bottom with max extents from FontMetrics
+            bbox.fBottom += metrics.fBottom;
+            bbox.fTop += metrics.fTop;
+        } else {
+            SkScalar w = bbox.fRight - bbox.fLeft;
+            if (paint.getTextAlign() == SkPaint::kCenter_Align) {
+                bbox.fLeft  -= w / 2;
+                bbox.fRight -= w / 2;
+            } else if (paint.getTextAlign() == SkPaint::kRight_Align) {
+                bbox.fLeft  -= w;
+                bbox.fRight -= w;
+            }
+            // Set vertical bounds to max extents from font metrics
+            bbox.fTop = metrics.fTop;
+            bbox.fBottom = metrics.fBottom;
+        }
+
+        // Pad horizontal bounds on each side by half of max vertical extents (this is sort of
+        // arbitrary, but seems to produce reasonable results, if there were a way of getting max
+        // glyph X-extents to pad by, that may be better here, but FontMetrics fXMin and fXMax seem
+        // incorrect on most platforms (too small in Linux, never even set in Windows).
+        SkScalar pad = (metrics.fBottom - metrics.fTop) / 2;
+        bbox.fLeft  -= pad;
+        bbox.fRight += pad;
+
+        bbox.fLeft += x;
+        bbox.fRight += x;
+        bbox.fTop += y;
+        bbox.fBottom += y;
+        initialOffset = this->addDrawWithBounds(op, &size, &paint, &bbox);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(op, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(op, size, recordBounds()) == fWriter.size());
     const SkFlatData* flatPaintData = addPaint(paint);
     SkASSERT(flatPaintData);
     addText(text, byteLength);
     addScalar(x);
     addScalar(y);
     if (fast) {
         addFontMetricsTopBottom(paint, *flatPaintData, y, y);
     }
     validate(initialOffset, size);
 }
@@ skipping 15 matching lines @@
                 canUseDrawH = false;
                 if (pos[index].fY < minY) {
                     minY = pos[index].fY;
                 } else if (pos[index].fY > maxY) {
                     maxY = pos[index].fY;
                 }
             }
         }
     }
 
-    bool fastBounds = !paint.isVerticalText() && paint.canComputeFastBounds();
+    bool fastBounds = !paint.isVerticalText() && paint.canComputeFastBounds() &&
+        (fRecordFlags & SkPicture::kRecordBounds_RecordingFlag) == 0;
     bool fast = canUseDrawH && fastBounds;
 
     // op + paint index + length + 'length' worth of data + num points
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 1 * kUInt32Size;
     if (canUseDrawH) {
         if (fast) {
             size += 2 * sizeof(SkScalar); // + top & bottom
         }
         // + y-pos + actual x-point data
         size += sizeof(SkScalar) + points * sizeof(SkScalar);
     } else {
         // + x&y point data
         size += points * sizeof(SkPoint);
         if (fastBounds) {
             size += 2 * sizeof(SkScalar); // + top & bottom
         }
     }
 
     DrawType op;
     if (fast) {
         op = DRAW_POS_TEXT_H_TOP_BOTTOM;
     } else if (canUseDrawH) {
         op = DRAW_POS_TEXT_H;
     } else if (fastBounds) {
         op = DRAW_POS_TEXT_TOP_BOTTOM;
     } else {
         op = DRAW_POS_TEXT;
     }
-    uint32_t initialOffset = this->addDraw(op, &size);
-    SkASSERT(initialOffset+getPaintOffset(op, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        SkRect bbox;
+        bbox.set(pos, paint.countText(text, byteLength));
+        SkPaint::FontMetrics metrics;
+        paint.getFontMetrics(&metrics);
+        bbox.fTop += metrics.fTop;
+        bbox.fBottom += metrics.fBottom;
+
+        // pad on left and right by half of max vertical glyph extents
+        SkScalar pad = (metrics.fTop - metrics.fBottom) / 2;
+        bbox.fLeft += pad;
+        bbox.fRight -= pad;
+        initialOffset = this->addDrawWithBounds(op, &size, &paint, &bbox);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(op, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(op, size, recordBounds()) == fWriter.size());
     const SkFlatData* flatPaintData = addPaint(paint);
     SkASSERT(flatPaintData);
     addText(text, byteLength);
     addInt(points);
 
 #ifdef SK_DEBUG_SIZE
     size_t start = fWriter.size();
 #endif
     if (canUseDrawH) {
         if (fast) {
@@ skipping 16 matching lines @@
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawPosTextH(const void* text, size_t byteLength,
                           const SkScalar xpos[], SkScalar constY,
                           const SkPaint& paint) {
     size_t points = paint.countText(text, byteLength);
     if (0 == points)
         return;
 
-    bool fast = !paint.isVerticalText() && paint.canComputeFastBounds();
+    bool fast = !paint.isVerticalText() && paint.canComputeFastBounds() &&
+        (fRecordFlags & SkPicture::kRecordBounds_RecordingFlag) == 0;
 
     // op + paint index + length + 'length' worth of data + num points
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 1 * kUInt32Size;
     if (fast) {
         size += 2 * sizeof(SkScalar); // + top & bottom
     }
     // + y + the actual points
     size += 1 * kUInt32Size + points * sizeof(SkScalar);
 
-    uint32_t initialOffset = this->addDraw(fast ? DRAW_POS_TEXT_H_TOP_BOTTOM : DRAW_POS_TEXT_H,
-                                           &size);
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        size_t numChars = paint.countText(text, byteLength);
+        SkRect bbox;
+        bbox.fLeft  = xpos[0];
+        bbox.fRight = xpos[numChars - 1];
+        // if we had a guarantee that these will be monotonically increasing, this could be sped up
+        for (size_t i = 1; i < numChars; ++i) {
+            if (xpos[i] < bbox.fLeft) {
+                bbox.fLeft = xpos[i];
+            }
+            if (xpos[i] > bbox.fRight) {
+                bbox.fRight = xpos[i];
+            }
+        }
+        SkPaint::FontMetrics metrics;
+        paint.getFontMetrics(&metrics);
+
+        // pad horizontally by max glyph height
+        SkScalar pad = (metrics.fTop - metrics.fBottom);
+        bbox.fLeft  += pad;
+        bbox.fRight -= pad;
+
+        bbox.fTop    = metrics.fTop + constY;
+        bbox.fBottom = metrics.fBottom + constY;
+        initialOffset = this->addDrawWithBounds(DRAW_POS_TEXT_H, &size, &paint, &bbox);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(fast ? DRAW_POS_TEXT_H_TOP_BOTTOM : DRAW_POS_TEXT_H,
+                                      &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_TEXT_ON_PATH, size, recordBounds()) \
+             == fWriter.size());
     const SkFlatData* flatPaintData = addPaint(paint);
     SkASSERT(flatPaintData);
     addText(text, byteLength);
     addInt(points);
 
 #ifdef SK_DEBUG_SIZE
     size_t start = fWriter.size();
 #endif
     if (fast) {
         addFontMetricsTopBottom(paint, *flatPaintData, constY, constY);
     }
     addScalar(constY);
     fWriter.writeMul4(xpos, points * sizeof(SkScalar));
 #ifdef SK_DEBUG_SIZE
     fPointBytes += fWriter.size() - start;
     fPointWrites += points;
 #endif
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawTextOnPath(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 index
     uint32_t size = 3 * kUInt32Size + SkAlign4(byteLength) + 2 * kUInt32Size;
-    uint32_t initialOffset = this->addDraw(DRAW_TEXT_ON_PATH, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_TEXT_ON_PATH, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        SkRect bbox = path.getBounds();
+        SkPaint::FontMetrics metrics;
+        paint.getFontMetrics(&metrics);
+        // pad out all sides by the max glyph height above baseline
+        SkScalar pad = metrics.fTop;
+        bbox.fLeft += pad;
+        bbox.fRight -= pad;
+        bbox.fTop += pad;
+        bbox.fBottom -= pad;
+        initialOffset = this->addDrawWithBounds(DRAW_TEXT_ON_PATH, &size, &paint, &bbox);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_TEXT_ON_PATH, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_TEXT_ON_PATH, size, recordBounds()) \
+        == fWriter.size());
     addPaint(paint);
     addText(text, byteLength);
     addPath(path);
     addMatrixPtr(matrix);
     validate(initialOffset, size);
 }
 
 void SkPictureRecord::drawPicture(SkPicture& picture) {
     // op + picture index
     uint32_t size = 2 * kUInt32Size;
@@ skipping 24 matching lines @@
         size += vertexCount * sizeof(SkPoint);  // + uvs
     }
     if (flags & DRAW_VERTICES_HAS_COLORS) {
         size += vertexCount * sizeof(SkColor);  // + vert colors
     }
     if (flags & DRAW_VERTICES_HAS_INDICES) {
         // + num indices + indices
         size += 1 * kUInt32Size + SkAlign4(indexCount * sizeof(uint16_t));
     }
 
-    uint32_t initialOffset = this->addDraw(DRAW_VERTICES, &size);
-    SkASSERT(initialOffset+getPaintOffset(DRAW_VERTICES, size) == fWriter.size());
+    uint32_t initialOffset;
+    if (recordBounds()) {
+        SkRect bbox;
+        bbox.set(vertices, vertexCount);
+        initialOffset = this->addDrawWithBounds(DRAW_VERTICES, &size, &paint, &bbox);
+        if (fLastDrawRejected) {
+            return;
+        }
+    } else {
+        initialOffset = this->addDraw(DRAW_VERTICES, &size);
+    }
+    SkASSERT(initialOffset + getPaintOffset(DRAW_VERTICES, size, recordBounds()) \
+        == fWriter.size());
     addPaint(paint);
     addInt(flags);
     addInt(vmode);
     addInt(vertexCount);
     addPoints(vertices, vertexCount);
     if (flags & DRAW_VERTICES_HAS_TEXS) {
         addPoints(texs, vertexCount);
     }
     if (flags & DRAW_VERTICES_HAS_COLORS) {
         fWriter.writeMul4(colors, vertexCount * sizeof(SkColor));
@@ skipping 250 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