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

src/core/SkPictureRecord.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPictureRecord_DEFINED
 #define SkPictureRecord_DEFINED
 
@@ skipping 84 matching lines @@
         fRecordFlags = recordFlags;
     }
 
     const SkWriter32& writeStream() const {
         return fWriter;
     }
 
     void beginRecording();
     void endRecording();
 
+    static bool canRecordBounds(DrawType op);
 private:
     void recordRestoreOffsetPlaceholder(SkRegion::Op);
     void fillRestoreOffsetPlaceholdersForCurrentStackLevel(
         uint32_t restoreOffset);
 
     SkTDArray<int32_t> fRestoreOffsetStack;
     int fFirstSavedLayerIndex;
     enum {
-        kNoSavedLayerIndex = -1
+        kNoSavedLayerIndex = -1,
     };
+    static const uint32_t kInvalidOffset = ~0;
 
     /*
      * Write the 'drawType' operation and chunk size to the skp. 'size'
      * can potentially be increased if the chunk size needs its own storage
      * location (i.e., it overflows 24 bits).
      * Returns the start offset of the chunk. This is the location at which
      * the opcode & size are stored.
      * TODO: since we are handing the size into here we could call reserve
      * and then return a pointer to the memory storage. This could decrease
      * allocation overhead but could lead to more wasted space (the tail
      * end of blocks could go unused). Possibly add a second addDraw that
      * operates in this manner.
      */
     uint32_t addDraw(DrawType drawType, uint32_t* size) {
         uint32_t offset = fWriter.size();
 
         this->predrawNotify();
 
     #ifdef SK_DEBUG_TRACE
         SkDebugf("add %s\n", DrawTypeToString(drawType));
     #endif
-
         SkASSERT(0 != *size);
         SkASSERT(((uint8_t) drawType) == drawType);
-
         if (0 != (*size & ~MASK_24) || *size == MASK_24) {
             fWriter.writeInt(PACK_8_24(drawType, MASK_24));
             *size += 1;
             fWriter.writeInt(*size);
         } else {
             fWriter.writeInt(PACK_8_24(drawType, *size));
         }
-
+        fLastDrawRejected = false;
         return offset;
     }
 
+    uint32_t addDrawWithBounds(DrawType drawType, uint32_t* size, const SkPaint* paint,
+                               const SkRect* localBounds);
+    bool recordBounds() const { return fRecordFlags & SkPicture::kRecordBounds_RecordingFlag; }
+
     void addInt(int value) {
         fWriter.writeInt(value);
     }
     void addScalar(SkScalar scalar) {
         fWriter.writeScalar(scalar);
     }
 
     void addBitmap(const SkBitmap& bitmap);
     void addMatrix(const SkMatrix& matrix);
     void addMatrixPtr(const SkMatrix* matrix);
@@ skipping 51 matching lines @@
 
 protected:
 
     // These are set to NULL in our constructor, but may be changed by
     // subclasses, in which case they will be SkSafeUnref'd in our destructor.
     SkBBoxHierarchy* fBoundingHierarchy;
     SkPictureStateTree* fStateTree;
 
     // Allocated in the constructor and managed by this class.
     SkBitmapHeap* fBitmapHeap;
+    bool fLastDrawRejected;
 
 private:
     SkChunkFlatController fFlattenableHeap;
 
     SkMatrixDictionary fMatrices;
     SkPaintDictionary fPaints;
     SkRegionDictionary fRegions;
 
     SkPathHeap* fPathHeap;  // reference counted
     SkWriter32 fWriter;
 
     // we ref each item in these arrays
     SkTDArray<SkPicture*> fPictureRefs;
 
     uint32_t fRecordFlags;
     int fInitialSaveCount;
 
     friend class SkPicturePlayback;
     friend class SkPictureTester; // for unit testing
 
     typedef SkCanvas INHERITED;
 };
 
 #endif