SkTextBlob: Begin implementing Extended TextBlob API

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 "SkTextBlobRunIterator.h"
 
 #include "SkReadBuffer.h"
@@ skipping 82 matching lines @@
     uint32_t fFlags;
 };
 static_assert(sizeof(RunFont) == sizeof(RunFontStorageEquivalent), "runfont_should_stay_packed");
 
 } // anonymous namespace
 
 //
 // Textblob data is laid out into externally-managed storage as follows:
 //
 //    -----------------------------------------------------------------------------
 //   | SkTextBlob | RunRecord | Glyphs[] | Pos[] | RunRecord | Glyphs[] | Pos[] | ...

[f(malita), 2016/06/27 20:21:55]

We should also update this layout diagram w/ text info.

[hal.canary, 2016/06/28 15:39:12]

Done.

 //    -----------------------------------------------------------------------------
 //
 //  Each run record describes a text blob run, and can be used to determine the (implicit)
 //  location of the following record.
 
 SkDEBUGCODE(static const unsigned kRunRecordMagic = 0xb10bcafe;)
 
 class SkTextBlob::RunRecord {
 public:
-    RunRecord(uint32_t count, const SkPoint& offset, const SkPaint& font, GlyphPositioning pos)
+    RunRecord(uint32_t count, const SkPoint& offset, const SkPaint& font, GlyphPositioning pos, bool extended)
         : fFont(font)
         , fCount(count)
         , fOffset(offset)
-        , fPositioning(pos) {
+        , fPositioning(pos)
+        , fExtended(extended) {
         SkDEBUGCODE(fMagic = kRunRecordMagic);
     }
 
     uint32_t glyphCount() const {
         return fCount;
     }
 
     const SkPoint& offset() const {
         return fOffset;
     }
 
     const RunFont& font() const {
         return fFont;
     }
 
     GlyphPositioning positioning() const {
         return fPositioning;
     }
 
     uint16_t* glyphBuffer() const {
+        static_assert(SkIsAlignPtr(sizeof(RunRecord)), "");
         // Glyph are stored immediately following the record.

[f(malita), 2016/06/27 20:21:55]

nit: "Glyphs", while we're here

[hal.canary, 2016/06/28 15:39:13]

Done.

         return reinterpret_cast<uint16_t*>(const_cast<RunRecord*>(this) + 1);
     }
 
     SkScalar* posBuffer() const {
         // Position scalars follow the (aligned) glyph buffer.
         return reinterpret_cast<SkScalar*>(reinterpret_cast<uint8_t*>(this->glyphBuffer()) +
                                            SkAlign4(fCount * sizeof(uint16_t)));
     }
 
-    static size_t StorageSize(int glyphCount, SkTextBlob::GlyphPositioning positioning) {
+    uint32_t textSize() const {

[f(malita), 2016/06/27 20:21:55]

maybe uint32_t* textSizePtr() for reuse?

[hal.canary, 2016/06/28 15:39:12]

Done.

+        // textSize follows the position buffer.
+        if (!fExtended) { return 0; }
+        return *(uint32_t*)(&this->posBuffer()[ScalarsPerGlyph(fPositioning) * fCount]);

[f(malita), 2016/06/27 20:21:55]

nit: reinterpret_cast instead of old-style cast?

[hal.canary, 2016/06/28 15:39:12]

Done.

+    }
+
+    void setTextSize(uint32_t size) {

[f(malita), 2016/06/27 20:21:55]

I think we can get rid of the setter, see suggestion below.

[hal.canary, 2016/06/28 15:39:12]

Done.

+        SkASSERT(fExtended);
+        *(uint32_t*)(&this->posBuffer()[ScalarsPerGlyph(fPositioning) * fCount]) = size;

[f(malita), 2016/06/27 20:21:55]

nit: reinterpret_cast

[hal.canary, 2016/06/28 15:39:12]

Done.

+
+    }
+    uint32_t* clusterBuffer() const {
+        // clusters follow the textSize.
+        if (!fExtended) { return nullptr; }
+        return (uint32_t*)(&this->posBuffer()[ScalarsPerGlyph(fPositioning) * fCount]) + 1;

[f(malita), 2016/06/27 20:21:55]

return textSizePtr() + 1 ?

[hal.canary, 2016/06/28 15:39:12]

Done.

+    }
+
+    char* textBuffer() const {
+        if (!fExtended) { return nullptr; }
+        return (char*)((uint32_t*)(&this->posBuffer()[ScalarsPerGlyph(fPositioning) * fCount]) + 1 + fCount);

[f(malita), 2016/06/27 20:21:55]

return reinterpret_cast<char*>(clusterBuffer() + fCount) ?

[hal.canary, 2016/06/28 15:39:13]

Done.

+    }
+
+    static size_t StorageSize(int glyphCount, int textSize, SkTextBlob::GlyphPositioning positioning) {
         // RunRecord object + (aligned) glyph buffer + position buffer
-        return SkAlignPtr(sizeof(SkTextBlob::RunRecord)
-                        + SkAlign4(glyphCount* sizeof(uint16_t))
-                        + glyphCount * sizeof(SkScalar) * ScalarsPerGlyph(positioning));
+        if (0 == textSize) {
+            return SkAlignPtr(sizeof(SkTextBlob::RunRecord)
+                              + SkAlign4(glyphCount* sizeof(uint16_t))
+                              + glyphCount * sizeof(SkScalar) * ScalarsPerGlyph(positioning));
+        } else {
+            return SkAlignPtr(sizeof(SkTextBlob::RunRecord)
+                              + SkAlign4(glyphCount* sizeof(uint16_t))
+                              + glyphCount * sizeof(SkScalar) * ScalarsPerGlyph(positioning)
+                              + sizeof(uint32_t)
+                              + sizeof(uint32_t) * glyphCount
+                              + textSize);
+        }

[f(malita), 2016/06/27 20:21:55]

nit: maybe somewhat DRY-er

  size_t size = ...;
  if (textSize) {
      size += ...;
  }
  return SkAlignPtr(size);

[hal.canary, 2016/06/28 15:39:12]

Done.

     }
 
     static const RunRecord* First(const SkTextBlob* blob) {
         // The first record (if present) is stored following the blob object.
         return reinterpret_cast<const RunRecord*>(blob + 1);
     }
 
     static const RunRecord* Next(const RunRecord* run) {
-        return reinterpret_cast<const RunRecord*>(reinterpret_cast<const uint8_t*>(run)
-            + StorageSize(run->glyphCount(), run->positioning()));
+        return reinterpret_cast<const RunRecord*>(
+                reinterpret_cast<const uint8_t*>(run)
+                + StorageSize(run->glyphCount(), run->textSize(), run->positioning()));
     }
 
     void validate(const uint8_t* storageTop) const {
         SkASSERT(kRunRecordMagic == fMagic);
         SkASSERT((uint8_t*)Next(this) <= storageTop);
+
         SkASSERT(glyphBuffer() + fCount <= (uint16_t*)posBuffer());
         SkASSERT(posBuffer() + fCount * ScalarsPerGlyph(fPositioning) <= (SkScalar*)Next(this));

[f(malita), 2016/06/27 20:21:55]

We should also add asserts for the new buffers.

[hal.canary, 2016/06/28 15:39:12]

Done.

     }
 
 private:
     friend class SkTextBlobBuilder;
 
     void grow(uint32_t count) {
         SkScalar* initialPosBuffer = posBuffer();
         uint32_t initialCount = fCount;
         fCount += count;
 
         // Move the initial pos scalars to their new location.
         size_t copySize = initialCount * sizeof(SkScalar) * ScalarsPerGlyph(fPositioning);
         SkASSERT((uint8_t*)posBuffer() + copySize <= (uint8_t*)Next(this));
 
         // memmove, as the buffers may overlap
         memmove(posBuffer(), initialPosBuffer, copySize);
     }
 
     RunFont          fFont;
     uint32_t         fCount;
     SkPoint          fOffset;
     GlyphPositioning fPositioning;
+    bool             fExtended;
 
     SkDEBUGCODE(unsigned fMagic;)
 };

[f(malita), 2016/06/27 20:21:55]

Similar to RunFont above:

namespace {

struct RunRecordStorageEquivalent {
    RunFont  fFont;
    SkPoint  fOffset;
    uint32_t fCount, fFlags;
};

static_assert(sizeof(RunRecord) == sizeof(RunRecordStorageEquivalent),
"runrecord_should_stay_packed");
}

?

[hal.canary, 2016/06/28 15:39:12]

Done.

 
 static int32_t gNextID = 1;
 static int32_t next_id() {
     int32_t id;
     do {
         id = sk_atomic_inc(&gNextID);
     } while (id == SK_InvalidGenID);
     return id;
 }
 
 SkTextBlob::SkTextBlob(int runCount, const SkRect& bounds)
     : fRunCount(runCount)
     , fBounds(bounds)
     , fUniqueID(next_id()) {
+    #ifdef SK_DEBUG
+        static_assert(sizeof(SkTextBlob::RunRecord) == SkAlignPtr(sizeof(void*) + 29 + 4), "");
+    #else
+        static_assert(sizeof(SkTextBlob::RunRecord) == SkAlignPtr(sizeof(void*) + 29), "");
+    #endif

[f(malita), 2016/06/27 20:21:55]

Not needed with RunRecordStorageEquivalent above.

[hal.canary, 2016/06/28 15:39:12]

Done.

 }
 
 SkTextBlob::~SkTextBlob() {
     const RunRecord* run = RunRecord::First(this);
     for (int i = 0; i < fRunCount; ++i) {
         const RunRecord* nextRun = RunRecord::Next(run);
         SkDEBUGCODE(run->validate((uint8_t*)this + fStorageSize);)
         run->~RunRecord();
         run = nextRun;
     }
 }
 
+namespace {
+union PositioningAndExtended {
+    int32_t intValue;
+    struct {
+        SkTextBlob::GlyphPositioning positioning;
+        bool extended;
+        uint16_t padding;
+    };
+};
+} // namespace
+
 void SkTextBlob::flatten(SkWriteBuffer& buffer) const {
     int runCount = fRunCount;
 
     buffer.write32(runCount);
     buffer.writeRect(fBounds);
 
     SkPaint runPaint;
     SkTextBlobRunIterator it(this);
     while (!it.done()) {
         SkASSERT(it.glyphCount() > 0);
 
         buffer.write32(it.glyphCount());
-        buffer.write32(it.positioning());
+        PositioningAndExtended pe;
+        pe.intValue = 0;
+        pe.positioning = it.positioning();
+        SkASSERT((int32_t)it.positioning() == pe.intValue);  // backwards compat.
+        pe.extended = it.isExtended();
+        buffer.write32(pe.intValue);
+        if (pe.extended) {
+            buffer.write32(it.textSize());
+        }
         buffer.writePoint(it.offset());
         // This should go away when switching to SkFont
         it.applyFontToPaint(&runPaint);
         buffer.writePaint(runPaint);
 
         buffer.writeByteArray(it.glyphs(), it.glyphCount() * sizeof(uint16_t));
         buffer.writeByteArray(it.pos(),
             it.glyphCount() * sizeof(SkScalar) * ScalarsPerGlyph(it.positioning()));
+        if (pe.extended) {
+            buffer.writeByteArray(it.clusterBuffer(), sizeof(uint32_t) * it.glyphCount());
+            buffer.writeByteArray(it.textBuffer(), it.textSize());
+        }
 
         it.next();
         SkDEBUGCODE(runCount--);
     }
     SkASSERT(0 == runCount);
 }
 
 const SkTextBlob* SkTextBlob::CreateFromBuffer(SkReadBuffer& reader) {
     int runCount = reader.read32();
     if (runCount < 0) {
         return nullptr;
     }
 
     SkRect bounds;
     reader.readRect(&bounds);
 
     SkTextBlobBuilder blobBuilder;
     for (int i = 0; i < runCount; ++i) {
         int glyphCount = reader.read32();
-        GlyphPositioning pos = static_cast<GlyphPositioning>(reader.read32());
+
+        PositioningAndExtended pe;
+        pe.intValue = reader.read32();
+        GlyphPositioning pos = pe.positioning;
         if (glyphCount <= 0 || pos > kFull_Positioning) {
             return nullptr;
         }
+        uint32_t textSize = pe.extended ? (uint32_t)reader.read32() : 0;
 
         SkPoint offset;
         reader.readPoint(&offset);
         SkPaint font;
         reader.readPaint(&font);
 
         const SkTextBlobBuilder::RunBuffer* buf = nullptr;
         switch (pos) {
         case kDefault_Positioning:
-            buf = &blobBuilder.allocRun(font, glyphCount, offset.x(), offset.y(), &bounds);
+            buf = &blobBuilder.allocRunText(font, glyphCount, offset.x(), offset.y(),
+                                            textSize, SkString(), &bounds);
             break;
         case kHorizontal_Positioning:
-            buf = &blobBuilder.allocRunPosH(font, glyphCount, offset.y(), &bounds);
+            buf = &blobBuilder.allocRunTextPosH(font, glyphCount, offset.y(),
+                                                textSize, SkString(), &bounds);
             break;
         case kFull_Positioning:
-            buf = &blobBuilder.allocRunPos(font, glyphCount, &bounds);
+            buf = &blobBuilder.allocRunTextPos(font, glyphCount, textSize, SkString(), &bounds);
             break;
         default:
             return nullptr;
         }
 
         if (!reader.readByteArray(buf->glyphs, glyphCount * sizeof(uint16_t)) ||
             !reader.readByteArray(buf->pos,
                                   glyphCount * sizeof(SkScalar) * ScalarsPerGlyph(pos))) {
             return nullptr;
         }
+
+        if (pe.extended) {
+            if (!reader.readByteArray(buf->clusters, glyphCount * sizeof(uint32_t))  ||
+                !reader.readByteArray(buf->utf8text, textSize)) {
+                return nullptr;
+            }
+        }
     }
 
     return blobBuilder.build();
 }
 
 unsigned SkTextBlob::ScalarsPerGlyph(GlyphPositioning pos) {
     // GlyphPositioning values are directly mapped to scalars-per-glyph.
     SkASSERT(pos <= 2);
     return pos;
 }
@@ skipping 42 matching lines @@
     SkASSERT(!this->done());
     return fCurrentRun->positioning();
 }
 
 void SkTextBlobRunIterator::applyFontToPaint(SkPaint* paint) const {
     SkASSERT(!this->done());
 
     fCurrentRun->font().applyToPaint(paint);
 }
 
+bool SkTextBlobRunIterator::isExtended() const {
+    SkASSERT(!this->done());
+    return fCurrentRun->textSize() > 0;
+}
+uint32_t* SkTextBlobRunIterator::clusterBuffer() const {
+    SkASSERT(!this->done());
+    return fCurrentRun->clusterBuffer();
+}
+uint32_t SkTextBlobRunIterator::textSize() const {
+    SkASSERT(!this->done());
+    return fCurrentRun->textSize();
+}
+char* SkTextBlobRunIterator::textBuffer() const {
+    SkASSERT(!this->done());
+    return fCurrentRun->textBuffer();
+}
+
+
 bool SkTextBlobRunIterator::isLCD() const {
     return SkToBool(fCurrentRun->font().flags() & SkPaint::kLCDRenderText_Flag);
 }
 
 SkTextBlobBuilder::SkTextBlobBuilder()
     : fStorageSize(0)
     , fStorageUsed(0)
     , fRunCount(0)
     , fDeferredBounds(false)
     , fLastRun(0) {
@@ skipping 143 matching lines @@
     if (0 == fLastRun) {
         SkASSERT(0 == fRunCount);
         return false;
     }
 
     SkASSERT(fLastRun >= sizeof(SkTextBlob));
     SkTextBlob::RunRecord* run = reinterpret_cast<SkTextBlob::RunRecord*>(fStorage.get() +
                                                                           fLastRun);
     SkASSERT(run->glyphCount() > 0);
 
+    if (run->textSize() != 0) {
+        return false;
+    }
+
     if (run->positioning() != positioning
         || run->font() != font
         || (run->glyphCount() + count < run->glyphCount())) {
         return false;
     }
 
     // we can merge same-font/same-positioning runs in the following cases:
     //   * fully positioned run following another fully positioned run
     //   * horizontally postioned run following another horizontally positioned run with the same
     //     y-offset
     if (SkTextBlob::kFull_Positioning != positioning
         && (SkTextBlob::kHorizontal_Positioning != positioning
             || run->offset().y() != offset.y())) {
         return false;
     }
 
-    size_t sizeDelta = SkTextBlob::RunRecord::StorageSize(run->glyphCount() + count, positioning) -
-                       SkTextBlob::RunRecord::StorageSize(run->glyphCount(), positioning);
+    size_t sizeDelta = SkTextBlob::RunRecord::StorageSize(run->glyphCount() + count, 0, positioning) -
+                       SkTextBlob::RunRecord::StorageSize(run->glyphCount(), 0, positioning);
     this->reserve(sizeDelta);
 
     // reserve may have realloced
     run = reinterpret_cast<SkTextBlob::RunRecord*>(fStorage.get() + fLastRun);
     uint32_t preMergeCount = run->glyphCount();
     run->grow(count);
 
     // Callers expect the buffers to point at the newly added slice, ant not at the beginning.
     fCurrentRunBuffer.glyphs = run->glyphBuffer() + preMergeCount;
     fCurrentRunBuffer.pos = run->posBuffer()
                           + preMergeCount * SkTextBlob::ScalarsPerGlyph(positioning);
 
     fStorageUsed += sizeDelta;
 
     SkASSERT(fStorageUsed <= fStorageSize);
     run->validate(fStorage.get() + fStorageUsed);
 
     return true;
 }
 
 void SkTextBlobBuilder::allocInternal(const SkPaint &font,
                                       SkTextBlob::GlyphPositioning positioning,
-                                      int count, SkPoint offset, const SkRect* bounds) {
+                                      int count, int textSize, SkPoint offset, const SkRect* bounds) {
     SkASSERT(count > 0);
+    SkASSERT(textSize >= 0);
     SkASSERT(SkPaint::kGlyphID_TextEncoding == font.getTextEncoding());
 
-    if (!this->mergeRun(font, positioning, count, offset)) {
+    if (textSize != 0 || !this->mergeRun(font, positioning, count, offset)) {
         this->updateDeferredBounds();
 
-        size_t runSize = SkTextBlob::RunRecord::StorageSize(count, positioning);
+        size_t runSize = SkTextBlob::RunRecord::StorageSize(count, textSize, 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);
-
+                                     SkTextBlob::RunRecord(count, offset, font, positioning, textSize > 0);
+        if (textSize > 0) {
+            run->setTextSize(textSize);

[f(malita), 2016/06/27 20:21:55]

Why not pass textSize to the RunRecord ctor?  Then I think we don't need the
setter anymore.

[hal.canary, 2016/06/28 15:39:13]

Done.

+        }
         fCurrentRunBuffer.glyphs = run->glyphBuffer();
         fCurrentRunBuffer.pos = run->posBuffer();
+        fCurrentRunBuffer.utf8text = run->textBuffer();
+        fCurrentRunBuffer.clusters = run->clusterBuffer();
 
         fLastRun = fStorageUsed;
         fStorageUsed += runSize;
         fRunCount++;
 
         SkASSERT(fStorageUsed <= fStorageSize);
         run->validate(fStorage.get() + fStorageUsed);
+    } else {
+        fCurrentRunBuffer.utf8text = nullptr;
+        fCurrentRunBuffer.clusters = nullptr;

[f(malita), 2016/06/27 20:21:55]

I don't think we need to clear these: textSize == 0 AND mergeRun() succeeded
(which implies textSize == 0 for prev run also).

Maybe SkASSERTs instead?

[hal.canary, 2016/06/28 15:39:12]

Done.

     }
 
     if (!fDeferredBounds) {
         if (bounds) {
             fBounds.join(*bounds);
         } else {
             fDeferredBounds = true;
         }
     }
 }
 
-const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRun(const SkPaint& font, int count,
-                                                                SkScalar x, SkScalar y,
-                                                                const SkRect* bounds) {
-    this->allocInternal(font, SkTextBlob::kDefault_Positioning, count, SkPoint::Make(x, y), bounds);
-
+const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRunText(const SkPaint& font, int count,
+                                                                    SkScalar x, SkScalar y,
+                                                                    int textByteCount,
+                                                                    SkString lang,
+                                                                    const SkRect* bounds) {
+    this->allocInternal(font, SkTextBlob::kDefault_Positioning, count, textByteCount, SkPoint::Make(x, y), bounds);
     return fCurrentRunBuffer;
 }
 
-const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRunPosH(const SkPaint& font, int count,
-                                                                    SkScalar y,
-                                                                    const SkRect* bounds) {
-    this->allocInternal(font, SkTextBlob::kHorizontal_Positioning, count, SkPoint::Make(0, y),
+const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRunTextPosH(const SkPaint& font, int count,
+                                                                        SkScalar y,
+                                                                        int textByteCount,
+                                                                        SkString lang,
+                                                                        const SkRect* bounds) {
+    this->allocInternal(font, SkTextBlob::kHorizontal_Positioning, count, textByteCount, SkPoint::Make(0, y),
                         bounds);
 
     return fCurrentRunBuffer;
 }
 
-const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRunPos(const SkPaint& font, int count,
-                                                                   const SkRect *bounds) {
-    this->allocInternal(font, SkTextBlob::kFull_Positioning, count, SkPoint::Make(0, 0), bounds);
+const SkTextBlobBuilder::RunBuffer& SkTextBlobBuilder::allocRunTextPos(const SkPaint& font, int count,
+                                                                       int textByteCount,
+                                                                       SkString lang,
+                                                                       const SkRect *bounds) {
+   this->allocInternal(font, SkTextBlob::kFull_Positioning, count, textByteCount, SkPoint::Make(0, 0), bounds);
 
     return fCurrentRunBuffer;
 }
 
 const SkTextBlob* SkTextBlobBuilder::build() {
     SkASSERT((fRunCount > 0) == (nullptr != fStorage.get()));
 
     this->updateDeferredBounds();
 
     if (0 == fRunCount) {
         SkASSERT(nullptr == fStorage.get());
         fStorageUsed = sizeof(SkTextBlob);
         fStorage.realloc(fStorageUsed);
     }
 
     const SkTextBlob* blob = new (fStorage.release()) SkTextBlob(fRunCount, fBounds);
     SkDEBUGCODE(const_cast<SkTextBlob*>(blob)->fStorageSize = fStorageSize;)
 
     SkDEBUGCODE(
         size_t validateSize = sizeof(SkTextBlob);
         const SkTextBlob::RunRecord* run = SkTextBlob::RunRecord::First(blob);
         for (int i = 0; i < fRunCount; ++i) {
-            validateSize += SkTextBlob::RunRecord::StorageSize(run->fCount, run->fPositioning);
+            validateSize += SkTextBlob::RunRecord::StorageSize(
+                    run->fCount, run->textSize(), run->fPositioning);
             run->validate(reinterpret_cast<const uint8_t*>(blob) + fStorageUsed);
             run = SkTextBlob::RunRecord::Next(run);
         }
         SkASSERT(validateSize == fStorageUsed);
     )
 
     fStorageUsed = 0;
     fStorageSize = 0;
     fRunCount = 0;
     fLastRun = 0;
     fBounds.setEmpty();
 
     return blob;
 }