Quick-reject draw text blob calls.

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 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.
  */
 
 
 #include "SkCanvas.h"
 #include "SkCanvasPriv.h"
@@ skipping 2202 matching lines @@
                                      matrix, looper.paint());
     }
 
     LOOPER_END
 }
 
 void SkCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                               const SkPaint& paint) {
     SkASSERT(blob);
 
+    bool hasOffset = x || y;
+
+    // FIXME: temporarily disable quickreject for empty bounds,
+    // pending implicit blob bounds implementation.
+    if (!blob->bounds().isEmpty() && paint.canComputeFastBounds()) {
+        SkRect storage;

[reed1, 2014/08/29 15:34:28]

I wonder if we should send the translated rect to the paint, in case it has an
imagefilter or something?

[f(malita), 2014/08/29 16:01:26]

Done.

+        const SkRect* bounds = &paint.computeFastBounds(blob->bounds(), &storage);
+        if (hasOffset) {
+            if (bounds != &storage) {
+                storage = *bounds;
+                bounds = &storage;
+            }
+            storage.offset(x, y);
+        }
+
+        if (this->quickReject(*bounds)) {
+            return;
+        }
+    }
+
     // FIXME: dispatch to the device instead
 
-    if (x || y) {
+    if (hasOffset) {
         this->translate(x, y);

[reed1, 2014/08/29 15:34:28]

Eeeek! translate is virtual. I thought all of this old code was now safely
inside SkBaseDevice?

[f(malita), 2014/08/29 15:36:39]

It is now, just haven't rebased this yet :)

     }
 
     SkPaint runPaint = paint;
     SkTextBlob::RunIterator it(blob);
     while (!it.done()) {
         size_t textLen = it.glyphCount() * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
         // applyFontToPaint() always overwrites the exact same attributes,
         // so it is safe to not re-seed the paint.
         it.applyFontToPaint(&runPaint);
 
         switch (it.positioning()) {
         case SkTextBlob::kDefault_Positioning:
             this->drawText(it.glyphs(), textLen, offset.x(), offset.y(), runPaint);
             break;
         case SkTextBlob::kHorizontal_Positioning:
             this->drawPosTextH(it.glyphs(), textLen, it.pos(), offset.y(), runPaint);
             break;
         case SkTextBlob::kFull_Positioning:
             this->drawPosText(it.glyphs(), textLen, (const SkPoint*)it.pos(), runPaint);
             break;
         default:
             SkFAIL("unhandled positioning mode");
         }
 
         it.next();
     }
 
-    if (x || y) {
+    if (hasOffset) {
         this->translate(-x, -y);
     }
 }
 
 // These will become non-virtual, so they always call the (virtual) onDraw... method
 void SkCanvas::drawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
                         const SkPaint& paint) {
     this->onDrawText(text, byteLength, x, y, paint);
 }
 void SkCanvas::drawPosText(const void* text, size_t byteLength, const SkPoint pos[],
@@ skipping 328 matching lines @@
     }
 
     if (NULL != matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }