Add ShapeResult::RunInfo glyph iterators

third_party/WebKit/Source/platform/fonts/shaping/ShapeResultBuffer.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/fonts/shaping/ShapeResultBuffer.h"
 
 #include "platform/fonts/CharacterRange.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
@@ skipping 71 matching lines @@
   int numGraphemes = -1;
   while (0 <= cursorPos) {
     cursorPos = cursorPosIterator->next();
     numGraphemes++;
   }
   return std::max(0, numGraphemes);
 }
 
 }  // anonymous namespace
 
-template <TextDirection direction>
-float ShapeResultBuffer::fillGlyphBufferForRun(GlyphBuffer* glyphBuffer,
-                                               const ShapeResult::RunInfo* run,
-                                               const TextRun& textRun,
-                                               float initialAdvance,
-                                               unsigned from,
-                                               unsigned to,
-                                               unsigned runOffset) {
-  if (!run)
-    return 0;
-  float advanceSoFar = initialAdvance;
-  const unsigned numGlyphs = run->m_glyphData.size();
-  for (unsigned i = 0; i < numGlyphs; ++i) {
-    const HarfBuzzRunGlyphData& glyphData = run->m_glyphData[i];
-    uint16_t currentCharacterIndex =
-        run->m_startIndex + glyphData.characterIndex + runOffset;
-    if ((direction == TextDirection::kRtl && currentCharacterIndex >= to) ||
-        (direction == TextDirection::kLtr && currentCharacterIndex < from)) {
-      advanceSoFar += glyphData.advance;
-    } else if ((direction == TextDirection::kRtl &&
-                currentCharacterIndex >= from) ||
-               (direction == TextDirection::kLtr &&
-                currentCharacterIndex < to)) {
-      addGlyphToBuffer(glyphBuffer, advanceSoFar, run->m_direction,
-                       run->m_fontData.get(), glyphData, textRun,
-                       currentCharacterIndex);
-      advanceSoFar += glyphData.advance;
-    }
+float ShapeResultBuffer::fillGlyphBufferForResult(GlyphBuffer* glyphBuffer,
+                                                  const ShapeResult& result,
+                                                  const TextRun& textRun,
+                                                  float initialAdvance,
+                                                  unsigned from,
+                                                  unsigned to,
+                                                  unsigned runOffset) {
+  auto totalAdvance = initialAdvance;
+
+  for (const auto& run : result.m_runs) {
+    totalAdvance = run->forEachGlyphInRange(
+        totalAdvance, from, to, runOffset,
+        [&](const HarfBuzzRunGlyphData& glyphData, float totalAdvance,
+            uint16_t characterIndex) -> bool {
+
+          addGlyphToBuffer(glyphBuffer, totalAdvance, run->m_direction,
+                           run->m_fontData.get(), glyphData, textRun,
+                           characterIndex);
+          return true;
+        });
   }
-  return advanceSoFar - initialAdvance;
+
+  return totalAdvance;
 }
 
 float ShapeResultBuffer::fillGlyphBufferForTextEmphasisRun(
     GlyphBuffer* glyphBuffer,
     const ShapeResult::RunInfo* run,
     const TextRun& textRun,
     const GlyphData* emphasisData,
     float initialAdvance,
     unsigned from,
     unsigned to,
@@ skipping 75 matching lines @@
       clusterStart = clusterEnd;
       clusterAdvance = 0;
     }
   }
   return advanceSoFar - initialAdvance;
 }
 
 float ShapeResultBuffer::fillFastHorizontalGlyphBuffer(
     GlyphBuffer* glyphBuffer,
     const TextRun& textRun) const {
-  ASSERT(!hasVerticalOffsets());
+  DCHECK(!hasVerticalOffsets());
 
   float advance = 0;
 
   unsigned characterIndex = 0;
   for (unsigned i = 0; i < m_results.size(); ++i) {
     const auto& wordResult = isLeftToRightDirection(textRun.direction())
                                  ? m_results[i]
                                  : m_results[m_results.size() - 1 - i];
-    ASSERT(!wordResult->hasVerticalOffsets());
+    DCHECK(!wordResult->hasVerticalOffsets());
 
     for (const auto& run : wordResult->m_runs) {
-      ASSERT(run);
-      ASSERT(HB_DIRECTION_IS_HORIZONTAL(run->m_direction));
+      DCHECK(run);
+      DCHECK(HB_DIRECTION_IS_HORIZONTAL(run->m_direction));
 
-      for (const auto& glyphData : run->m_glyphData) {
-        ASSERT(!glyphData.offset.height());
+      advance = run->forEachGlyph(
+          advance,
+          [&](const HarfBuzzRunGlyphData& glyphData,
+              float totalAdvance) -> bool {
+            DCHECK(!glyphData.offset.height());
 
-        if (!isSkipInkException(*glyphBuffer, textRun,
-                                characterIndex + glyphData.characterIndex)) {
-          glyphBuffer->add(glyphData.glyph, run->m_fontData.get(),
-                           advance + glyphData.offset.width());
-        }
-
-        advance += glyphData.advance;
-      }
+            if (!isSkipInkException(
+                    *glyphBuffer, textRun,
+                    characterIndex + glyphData.characterIndex)) {
+              glyphBuffer->add(glyphData.glyph, run->m_fontData.get(),
+                               totalAdvance + glyphData.offset.width());
+            }
+            return true;
+          });
     }
     characterIndex += wordResult->m_numCharacters;
   }
 
   ASSERT(!glyphBuffer->hasVerticalOffsets());
 
   return advance;
 }
 
 float ShapeResultBuffer::fillGlyphBuffer(GlyphBuffer* glyphBuffer,
                                          const TextRun& textRun,
                                          unsigned from,
                                          unsigned to) const {
   // Fast path: full run with no vertical offsets
   if (!from && to == textRun.length() && !hasVerticalOffsets())
     return fillFastHorizontalGlyphBuffer(glyphBuffer, textRun);
 
   float advance = 0;
 
   if (textRun.rtl()) {
     unsigned wordOffset = textRun.length();
     for (unsigned j = 0; j < m_results.size(); j++) {
       unsigned resolvedIndex = m_results.size() - 1 - j;
       const RefPtr<const ShapeResult>& wordResult = m_results[resolvedIndex];
-      for (unsigned i = 0; i < wordResult->m_runs.size(); i++) {
-        advance += fillGlyphBufferForRun<TextDirection::kRtl>(
-            glyphBuffer, wordResult->m_runs[i].get(), textRun, advance, from,
-            to, wordOffset - wordResult->numCharacters());
-      }
       wordOffset -= wordResult->numCharacters();
+      advance = fillGlyphBufferForResult(glyphBuffer, *wordResult, textRun,
+                                         advance, from, to, wordOffset);
     }
   } else {
     unsigned wordOffset = 0;
-    for (unsigned j = 0; j < m_results.size(); j++) {
-      const RefPtr<const ShapeResult>& wordResult = m_results[j];
-      for (unsigned i = 0; i < wordResult->m_runs.size(); i++) {
-        advance += fillGlyphBufferForRun<TextDirection::kLtr>(
-            glyphBuffer, wordResult->m_runs[i].get(), textRun, advance, from,
-            to, wordOffset);
-      }
+    for (const auto& wordResult : m_results) {
+      advance = fillGlyphBufferForResult(glyphBuffer, *wordResult, textRun,
+                                         advance, from, to, wordOffset);
       wordOffset += wordResult->numCharacters();
     }
   }
 
   return advance;
 }
 
 float ShapeResultBuffer::fillGlyphBufferForTextEmphasis(
     GlyphBuffer* glyphBuffer,
     const TextRun& textRun,
@@ skipping 200 matching lines @@
       totalOffset += offsetForWord;
       if (targetX >= 0 && targetX <= wordResult->width())
         return totalOffset;
       targetX -= wordResult->width();
     }
   }
   return totalOffset;
 }
 
 }  // namespace blink