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.
     SkAutoSTMalloc<32, SkPoint> storage(numGlyphs);
     SkPoint* pos = storage.get();
-    const FloatSize* adv = glyphBuffer.advances(from);
+    const FloatSize* offsets = glyphBuffer.offsets(from);
+    const float* advances = glyphBuffer.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);
     paintGlyphs(gc, font, glyphs, numGlyphs, pos, textRect);
 }
 
 void Font::drawTextBlob(GraphicsContext* gc, const SkTextBlob* blob, const SkPoint& origin) const
 {
     ASSERT(RuntimeEnabledFeatures::textBlobEnabled());
 
@@ skipping 23 matching lines @@
     bool stroke = (textMode & TextModeStroke) && gc->hasStroke();
 
     if (!fill && !stroke)
         return 0;
 
     GlyphBuffer 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());
 
     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 FloatSize* offsets = glyphBuffer.offsets(start);

[f(malita), 2014/09/25 16:42:05]

I think we still want advances here. We only support text blobs for simple text,
in which case offsets() is empty IIUC.

[eae, 2014/09/26 05:26:51]

Right, thanks!

         for (unsigned j = 0; j < count; j++) {
             buffer.pos[j] = x;
-            x += SkFloatToScalar(advances[j].width());
+            x += SkFloatToScalar(offsets[j].width());
         }
     }
 
     advance = x;
     return adoptRef(builder.build());
 }
 
 } // namespace blink