[SkTextBlob] Custom run font record

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"
 #include "SkTypeface.h"
 #include "SkWriteBuffer.h"
 
+namespace {
+
+// TODO(fmalita): replace with SkFont.
+class RunFont : SkNoncopyable {
+public:
+    RunFont(const SkPaint& paint)
+        : fSize(paint.getTextSize())
+        , fScaleX(paint.getTextScaleX())
+        , fTypeface(SkSafeRef(paint.getTypeface()))
+        , fSkewX(paint.getTextSkewX())
+        , fHinting(paint.getHinting())
+        , fFlags(paint.getFlags() & kFlagsMask) { }
+
+    void applyToPaint(SkPaint* paint) const {
+        paint->setTextEncoding(SkPaint::kGlyphID_TextEncoding);
+        paint->setTypeface(fTypeface.get());
+        paint->setTextSize(fSize);
+        paint->setTextScaleX(fScaleX);
+        paint->setTextSkewX(fSkewX);
+        paint->setHinting(static_cast<SkPaint::Hinting>(fHinting));
+
+        paint->setFlags((paint->getFlags() & ~kFlagsMask) | fFlags);
+    }
+
+    bool operator==(const RunFont& other) const {
+        return fTypeface == other.fTypeface
+            && fSize == other.fSize
+            && fScaleX == other.fScaleX
+            && fSkewX == other.fSkewX
+            && fHinting == other.fHinting
+            && fFlags == other.fFlags;
+    }
+
+    bool operator!=(const RunFont& other) const {
+        return !(*this == other);
+    }
+private:
+    const static uint32_t kFlagsMask =
+        SkPaint::kAntiAlias_Flag          |
+        SkPaint::kUnderlineText_Flag      |
+        SkPaint::kStrikeThruText_Flag     |
+        SkPaint::kFakeBoldText_Flag       |
+        SkPaint::kLinearText_Flag         |
+        SkPaint::kSubpixelText_Flag       |
+        SkPaint::kDevKernText_Flag        |
+        SkPaint::kLCDRenderText_Flag      |
+        SkPaint::kEmbeddedBitmapText_Flag |
+        SkPaint::kAutoHinting_Flag        |
+        SkPaint::kVerticalText_Flag       |
+        SkPaint::kGenA8FromLCD_Flag       |
+        SkPaint::kDistanceFieldTextTEMP_Flag;
+
+    SkScalar                 fSize;
+    SkScalar                 fScaleX;
+
+    // Keep this SkAutoTUnref off the first position, to avoid interfering with SkNoncopyable
+    // empty baseclass optimization (http://code.google.com/p/skia/issues/detail?id=3694).
+    SkAutoTUnref<SkTypeface> fTypeface;
+    SkScalar                 fSkewX;
+
+    SK_COMPILE_ASSERT(SkPaint::kFull_Hinting < 4, insufficient_hinting_bits);
+    uint32_t                 fHinting : 2;
+    SK_COMPILE_ASSERT((kFlagsMask & 0xffff) == kFlagsMask, insufficient_flags_bits);
+    uint32_t                 fFlags : 16;
+
+    typedef SkNoncopyable INHERITED;
+};
+
+struct RunFontStorageEquivalent {
+    SkScalar fSize, fScaleX;
+    void*    fTypeface;
+    SkScalar fSkewX;
+    uint32_t fFlags;
+};
+SK_COMPILE_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[] | ...
 //    -----------------------------------------------------------------------------
 //
 //  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)
-        : fCount(count)
+        : fFont(font)
+        , fCount(count)
         , fOffset(offset)
-        , fFont(font)
         , fPositioning(pos) {
         SkDEBUGCODE(fMagic = kRunRecordMagic);
     }
 
     uint32_t glyphCount() const {
         return fCount;
     }
 
     const SkPoint& offset() const {
         return fOffset;
     }
 
-    const SkPaint& font() const {
+    const RunFont& font() const {
         return fFont;
     }
 
     GlyphPositioning positioning() const {
         return fPositioning;
     }
 
     uint16_t* glyphBuffer() const {
         // Glyph are stored immediately following the record.
         return reinterpret_cast<uint16_t*>(const_cast<RunRecord*>(this) + 1);
@@ skipping 38 matching lines @@
         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;
-    SkPaint          fFont;
     GlyphPositioning fPositioning;
 
     SkDEBUGCODE(unsigned fMagic;)
 };
 
 static int32_t gNextID = 1;
 static int32_t next_id() {
     int32_t id;
     do {
         id = sk_atomic_inc(&gNextID);
@@ skipping 139 matching lines @@
 }
 
 SkTextBlob::GlyphPositioning SkTextBlob::RunIterator::positioning() const {
     SkASSERT(!this->done());
     return fCurrentRun->positioning();
 }
 
 void SkTextBlob::RunIterator::applyFontToPaint(SkPaint* paint) const {
     SkASSERT(!this->done());
 
-    const SkPaint& font = fCurrentRun->font();
-
-    paint->setTypeface(font.getTypeface());
-    paint->setTextEncoding(font.getTextEncoding());
-    paint->setTextSize(font.getTextSize());
-    paint->setTextScaleX(font.getTextScaleX());
-    paint->setTextSkewX(font.getTextSkewX());
-    paint->setHinting(font.getHinting());
-
-    uint32_t flagsMask = SkPaint::kAntiAlias_Flag
-                       | SkPaint::kUnderlineText_Flag
-                       | SkPaint::kStrikeThruText_Flag
-                       | SkPaint::kFakeBoldText_Flag
-                       | SkPaint::kLinearText_Flag
-                       | SkPaint::kSubpixelText_Flag
-                       | SkPaint::kDevKernText_Flag
-                       | SkPaint::kLCDRenderText_Flag
-                       | SkPaint::kEmbeddedBitmapText_Flag
-                       | SkPaint::kAutoHinting_Flag
-                       | SkPaint::kVerticalText_Flag
-                       | SkPaint::kGenA8FromLCD_Flag
-                       | SkPaint::kDistanceFieldTextTEMP_Flag;
-    paint->setFlags((paint->getFlags() & ~flagsMask) | (font.getFlags() & flagsMask));
+    fCurrentRun->font().applyToPaint(paint);
 }
 
 SkTextBlobBuilder::SkTextBlobBuilder()
     : fStorageSize(0)
     , fStorageUsed(0)
     , fRunCount(0)
     , fDeferredBounds(false)
     , fLastRun(0) {
     fBounds.setEmpty();
 }
 
 SkTextBlobBuilder::~SkTextBlobBuilder() {
     if (NULL != 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;
-    run.font().measureText(run.glyphBuffer(), run.glyphCount() * sizeof(uint16_t), &bounds);
+    SkPaint paint;
+    run.font().applyToPaint(&paint);
+    paint.measureText(run.glyphBuffer(), run.glyphCount() * sizeof(uint16_t), &bounds);
 
     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.
@@ skipping 17 matching lines @@
         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.
-    const SkRect fontBounds = run.font().getFontBounds();
+    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() {
     SkASSERT(!fDeferredBounds || fRunCount > 0);
 
     if (!fDeferredBounds) {
         return;
     }
 
     SkASSERT(fLastRun >= sizeof(SkTextBlob));
     SkTextBlob::RunRecord* run = reinterpret_cast<SkTextBlob::RunRecord*>(fStorage.get() +
                                                                           fLastRun);
-    SkASSERT(SkPaint::kGlyphID_TextEncoding == run->font().getTextEncoding());
 
     // FIXME: we should also use conservative bounds for kDefault_Positioning.
     SkRect runBounds = SkTextBlob::kDefault_Positioning == run->positioning() ?
                        TightRunBounds(*run) : ConservativeRunBounds(*run);
     fBounds.join(runBounds);
     fDeferredBounds = false;
 }
 
 void SkTextBlobBuilder::reserve(size_t size) {
     // We don't currently pre-allocate, but maybe someday...
@@ skipping 155 matching lines @@
 
     fStorageUsed = 0;
     fStorageSize = 0;
     fRunCount = 0;
     fLastRun = 0;
     fBounds.setEmpty();
 
     return blob;
 }