[TextBlob] Fall back to TightRunBounds when the font bounds are empty

src/core/SkTextBlob.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 "SkTextBlob.h"
 
 #include "SkReadBuffer.h"
@@ skipping 349 matching lines @@
 
 SkTextBlobBuilder::~SkTextBlobBuilder() {
     if (nullptr != fStorage.get()) {
         // We are abandoning runs and must destruct the associated font data.
         // The easiest way to accomplish that is to use the blob destructor.
         build()->unref();
     }
 }
 
 SkRect SkTextBlobBuilder::TightRunBounds(const SkTextBlob::RunRecord& run) {
-    SkASSERT(SkTextBlob::kDefault_Positioning == run.positioning());
-
     SkRect bounds;
     SkPaint paint;
     run.font().applyToPaint(&paint);
-    paint.measureText(run.glyphBuffer(), run.glyphCount() * sizeof(uint16_t), &bounds);
+
+    if (SkTextBlob::kDefault_Positioning == run.positioning()) {
+        paint.measureText(run.glyphBuffer(), run.glyphCount() * sizeof(uint16_t), &bounds);
+        return bounds.makeOffset(run.offset().x(), run.offset().y());
+    }
+
+    SkAutoSTArray<16, SkRect> glyphBounds(run.glyphCount());
+    paint.getTextWidths(run.glyphBuffer(),
+                        run.glyphCount() * sizeof(uint16_t),
+                        NULL,
+                        glyphBounds.get());
+
+    SkASSERT(SkTextBlob::kFull_Positioning == run.positioning() ||
+             SkTextBlob::kHorizontal_Positioning == run.positioning());
+    // kFull_Positioning       => [ x, y, x, y... ]
+    // kHorizontal_Positioning => [ x, x, x... ]
+    //                            (const y applied by runBounds.offset(run->offset()) later)
+    const SkScalar horizontalConstY = 0;
+    const SkScalar* glyphPosX = run.posBuffer();
+    const SkScalar* glyphPosY = (run.positioning() == SkTextBlob::kFull_Positioning) ?
+                                                      glyphPosX + 1 : &horizontalConstY;
+    const unsigned posXInc = SkTextBlob::ScalarsPerGlyph(run.positioning());
+    const unsigned posYInc = (run.positioning() == SkTextBlob::kFull_Positioning) ?
+                                                   posXInc : 0;
+
+    bounds.setEmpty();
+    for (unsigned i = 0; i < run.glyphCount(); ++i) {
+        bounds.join(glyphBounds[i].makeOffset(*glyphPosX, *glyphPosY));
+        glyphPosX += posXInc;
+        glyphPosY += posYInc;
+    }
+
+    SkASSERT((void*)glyphPosX <= SkTextBlob::RunRecord::Next(&run));
+    SkASSERT(run.positioning() == SkTextBlob::kHorizontal_Positioning ||
+             (void*)glyphPosY <= SkTextBlob::RunRecord::Next(&run));
 
     return bounds.makeOffset(run.offset().x(), run.offset().y());
 }
 
 SkRect SkTextBlobBuilder::ConservativeRunBounds(const SkTextBlob::RunRecord& run) {
     SkASSERT(run.glyphCount() > 0);
     SkASSERT(SkTextBlob::kFull_Positioning == run.positioning() ||
              SkTextBlob::kHorizontal_Positioning == run.positioning());
 
-    // First, compute the glyph position bbox.
+    SkPaint paint;
+    run.font().applyToPaint(&paint);
+    const SkRect fontBounds = paint.getFontBounds();
+    if (fontBounds.isEmpty()) {
+        // Empty font bounds are likely a font bug.  TightBounds has a better chance of
+        // producing useful results in this case.
+        return TightRunBounds(run);
+    }
+
+    // Compute the glyph position bbox.
     SkRect bounds;
     switch (run.positioning()) {
     case SkTextBlob::kHorizontal_Positioning: {
         const SkScalar* glyphPos = run.posBuffer();
         SkASSERT((void*)(glyphPos + run.glyphCount()) <= SkTextBlob::RunRecord::Next(&run));
 
         SkScalar minX = *glyphPos;
         SkScalar maxX = *glyphPos;
         for (unsigned i = 1; i < run.glyphCount(); ++i) {
             SkScalar x = glyphPos[i];
             minX = SkMinScalar(x, minX);
             maxX = SkMaxScalar(x, maxX);
         }
 
         bounds.setLTRB(minX, 0, maxX, 0);
     } break;
     case SkTextBlob::kFull_Positioning: {
         const SkPoint* glyphPosPts = reinterpret_cast<const SkPoint*>(run.posBuffer());
         SkASSERT((void*)(glyphPosPts + run.glyphCount()) <= SkTextBlob::RunRecord::Next(&run));
 
         bounds.setBounds(glyphPosPts, run.glyphCount());
     } break;
     default:
         SkFAIL("unsupported positioning mode");
     }
 
     // Expand by typeface glyph bounds.
-    SkPaint paint;
-    run.font().applyToPaint(&paint);
-    const SkRect fontBounds = paint.getFontBounds();
     bounds.fLeft   += fontBounds.left();
     bounds.fTop    += fontBounds.top();
     bounds.fRight  += fontBounds.right();
     bounds.fBottom += fontBounds.bottom();
 
     // Offset by run position.
     return bounds.makeOffset(run.offset().x(), run.offset().y());
 }
 
 void SkTextBlobBuilder::updateDeferredBounds() {
@@ skipping 173 matching lines @@
 
     fStorageUsed = 0;
     fStorageSize = 0;
     fRunCount = 0;
     fLastRun = 0;
     fBounds.setEmpty();
 
     return blob;
 }