Separate advance from offset in GlypBuffer

Source/platform/fonts/harfbuzz/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. 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.
@@ skipping 260 matching lines @@
     m_glyphs.resize(m_numGlyphs);
     m_advances.resize(m_numGlyphs);
     m_glyphToCharacterIndexes.resize(m_numGlyphs);
     m_offsets.resize(m_numGlyphs);
 }
 
 inline void HarfBuzzShaper::HarfBuzzRun::setGlyphAndPositions(unsigned index, uint16_t glyphId, float advance, float offsetX, float offsetY)
 {
     m_glyphs[index] = glyphId;
     m_advances[index] = advance;
-    m_offsets[index] = FloatPoint(offsetX, offsetY);
+    m_offsets[index] = FloatSize(offsetX, offsetY);
 }
 
 int HarfBuzzShaper::HarfBuzzRun::characterIndexForXPosition(float targetX)
 {
     ASSERT(targetX <= m_width);
     float currentX = 0;
     float currentAdvance = m_advances[0];
     unsigned glyphIndex = 0;
 
     // Sum up advances that belong to a character.
@@ skipping 275 matching lines @@
     if (!RuntimeEnabledFeatures::subpixelFontScalingEnabled())
         m_totalWidth = roundf(m_totalWidth);
 
     if (m_harfBuzzRuns.last()->hasGlyphToCharacterIndexes()
         && glyphBuffer && !fillGlyphBuffer(glyphBuffer))
         return false;
 
     return true;
 }
 
-FloatPoint HarfBuzzShaper::adjustStartPoint(const FloatPoint& point)
-{
-    return point + m_startOffset;
-}
-
 static inline int handleMultipleUChar(
     UChar32 character,
     unsigned clusterLength,
     const SimpleFontData* currentFontData,
     const UChar* currentCharacterPosition,
     const UChar* markCharactersEnd,
     const UChar* normalizedBufferEnd)
 {
     if (U_GET_GC_MASK(character) & U_GC_M_MASK) {
         int markLength = clusterLength;
@@ skipping 354 matching lines @@
         glyphBounds.move(glyphOrigin.x(), glyphOrigin.y());
         m_glyphBoundingBox.unite(glyphBounds);
         glyphOrigin += FloatSize(advance + offsetX, offsetY);
 
         totalAdvance += advance;
     }
     currentRun->setWidth(totalAdvance > 0.0 ? totalAdvance : 0.0);
     m_totalWidth += currentRun->width();
 }
 
-void HarfBuzzShaper::fillGlyphBufferFromHarfBuzzRun(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun, FloatPoint& firstOffsetOfNextRun)
+void HarfBuzzShaper::fillGlyphBufferFromHarfBuzzRun(GlyphBufferWithOffsets* glyphBuffer, HarfBuzzRun* currentRun)
 {
-    FloatPoint* offsets = currentRun->offsets();
+    FloatSize* offsets = currentRun->offsets();
     uint16_t* glyphs = currentRun->glyphs();
     float* advances = currentRun->advances();
     unsigned numGlyphs = currentRun->numGlyphs();
     uint16_t* glyphToCharacterIndexes = currentRun->glyphToCharacterIndexes();
-    for (unsigned i = 0; i < numGlyphs; ++i) {
-        uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
-        FloatPoint& currentOffset = offsets[i];
-        FloatPoint& nextOffset = (i == numGlyphs - 1) ? firstOffsetOfNextRun : offsets[i + 1];
-        float glyphAdvanceX = advances[i] + nextOffset.x() - currentOffset.x();
-        float glyphAdvanceY = nextOffset.y() - currentOffset.y();
-        if (m_run.rtl()) {
+    float advanceSoFar = 0;
+    if (m_run.rtl()) {
+        for (unsigned i = 0; i < numGlyphs; ++i) {
+            uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
             if (currentCharacterIndex >= m_toIndex)
-                m_startOffset.move(glyphAdvanceX, glyphAdvanceY);
+                advanceSoFar += advances[i];
             else if (currentCharacterIndex >= m_fromIndex)
-                glyphBuffer->add(glyphs[i], currentRun->fontData(), FloatSize(glyphAdvanceX, glyphAdvanceY));
-        } else {
+                glyphBuffer->add(glyphs[i], currentRun->fontData(), offsets[i] + FloatSize(advanceSoFar, 0), advances[i]);
+        }
+    } else {
+        for (unsigned i = 0; i < numGlyphs; ++i) {
+            uint16_t currentCharacterIndex = currentRun->startIndex() + glyphToCharacterIndexes[i];
             if (currentCharacterIndex < m_fromIndex)
-                m_startOffset.move(glyphAdvanceX, glyphAdvanceY);
+                advanceSoFar += advances[i];
             else if (currentCharacterIndex < m_toIndex)
-                glyphBuffer->add(glyphs[i], currentRun->fontData(), FloatSize(glyphAdvanceX, glyphAdvanceY));
+                glyphBuffer->add(glyphs[i], currentRun->fontData(), offsets[i] + FloatSize(advanceSoFar, 0), advances[i]);
         }
     }
 }
 
 void HarfBuzzShaper::fillGlyphBufferForTextEmphasis(GlyphBuffer* glyphBuffer, HarfBuzzRun* currentRun)
 {
     // FIXME: Instead of generating a synthetic GlyphBuffer here which is then used by the
     // drawEmphasisMarks method of FontFastPath, we should roll our own emphasis mark drawing function.
 
     float* advances = currentRun->advances();
@@ skipping 42 matching lines @@
             clusterStart = clusterEnd;
             clusterAdvance = 0;
         }
     }
 }
 
 bool HarfBuzzShaper::fillGlyphBuffer(GlyphBuffer* glyphBuffer)
 {
     unsigned numRuns = m_harfBuzzRuns.size();
     if (m_run.rtl()) {
-        m_startOffset = m_harfBuzzRuns.last()->offsets()[0];
         for (int runIndex = numRuns - 1; runIndex >= 0; --runIndex) {
             HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
             if (!currentRun->hasGlyphToCharacterIndexes()) {
                 // FIXME: bug 337886, 359664
                 continue;
             }
-            FloatPoint firstOffsetOfNextRun = !runIndex ? FloatPoint() : m_harfBuzzRuns[runIndex - 1]->offsets()[0];
-            if (m_forTextEmphasis == ForTextEmphasis)
+            if (m_forTextEmphasis == ForTextEmphasis) {
+                ASSERT(!glyphBuffer->hasOffsets());
                 fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun);
-            else
-                fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, firstOffsetOfNextRun);
+            } else {
+                ASSERT(glyphBuffer->hasOffsets());
+                fillGlyphBufferFromHarfBuzzRun(
+                    static_cast<GlyphBufferWithOffsets*>(glyphBuffer), currentRun);
+            }
         }
     } else {
-        m_startOffset = m_harfBuzzRuns.first()->offsets()[0];
         for (unsigned runIndex = 0; runIndex < numRuns; ++runIndex) {
             HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
             if (!currentRun->hasGlyphToCharacterIndexes()) {
                 // FIXME: bug 337886, 359664
                 continue;
             }
-            FloatPoint firstOffsetOfNextRun = runIndex == numRuns - 1 ? FloatPoint() : m_harfBuzzRuns[runIndex + 1]->offsets()[0];
-            if (m_forTextEmphasis == ForTextEmphasis)
+            if (m_forTextEmphasis == ForTextEmphasis) {
+                ASSERT(!glyphBuffer->hasOffsets());
                 fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun);
-            else
-                fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, firstOffsetOfNextRun);
+            } else {
+                ASSERT(glyphBuffer->hasOffsets());
+                fillGlyphBufferFromHarfBuzzRun(
+                    static_cast<GlyphBufferWithOffsets*>(glyphBuffer), currentRun);
+            }
         }
     }
     return glyphBuffer->size();
 }
 
 int HarfBuzzShaper::offsetForPosition(float targetX)
 {
     int charactersSoFar = 0;
     float currentX = 0;
 
@@ skipping 69 matching lines @@
             point.x() + fromX, point.x() + toX,
             point.y(), height);
     }
 
     return Font::pixelSnappedSelectionRect(
         point.x() + toX, point.x() + fromX,
         point.y(), height);
 }
 
 } // namespace blink