Bound everything except drawText().

src/core/SkRecordDraw.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkRecordDraw.h"
-#include "SkTSort.h"
+#include "SkPatchUtils.h"
 
 void SkRecordDraw(const SkRecord& record,
                   SkCanvas* canvas,
                   const SkBBoxHierarchy* bbh,
                   SkDrawPictureCallback* callback) {
     SkAutoCanvasRestore saveRestore(canvas, true /*save now, restore at exit*/);
 
     if (NULL != bbh) {
         // Draw only ops that affect pixels in the canvas's current clip.
         SkIRect query;
@@ skipping 229 matching lines @@
         fControlIndices.pop();
     }
 
     void updateSaveBounds(const SkIRect& bounds) {
         // If we're in a Save block, expand its bounds to cover these bounds too.
         if (!fSaveStack.isEmpty()) {
             fSaveStack.top().bounds.join(bounds);
         }
     }
 
-    // FIXME: these methods could use better bounds
-    SkIRect bounds(const DrawPatch&)      const { return fCurrentClipBounds; }
-    SkIRect bounds(const DrawPicture&)    const { return fCurrentClipBounds; }
-    SkIRect bounds(const DrawTextOnPath&) const { return fCurrentClipBounds; }
-    SkIRect bounds(const DrawSprite&)     const { return fCurrentClipBounds; }
-    SkIRect bounds(const DrawTextBlob&)   const { return fCurrentClipBounds; }
-    SkIRect bounds(const DrawText&)       const { return fCurrentClipBounds; }
-    SkIRect bounds(const DrawVertices&)   const { return fCurrentClipBounds; }
-    //  end of methods that could use better bounds
+    // FIXME: this method could use better bounds
+    SkIRect bounds(const DrawText&) const { return fCurrentClipBounds; }
 
-    SkIRect bounds(const Clear&) const { return SkIRect::MakeLargest(); }  // Ignores the clip
+    SkIRect bounds(const Clear&) const { return SkIRect::MakeLargest(); }  // Ignores the clip.
     SkIRect bounds(const DrawPaint&) const { return fCurrentClipBounds; }
     SkIRect bounds(const NoOp&)  const { return SkIRect::MakeEmpty(); }    // NoOps don't draw.
 
+    SkIRect bounds(const DrawSprite& op) const {
+        const SkBitmap& bm = op.bitmap;
+        return SkIRect::MakeXYWH(op.left, op.top, bm.width(), bm.height());  // Ignores the matrix.
+    }
+
     SkIRect bounds(const DrawRect& op) const { return this->adjustAndMap(op.rect, &op.paint); }
     SkIRect bounds(const DrawOval& op) const { return this->adjustAndMap(op.oval, &op.paint); }
     SkIRect bounds(const DrawRRect& op) const {
         return this->adjustAndMap(op.rrect.rect(), &op.paint);
     }
     SkIRect bounds(const DrawDRRect& op) const {
         return this->adjustAndMap(op.outer.rect(), &op.paint);
     }
 
     SkIRect bounds(const DrawBitmapRectToRect& op) const {
@@ skipping 21 matching lines @@
     SkIRect bounds(const DrawPoints& op) const {
         SkRect dst;
         dst.set(op.pts, op.count);
 
         // Pad the bounding box a little to make sure hairline points' bounds aren't empty.
         SkScalar stroke = SkMaxScalar(op.paint.getStrokeWidth(), 0.01f);
         dst.outset(stroke/2, stroke/2);
 
         return this->adjustAndMap(dst, &op.paint);
     }
+    SkIRect bounds(const DrawPatch& op) const {
+        SkRect dst;
+        dst.set(op.cubics, SkPatchUtils::kNumCtrlPts);
+        return this->adjustAndMap(dst, &op.paint);
+    }
+    SkIRect bounds(const DrawVertices& op) const {
+        SkRect dst;
+        dst.set(op.vertices, op.vertexCount);
+        return this->adjustAndMap(dst, &op.paint);
+    }
+
+    SkIRect bounds(const DrawPicture& op) const {
+        SkRect dst = SkRect::MakeWH(op.picture->width(), op.picture->height());
+        if (op.matrix) {
+            op.matrix->mapRect(&dst);
+        }
+        return this->adjustAndMap(dst, op.paint);
+    }
 
     SkIRect bounds(const DrawPosText& op) const {
         const int N = op.paint.countText(op.text, op.byteLength);
         if (N == 0) {
             return SkIRect::MakeEmpty();
         }
 
         SkRect dst;
         dst.set(op.pos, op.paint.countText(op.text, N));
         AdjustTextForFontMetrics(&dst, op.paint);
         return this->adjustAndMap(dst, &op.paint);
     }
     SkIRect bounds(const DrawPosTextH& op) const {
         const int N = op.paint.countText(op.text, op.byteLength);
         if (N == 0) {
             return SkIRect::MakeEmpty();
         }
 
         SkScalar left = op.xpos[0], right = op.xpos[0];
         for (int i = 1; i < N; i++) {
             left  = SkMinScalar(left,  op.xpos[i]);
             right = SkMaxScalar(right, op.xpos[i]);
         }
         SkRect dst = { left, op.y, right, op.y };
         AdjustTextForFontMetrics(&dst, op.paint);
         return this->adjustAndMap(dst, &op.paint);
     }
+    SkIRect bounds(const DrawTextOnPath& op) const {
+        SkRect dst = op.path.getBounds();

[robertphillips, 2014/08/25 21:00:40]

B.c. we don't know the shape of the path don't we have to do even more bloating?

[mtklein, 2014/08/25 21:09:22]

Done.  Now using the max pad in all directions.

+        AdjustTextForFontMetrics(&dst, op.paint);
+        return this->adjustAndMap(dst, &op.paint);
+    }
+
+    SkIRect bounds(const DrawTextBlob& op) const {
+        SkRect dst = op.blob->bounds();
+        dst.offset(op.x, op.y);
+        // TODO: remove when implicit bounds are plumbed through
+        if (dst.isEmpty()) {
+            return fCurrentClipBounds;
+        }
+        return this->adjustAndMap(dst, &op.paint);
+    }
 
     static void AdjustTextForFontMetrics(SkRect* rect, const SkPaint& paint) {
 #ifdef SK_DEBUG
         SkRect correct = *rect;
 #endif
         const SkScalar yPad = 2.0f * paint.getTextSize(),  // In practice, this seems to be enough.
                        xPad = 4.0f * yPad;                 // Hack for very wide Github logo font.
         rect->outset(xPad, yPad);
 #ifdef SK_DEBUG
         SkPaint::FontMetrics metrics;
@@ skipping 66 matching lines @@
     // Used to track the bounds of Save/Restore blocks and the control ops inside them.
     SkTDArray<SaveBounds> fSaveStack;
     SkTDArray<unsigned>   fControlIndices;
 };
 
 }  // namespace SkRecords
 
 void SkRecordFillBounds(const SkRecord& record, SkBBoxHierarchy* bbh) {
     SkRecords::FillBounds(record, bbh);
 }