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

include/core/SkPicture.h

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPicture_DEFINED
@@ skipping 71 matching lines @@
     SkPicture* clone() const;
 
     /**
      * Creates multiple thread-safe clones of this picture that are ready for
      * playback. The resulting clones are stored in the provided array of
      * SkPictures.
      */
     void clone(SkPicture* pictures, int count) const;
 
     enum RecordingFlags {
-        /*  This flag specifies that when clipPath() is called, the path will
+        /** This flag specifies that when clipPath() is called, the path will
             be faithfully recorded, but the recording canvas' current clip will
             only see the path's bounds. This speeds up the recording process
             without compromising the fidelity of the playback. The only side-
             effect for recording is that calling getTotalClip() or related
             clip-query calls will reflect the path's bounds, not the actual
             path.
          */
         kUsePathBoundsForClip_RecordingFlag = 0x01,
-        /*  This flag causes the picture to compute bounding boxes and build
+        /** This flag causes the picture to compute bounding boxes and build
             up a spatial hierarchy (currently an R-Tree), plus a tree of Canvas'
             usually stack-based clip/etc state. This requires an increase in
             recording time (often ~2x; likely more for very complex pictures),
             but allows us to perform much faster culling at playback time, and
             completely avoid some unnecessary clips and other operations. This
             is ideal for tiled rendering, or any other situation where you're
             drawing a fraction of a large scene into a smaller viewport.
 
             In most cases the record cost is offset by the playback improvement
             after a frame or two of tiled rendering (and complex pictures that
             induce the worst record times will generally get the largest
             speedups at playback time).
 
             Note: Currently this is not serializable, the bounding data will be
             discarded if you serialize into a stream and then deserialize.
         */
-        kOptimizeForClippedPlayback_RecordingFlag = 0x02
+        kOptimizeForClippedPlayback_RecordingFlag = 0x02,
+        /** This flag causes device-space bounding boxes to be stored for
+            each canvas call that writes pixels. Encoding this information
+            enables several playback optimizations.
+        */
+        kRecordBounds_RecordingFlag = 0x04
     };
 
     /** Returns the canvas that records the drawing commands.
         @param width the base width for the picture, as if the recording
                      canvas' bitmap had this width.
         @param height the base width for the picture, as if the recording
                      canvas' bitmap had this height.
         @param recordFlags optional flags that control recording.
         @return the picture canvas.
     */
@@ skipping 102 matching lines @@
     */
     SkCanvas* getRecordingCanvas() const { return fCanvas; }
 
 private:
     SkPicture*  fPicture;
     SkCanvas*   fCanvas;
 };
 
 
 #endif