Remove GlyphBuffer

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/ShapeResultBloberizer.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/text/Character.h"
 #include "platform/text/TextBreakIterator.h"
 #include "platform/text/TextDirection.h"
 
 namespace blink {
 
 namespace {
 
-inline bool isSkipInkException(const GlyphBuffer& glyphBuffer,
+inline bool isSkipInkException(const ShapeResultBloberizer& bloberizer,
                                const TextRun& run,
                                unsigned characterIndex) {
   // We want to skip descenders in general, but it is undesirable renderings for
   // CJK characters.
-  return glyphBuffer.type() == GlyphBuffer::Type::TextIntercepts &&
+  return bloberizer.type() == ShapeResultBloberizer::Type::TextIntercepts &&
          !run.is8Bit() &&
          Character::isCJKIdeographOrSymbol(run.codepointAt(characterIndex));
 }
 
-inline void addGlyphToBuffer(GlyphBuffer* glyphBuffer,
-                             float advance,
-                             hb_direction_t direction,
-                             const SimpleFontData* fontData,
-                             const HarfBuzzRunGlyphData& glyphData,
-                             const TextRun& run,
-                             unsigned characterIndex) {
+inline void addGlyphToBloberizer(ShapeResultBloberizer& bloberizer,
+                                 float advance,
+                                 hb_direction_t direction,
+                                 const SimpleFontData* fontData,
+                                 const HarfBuzzRunGlyphData& glyphData,
+                                 const TextRun& run,
+                                 unsigned characterIndex) {
   FloatPoint startOffset = HB_DIRECTION_IS_HORIZONTAL(direction)
                                ? FloatPoint(advance, 0)
                                : FloatPoint(0, advance);
-  if (!isSkipInkException(*glyphBuffer, run, characterIndex)) {
-    glyphBuffer->add(glyphData.glyph, fontData, startOffset + glyphData.offset);
-  }
+  if (!isSkipInkException(bloberizer, run, characterIndex))
+    bloberizer.add(glyphData.glyph, fontData, startOffset + glyphData.offset);
 }
 
-inline void addEmphasisMark(GlyphBuffer* buffer,
-                            const GlyphData* emphasisData,
+inline void addEmphasisMark(ShapeResultBloberizer& bloberizer,
+                            const GlyphData& emphasisData,
                             FloatPoint glyphCenter,
                             float midGlyphOffset) {
-  ASSERT(buffer);
-  ASSERT(emphasisData);
-
-  const SimpleFontData* emphasisFontData = emphasisData->fontData;
-  ASSERT(emphasisFontData);
+  const SimpleFontData* emphasisFontData = emphasisData.fontData;
+  DCHECK(emphasisFontData);
 
   bool isVertical = emphasisFontData->platformData().isVerticalAnyUpright() &&
                     emphasisFontData->verticalData();
 
   if (!isVertical) {
-    buffer->add(emphasisData->glyph, emphasisFontData,
-                midGlyphOffset - glyphCenter.x());
+    bloberizer.add(emphasisData.glyph, emphasisFontData,
+                   midGlyphOffset - glyphCenter.x());
   } else {
-    buffer->add(emphasisData->glyph, emphasisFontData,
-                FloatPoint(-glyphCenter.x(), midGlyphOffset - glyphCenter.y()));
+    bloberizer.add(
+        emphasisData.glyph, emphasisFontData,
+        FloatPoint(-glyphCenter.x(), midGlyphOffset - glyphCenter.y()));
   }
 }
 
 inline unsigned countGraphemesInCluster(const UChar* str,
                                         unsigned strLength,
                                         uint16_t startIndex,
                                         uint16_t endIndex) {
   if (startIndex > endIndex) {
     uint16_t tempIndex = startIndex;
     startIndex = endIndex;
     endIndex = tempIndex;
   }
   uint16_t length = endIndex - startIndex;
   ASSERT(static_cast<unsigned>(startIndex + length) <= strLength);
   TextBreakIterator* cursorPosIterator =
       cursorMovementIterator(&str[startIndex], length);
 
   int cursorPos = cursorPosIterator->current();
   int numGraphemes = -1;
   while (0 <= cursorPos) {
     cursorPos = cursorPosIterator->next();
     numGraphemes++;
   }
   return std::max(0, numGraphemes);
 }
 
 }  // anonymous namespace
 
-float ShapeResultBuffer::fillGlyphBufferForResult(GlyphBuffer* glyphBuffer,
-                                                  const ShapeResult& result,
-                                                  const TextRun& textRun,
-                                                  float initialAdvance,
-                                                  unsigned from,
-                                                  unsigned to,
-                                                  unsigned runOffset) {
+float ShapeResultBuffer::fillGlyphsForResult(ShapeResultBloberizer& bloberizer,
+                                             const ShapeResult& result,
+                                             const TextRunPaintInfo& runInfo,
+                                             float initialAdvance,
+                                             unsigned runOffset) {
   auto totalAdvance = initialAdvance;
 
   for (const auto& run : result.m_runs) {
     totalAdvance = run->forEachGlyphInRange(
-        totalAdvance, from, to, runOffset,
+        totalAdvance, runInfo.from, runInfo.to, runOffset,
         [&](const HarfBuzzRunGlyphData& glyphData, float totalAdvance,
             uint16_t characterIndex) -> bool {
 
-          addGlyphToBuffer(glyphBuffer, totalAdvance, run->m_direction,
-                           run->m_fontData.get(), glyphData, textRun,
-                           characterIndex);
+          addGlyphToBloberizer(bloberizer, totalAdvance, run->m_direction,
+                               run->m_fontData.get(), glyphData, runInfo.run,
+                               characterIndex);
           return true;
         });
   }
 
   return totalAdvance;
 }
 
-float ShapeResultBuffer::fillGlyphBufferForTextEmphasisRun(
-    GlyphBuffer* glyphBuffer,
+float ShapeResultBuffer::fillTextEmphasisGlyphsForRun(
+    ShapeResultBloberizer& bloberizer,
     const ShapeResult::RunInfo* run,
-    const TextRun& textRun,
-    const GlyphData* emphasisData,
+    const TextRunPaintInfo& runInfo,
+    const GlyphData& emphasisData,
     float initialAdvance,
-    unsigned from,
-    unsigned to,
     unsigned runOffset) {
   if (!run)
     return 0;
 
   unsigned graphemesInCluster = 1;
   float clusterAdvance = 0;
 
   FloatPoint glyphCenter =
-      emphasisData->fontData->boundsForGlyph(emphasisData->glyph).center();
+      emphasisData.fontData->boundsForGlyph(emphasisData.glyph).center();
+
+  const auto& textRun = runInfo.run;
+  const auto from = runInfo.from;
+  const auto to = runInfo.to;
 
   TextDirection direction = textRun.direction();
 
   // A "cluster" in this context means a cluster as it is used by HarfBuzz:
   // The minimal group of characters and corresponding glyphs, that cannot be
   // broken down further from a text shaping point of view.  A cluster can
   // contain multiple glyphs and grapheme clusters, with mutually overlapping
   // boundaries. Below we count grapheme clusters per HarfBuzz clusters, then
   // linearly split the sum of corresponding glyph advances by the number of
   // grapheme clusters in order to find positions for emphasis mark drawing.
@@ skipping 18 matching lines @@
       advanceSoFar += glyphData.advance;
       direction == TextDirection::kRtl ? --clusterStart : ++clusterStart;
       continue;
     }
 
     clusterAdvance += glyphData.advance;
 
     if (textRun.is8Bit()) {
       float glyphAdvanceX = glyphData.advance;
       if (Character::canReceiveTextEmphasis(textRun[currentCharacterIndex])) {
-        addEmphasisMark(glyphBuffer, emphasisData, glyphCenter,
+        addEmphasisMark(bloberizer, emphasisData, glyphCenter,
                         advanceSoFar + glyphAdvanceX / 2);
       }
       advanceSoFar += glyphAdvanceX;
     } else if (isClusterEnd) {
       uint16_t clusterEnd;
       if (direction == TextDirection::kRtl)
         clusterEnd = currentCharacterIndex;
       else
         clusterEnd = static_cast<uint16_t>(
             isRunEnd ? run->m_startIndex + run->m_numCharacters + runOffset
                      : run->glyphToCharacterIndex(i + 1) + runOffset);
 
       graphemesInCluster = countGraphemesInCluster(textRun.characters16(),
                                                    textRun.charactersLength(),
                                                    clusterStart, clusterEnd);
       if (!graphemesInCluster || !clusterAdvance)
         continue;
 
       float glyphAdvanceX = clusterAdvance / graphemesInCluster;
       for (unsigned j = 0; j < graphemesInCluster; ++j) {
         // Do not put emphasis marks on space, separator, and control
         // characters.
         if (Character::canReceiveTextEmphasis(textRun[currentCharacterIndex]))
-          addEmphasisMark(glyphBuffer, emphasisData, glyphCenter,
+          addEmphasisMark(bloberizer, emphasisData, glyphCenter,
                           advanceSoFar + glyphAdvanceX / 2);
         advanceSoFar += glyphAdvanceX;
       }
       clusterStart = clusterEnd;
       clusterAdvance = 0;
     }
   }
   return advanceSoFar - initialAdvance;
 }
 
-float ShapeResultBuffer::fillFastHorizontalGlyphBuffer(
-    GlyphBuffer* glyphBuffer,
-    const TextRun& textRun) const {
+float ShapeResultBuffer::fillFastHorizontalGlyphs(
+    const TextRun& textRun,
+    ShapeResultBloberizer& bloberizer) const {
   DCHECK(!hasVerticalOffsets());
-  DCHECK_NE(glyphBuffer->type(), GlyphBuffer::Type::TextIntercepts);
+  DCHECK_NE(bloberizer.type(), ShapeResultBloberizer::Type::TextIntercepts);
 
   float advance = 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];
     DCHECK(!wordResult->hasVerticalOffsets());
 
     for (const auto& run : wordResult->m_runs) {
       DCHECK(run);
       DCHECK(HB_DIRECTION_IS_HORIZONTAL(run->m_direction));
 
       advance = run->forEachGlyph(
           advance,
           [&](const HarfBuzzRunGlyphData& glyphData,
               float totalAdvance) -> bool {
             DCHECK(!glyphData.offset.height());
-
-            glyphBuffer->add(glyphData.glyph, run->m_fontData.get(),
-                             totalAdvance + glyphData.offset.width());
+            bloberizer.add(glyphData.glyph, run->m_fontData.get(),
+                           totalAdvance + glyphData.offset.width());
             return true;
           });
     }
   }
 
-  ASSERT(!glyphBuffer->hasVerticalOffsets());
-
   return advance;
 }
 
-float ShapeResultBuffer::fillGlyphBuffer(GlyphBuffer* glyphBuffer,
-                                         const TextRun& textRun,
-                                         unsigned from,
-                                         unsigned to) const {
+float ShapeResultBuffer::fillGlyphs(const TextRunPaintInfo& runInfo,
+                                    ShapeResultBloberizer& bloberizer) const {
   // Fast path: full run with no vertical offsets, no text intercepts.
-  if (!from && to == textRun.length() && !hasVerticalOffsets() &&
-      glyphBuffer->type() != GlyphBuffer::Type::TextIntercepts)
-    return fillFastHorizontalGlyphBuffer(glyphBuffer, textRun);
+  if (!runInfo.from && runInfo.to == runInfo.run.length() &&
+      !hasVerticalOffsets() &&
+      bloberizer.type() != ShapeResultBloberizer::Type::TextIntercepts) {
+    return fillFastHorizontalGlyphs(runInfo.run, bloberizer);
+  }
 
   float advance = 0;
 
-  if (textRun.rtl()) {
-    unsigned wordOffset = textRun.length();
+  if (runInfo.run.rtl()) {
+    unsigned wordOffset = runInfo.run.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];
       wordOffset -= wordResult->numCharacters();
-      advance = fillGlyphBufferForResult(glyphBuffer, *wordResult, textRun,
-                                         advance, from, to, wordOffset);
+      advance = fillGlyphsForResult(bloberizer, *wordResult, runInfo, advance,
+                                    wordOffset);
     }
   } else {
     unsigned wordOffset = 0;
     for (const auto& wordResult : m_results) {
-      advance = fillGlyphBufferForResult(glyphBuffer, *wordResult, textRun,
-                                         advance, from, to, wordOffset);
+      advance = fillGlyphsForResult(bloberizer, *wordResult, runInfo, advance,
+                                    wordOffset);
       wordOffset += wordResult->numCharacters();
     }
   }
 
   return advance;
 }
 
-float ShapeResultBuffer::fillGlyphBufferForTextEmphasis(
-    GlyphBuffer* glyphBuffer,
-    const TextRun& textRun,
-    const GlyphData* emphasisData,
-    unsigned from,
-    unsigned to) const {
+void ShapeResultBuffer::fillTextEmphasisGlyphs(
+    const TextRunPaintInfo& runInfo,
+    const GlyphData& emphasisData,
+    ShapeResultBloberizer& bloberizer) const {
   float advance = 0;
-  unsigned wordOffset = textRun.rtl() ? textRun.length() : 0;
+  unsigned wordOffset = runInfo.run.rtl() ? runInfo.run.length() : 0;
 
   for (unsigned j = 0; j < m_results.size(); j++) {
-    unsigned resolvedIndex = textRun.rtl() ? m_results.size() - 1 - j : j;
+    unsigned resolvedIndex = runInfo.run.rtl() ? m_results.size() - 1 - j : j;
     const RefPtr<const ShapeResult>& wordResult = m_results[resolvedIndex];
     for (unsigned i = 0; i < wordResult->m_runs.size(); i++) {
       unsigned resolvedOffset =
-          wordOffset - (textRun.rtl() ? wordResult->numCharacters() : 0);
-      advance += fillGlyphBufferForTextEmphasisRun(
-          glyphBuffer, wordResult->m_runs[i].get(), textRun, emphasisData,
-          advance, from, to, resolvedOffset);
+          wordOffset - (runInfo.run.rtl() ? wordResult->numCharacters() : 0);
+      advance += fillTextEmphasisGlyphsForRun(
+          bloberizer, wordResult->m_runs[i].get(), runInfo, emphasisData,
+          advance, resolvedOffset);
     }
-    wordOffset += wordResult->numCharacters() * (textRun.rtl() ? -1 : 1);
+    wordOffset += wordResult->numCharacters() * (runInfo.run.rtl() ? -1 : 1);
   }
-
-  return advance;
 }
 
 // TODO(eae): This is a bit of a hack to allow reuse of the implementation
 // for both ShapeResultBuffer and single ShapeResult use cases. Ideally the
 // logic should move into ShapeResult itself and then the ShapeResultBuffer
 // implementation may wrap that.
 CharacterRange ShapeResultBuffer::getCharacterRange(
     RefPtr<const ShapeResult> result,
     TextDirection direction,
     float totalWidth,
@@ skipping 200 matching lines @@
       return GlyphData(
           run->m_glyphData[0].glyph,
           run->m_fontData->emphasisMarkFontData(fontDescription).get());
     }
   }
 
   return GlyphData();
 }
 
 }  // namespace blink