Do not skip ink for ideographic scripts

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"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/text/Character.h"
 #include "platform/text/TextBreakIterator.h"
 #include "platform/text/TextDirection.h"
 
 namespace blink {
 
 namespace {
 
 inline void addGlyphToBuffer(GlyphBuffer* glyphBuffer,
                              float advance,
                              hb_direction_t direction,
                              const SimpleFontData* fontData,
-                             const HarfBuzzRunGlyphData& glyphData) {
+                             const HarfBuzzRunGlyphData& glyphData,
+                             unsigned characterIndex) {
   FloatPoint startOffset = HB_DIRECTION_IS_HORIZONTAL(direction)
                                ? FloatPoint(advance, 0)
                                : FloatPoint(0, advance);
-  glyphBuffer->add(glyphData.glyph, fontData, startOffset + glyphData.offset);
+  glyphBuffer->add(glyphData.glyph, fontData, startOffset + glyphData.offset,
+                   characterIndex);
 }
 
 inline void addEmphasisMark(GlyphBuffer* buffer,
                             const GlyphData* emphasisData,
                             FloatPoint glyphCenter,
                             float midGlyphOffset) {
   ASSERT(buffer);
   ASSERT(emphasisData);
 
   const SimpleFontData* emphasisFontData = emphasisData->fontData;
@@ skipping 52 matching lines @@
     uint16_t currentCharacterIndex =
         run->m_startIndex + glyphData.characterIndex + runOffset;
     if ((direction == TextDirection::Rtl && currentCharacterIndex >= to) ||
         (direction == TextDirection::Ltr && currentCharacterIndex < from)) {
       advanceSoFar += glyphData.advance;
     } else if ((direction == TextDirection::Rtl &&
                 currentCharacterIndex >= from) ||
                (direction == TextDirection::Ltr &&
                 currentCharacterIndex < to)) {
       addGlyphToBuffer(glyphBuffer, advanceSoFar, run->m_direction,
-                       run->m_fontData.get(), glyphData);
+                       run->m_fontData.get(), glyphData, currentCharacterIndex);
       advanceSoFar += glyphData.advance;
     }
   }
   return advanceSoFar - initialAdvance;
 }
 
 float ShapeResultBuffer::fillGlyphBufferForTextEmphasisRun(
     GlyphBuffer* glyphBuffer,
     const ShapeResult::RunInfo* run,
     const TextRun& textRun,
@@ skipping 83 matching lines @@
   return advanceSoFar - initialAdvance;
 }
 
 float ShapeResultBuffer::fillFastHorizontalGlyphBuffer(
     GlyphBuffer* glyphBuffer,
     TextDirection dir) const {
   ASSERT(!hasVerticalOffsets());
 
   float advance = 0;
 
+  unsigned characterIndex = 0;
   for (unsigned i = 0; i < m_results.size(); ++i) {
     const auto& wordResult = isLeftToRightDirection(dir)
                                  ? m_results[i]
                                  : m_results[m_results.size() - 1 - i];
     ASSERT(!wordResult->hasVerticalOffsets());
 
     for (const auto& run : wordResult->m_runs) {
       ASSERT(run);
       ASSERT(HB_DIRECTION_IS_HORIZONTAL(run->m_direction));
 
       for (const auto& glyphData : run->m_glyphData) {
         ASSERT(!glyphData.offset.height());
 
         glyphBuffer->add(glyphData.glyph, run->m_fontData.get(),
-                         advance + glyphData.offset.width());
+                         advance + glyphData.offset.width(),
+                         characterIndex + glyphData.characterIndex);
         advance += glyphData.advance;
       }
     }
+    characterIndex += wordResult->m_numCharacters;
   }
 
   ASSERT(!glyphBuffer->hasVerticalOffsets());
 
   return advance;
 }
 
 float ShapeResultBuffer::fillGlyphBuffer(GlyphBuffer* glyphBuffer,
                                          const TextRun& textRun,
                                          unsigned from,
@@ skipping 214 matching lines @@
       totalOffset += offsetForWord;
       if (targetX >= 0 && targetX <= wordResult->width())
         return totalOffset;
       targetX -= wordResult->width();
     }
   }
   return totalOffset;
 }
 
 }  // namespace blink