Implicit SkTextBlob bounds

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 300 matching lines @@
     }
 }
 
 void SkTextBlobBuilder::updateDeferredBounds() {
     SkASSERT(!fDeferredBounds || fRunCount > 0);
 
     if (!fDeferredBounds) {
         return;
     }
 
-    // FIXME: measure the current run & union bounds
+    SkASSERT(fLastRun >= sizeof(SkTextBlob));
+    SkTextBlob::RunRecord* run = reinterpret_cast<SkTextBlob::RunRecord*>(fStorage.get() +
+                                                                          fLastRun);
+    SkASSERT(SkPaint::kGlyphID_TextEncoding == run->font().getTextEncoding());
+
+    SkRect runBounds = SkRect::MakeEmpty();
+    if (SkTextBlob::kDefault_Positioning == run->positioning()) {
+        run->font().measureText(run->glyphBuffer(),
+                                run->glyphCount() * sizeof(uint16_t),
+                                &runBounds);
+    } else {
+        SkASSERT(SkTextBlob::kFull_Positioning == run->positioning() ||
+                 SkTextBlob::kHorizontal_Positioning == run->positioning());
+
+        SkAutoSTArray<16, SkRect> glyphBounds(run->glyphCount());
+        run->font().getTextWidths(run->glyphBuffer(),
+                                  run->glyphCount() * sizeof(uint16_t),
+                                  NULL,
+                                  glyphBounds.get());
+
+        SkScalar* glyphOffset = run->posBuffer();
+        for (unsigned i = 0; i < run->glyphCount(); ++i) {
+            if (SkTextBlob::kFull_Positioning == run->positioning()) {
+                // [ x, y, x, y... ]
+                glyphBounds[i].offset(glyphOffset[0], glyphOffset[1]);
+                SkASSERT(2 == SkTextBlob::ScalarsPerGlyph(run->positioning()));
+                glyphOffset += 2;
+            } else {
+                // [ x, x, x... ], const y applied by runBounds.offset(run->offset()) later.
+                glyphBounds[i].offset(glyphOffset[0], 0);
+                SkASSERT(1 == SkTextBlob::ScalarsPerGlyph(run->positioning()));
+                glyphOffset += 1;
+            }
+
+            runBounds.join(glyphBounds[i]);
+        }
+
+        SkASSERT((void*)glyphOffset <= SkTextBlob::RunRecord::Next(run));
+    }
+
+    runBounds.offset(run->offset());
+
+    fBounds.join(runBounds);
     fDeferredBounds = false;
 }
 
 void SkTextBlobBuilder::reserve(size_t size) {
     // We don't currently pre-allocate, but maybe someday...
     if (fStorageUsed + size <= fStorageSize) {
         return;
     }
 
     if (0 == fRunCount) {
@@ skipping 60 matching lines @@
     return true;
 }
 
 void SkTextBlobBuilder::allocInternal(const SkPaint &font,
                                       SkTextBlob::GlyphPositioning positioning,
                                       int count, SkPoint offset, const SkRect* bounds) {
     SkASSERT(count > 0);
     SkASSERT(SkPaint::kGlyphID_TextEncoding == font.getTextEncoding());
 
     if (!this->mergeRun(font, positioning, count, offset)) {
-        updateDeferredBounds();
+        this->updateDeferredBounds();
 
         size_t runSize = SkTextBlob::RunRecord::StorageSize(count, positioning);
         this->reserve(runSize);
 
         SkASSERT(fStorageUsed >= sizeof(SkTextBlob));
         SkASSERT(fStorageUsed + runSize <= fStorageSize);
 
         SkTextBlob::RunRecord* run = new (fStorage.get() + fStorageUsed)
                                          SkTextBlob::RunRecord(count, offset, font, positioning);
 
@@ skipping 69 matching lines @@
 
     fStorageUsed = 0;
     fStorageSize = 0;
     fRunCount = 0;
     fLastRun = 0;
     fBounds.setEmpty();
 
     return blob;
 }