Separate advance from offset in GlypBuffer

Source/platform/fonts/harfbuzz/FontHarfBuzz.cpp

 /*
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 139 matching lines @@
             verticalData->getVerticalTranslationsForGlyphs(font, &glyphs[0], chunkLength, reinterpret_cast<float*>(&translations[0]));
 
             x = verticalOriginX;
             y = SkFloatToScalar(point.y() + horizontalOffset - point.x());
 
             float currentWidth = 0;
             for (unsigned i = 0; i < chunkLength; ++i, ++glyphIndex) {
                 pos[i].set(
                     x + SkIntToScalar(lroundf(translations[i].x())),
                     y + -SkIntToScalar(-lroundf(currentWidth - translations[i].y())));
-                currentWidth += glyphBuffer.advanceAt(from + glyphIndex).width();
+                currentWidth += glyphBuffer.advanceAt(from + glyphIndex);
             }
             horizontalOffset += currentWidth;
             paintGlyphs(gc, font, glyphs, chunkLength, pos, textRect);
         }
 
         gc->setCTM(savedMatrix);
         return;
     }
 
-    if (!glyphBuffer.hasVerticalAdvances()) {
+    if (!glyphBuffer.hasOffsets()) {
         SkAutoSTMalloc<64, SkScalar> storage(numGlyphs);
         SkScalar* xpos = storage.get();
-        const FloatSize* adv = glyphBuffer.advances(from);
+        const float* adv = glyphBuffer.advances(from);
         for (unsigned i = 0; i < numGlyphs; i++) {
             xpos[i] = x;
-            x += SkFloatToScalar(adv[i].width());
+            x += SkFloatToScalar(adv[i]);
         }
         const Glyph* glyphs = glyphBuffer.glyphs(from);
         paintGlyphsHorizontal(gc, font, glyphs, numGlyphs, xpos, SkFloatToScalar(y), textRect);
         return;
     }
 
-    // FIXME: text rendering speed:
-    // Android has code in their WebCore fork to special case when the
-    // GlyphBuffer has no advances other than the defaults. In that case the
-    // text drawing can proceed faster. However, it's unclear when those
-    // patches may be upstreamed to WebKit so we always use the slower path
-    // here.
+    ASSERT(glyphBuffer.hasOffsets());
+    const GlyphBufferWithOffsets& glyphBufferWithOffsets =
+        static_cast<const GlyphBufferWithOffsets&>(glyphBuffer);
     SkAutoSTMalloc<32, SkPoint> storage(numGlyphs);
     SkPoint* pos = storage.get();
-    const FloatSize* adv = glyphBuffer.advances(from);
+    const FloatSize* offsets = glyphBufferWithOffsets.offsets(from);
+    const float* advances = glyphBufferWithOffsets.advances(from);
+    SkScalar advanceSoFar = SkFloatToScalar(0);
     for (unsigned i = 0; i < numGlyphs; i++) {
-        pos[i].set(x, y);
-        x += SkFloatToScalar(adv[i].width());
-        y += SkFloatToScalar(adv[i].height());
+        pos[i].set(
+            x + SkFloatToScalar(offsets[i].width()) + advanceSoFar,
+            y + SkFloatToScalar(offsets[i].height()));
+        advanceSoFar += SkFloatToScalar(advances[i]);
     }
 
-    const Glyph* glyphs = glyphBuffer.glyphs(from);
+    const Glyph* glyphs = glyphBufferWithOffsets.glyphs(from);
     paintGlyphs(gc, font, glyphs, numGlyphs, pos, textRect);
 }
 
 void Font::drawTextBlob(GraphicsContext* gc, const SkTextBlob* blob, const SkPoint& origin) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     // FIXME: It would be good to move this to Font.cpp, if we're sure that none
     // of the things in FontMac's setupPaint need to apply here.
     // See also paintGlyphs.
@@ skipping 15 matching lines @@
     if (!runInfo.run.length())
         return 0;
 
     TextDrawingModeFlags textMode = gc->textDrawingMode();
     bool fill = textMode & TextModeFill;
     bool stroke = (textMode & TextModeStroke) && gc->hasStroke();
 
     if (!fill && !stroke)
         return 0;
 
-    GlyphBuffer glyphBuffer;
+    GlyphBufferWithOffsets glyphBuffer;
     HarfBuzzShaper shaper(this, runInfo.run);
     shaper.setDrawRange(runInfo.from, runInfo.to);
     if (!shaper.shape(&glyphBuffer) || glyphBuffer.isEmpty())
         return 0;
-    FloatPoint adjustedPoint = shaper.adjustStartPoint(point);
-    return drawGlyphBuffer(gc, runInfo, glyphBuffer, adjustedPoint);
+    return drawGlyphBuffer(gc, runInfo, glyphBuffer, point);
 }
 
 void Font::drawEmphasisMarksForComplexText(GraphicsContext* context, const TextRunPaintInfo& runInfo, const AtomicString& mark, const FloatPoint& point) const
 {
     GlyphBuffer glyphBuffer;
 
     float initialAdvance = getGlyphsAndAdvancesForComplexText(runInfo, glyphBuffer, ForTextEmphasis);
 
     if (glyphBuffer.isEmpty())
         return;
@@ skipping 44 matching lines @@
     return shaper.selectionRect(point, height, from, to);
 }
 
 PassTextBlobPtr Font::buildTextBlob(const GlyphBuffer& glyphBuffer, float initialAdvance,
     const FloatRect& bounds, float& advance, bool couldUseLCD) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
     // FIXME: Except for setupPaint, this is not specific to FontHarfBuzz.
     // FIXME: Also implement the more general full-positioning path.
-    ASSERT(!glyphBuffer.hasVerticalAdvances());

[jbroman, 2014/09/26 13:02:11]

Mind putting the equivalent assertion back here?

ASSERT(!glyphBuffer.hasOffsets());

This path doesn't currently handle the complex case where there are offsets (and
it would merrily position such runs horizontally, which is wrong). It shouldn't
be reachable in such cases, but it would be nice to keep asserting that.

 
     SkTextBlobBuilder builder;
     SkScalar x = SkFloatToScalar(initialAdvance);
     SkRect skBounds = bounds;
 
     unsigned i = 0;
     while (i < glyphBuffer.size()) {
         const SimpleFontData* fontData = glyphBuffer.fontDataAt(i);
 
         // FIXME: Handle vertical text.
@@ skipping 17 matching lines @@
         unsigned start = i++;
         while (i < glyphBuffer.size() && glyphBuffer.fontDataAt(i) == fontData)
             i++;
         unsigned count = i - start;
 
         const SkTextBlobBuilder::RunBuffer& buffer = builder.allocRunPosH(paint, count, 0, &skBounds);
 
         const uint16_t* glyphs = glyphBuffer.glyphs(start);
         std::copy(glyphs, glyphs + count, buffer.glyphs);
 
-        const FloatSize* advances = glyphBuffer.advances(start);
+        const float* advances = glyphBuffer.advances(start);
         for (unsigned j = 0; j < count; j++) {
             buffer.pos[j] = x;
-            x += SkFloatToScalar(advances[j].width());
+            x += SkFloatToScalar(advances[j]);
         }
     }
 
     advance = x;
     return adoptRef(builder.build());
 }
 
 } // namespace blink