Do not skip ink for ideographic scripts

third_party/WebKit/Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (c) 2007, 2008, 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 239 matching lines @@
   STACK_ALLOCATED()
  public:
   GlyphBufferBloberizer(const GlyphBuffer& buffer,
                         const Font* font,
                         float deviceScaleFactor)
       : m_buffer(buffer),
         m_font(font),
         m_deviceScaleFactor(deviceScaleFactor),
         m_hasVerticalOffsets(buffer.hasVerticalOffsets()),
         m_index(0),
+        m_endIndex(m_buffer.size()),
         m_blobCount(0),
         m_rotation(buffer.isEmpty() ? NoRotation : computeBlobRotation(
-                                                       buffer.fontDataAt(0))) {}
+                                                       buffer.fontDataAt(0))),
+        m_skipGlyphs(nullptr) {}
 
-  bool done() const { return m_index >= m_buffer.size(); }
+  bool done() const { return m_index >= m_endIndex; }
   unsigned blobCount() const { return m_blobCount; }
 
   std::pair<sk_sp<SkTextBlob>, BlobRotation> next() {
     ASSERT(!done());
     const BlobRotation currentRotation = m_rotation;
 
-    while (m_index < m_buffer.size()) {
+    while (m_index < m_endIndex) {
+      if (m_skipGlyphs) {
+        while (m_index < m_endIndex && (*m_skipGlyphs)[m_index])
+          m_index++;
+      }
+
       const SimpleFontData* fontData = m_buffer.fontDataAt(m_index);
       ASSERT(fontData);
 
       const BlobRotation newRotation = computeBlobRotation(fontData);
       if (newRotation != m_rotation) {
         // We're switching to an orientation which requires a different rotation
         //   => emit the pending blob (and start a new one with the new
         //      rotation).
         m_rotation = newRotation;
         break;
       }
 
       const unsigned start = m_index++;
-      while (m_index < m_buffer.size() &&
-             m_buffer.fontDataAt(m_index) == fontData)
+      while (m_index < m_endIndex && m_buffer.fontDataAt(m_index) == fontData &&
+             !(m_skipGlyphs && (*m_skipGlyphs)[m_index]))
         m_index++;
 
       appendRun(start, m_index - start, fontData);
     }
 
     m_blobCount++;
     return std::make_pair(m_builder.make(), currentRotation);
   }
 
+  void setSkipGlyphs(const Vector<bool>* skipGlyphs) {
+    m_skipGlyphs = skipGlyphs;
+    m_endIndex = m_buffer.size();
+    if (m_skipGlyphs) {
+      while (m_endIndex > 0 && (*m_skipGlyphs)[m_endIndex - 1])
+        m_endIndex--;
+    }
+  }
+
  private:
   static BlobRotation computeBlobRotation(const SimpleFontData* font) {
     // For vertical upright text we need to compensate the inherited 90deg CW
     // rotation (using a 90deg CCW rotation).
     return (font->platformData().isVerticalAnyUpright() && font->verticalData())
                ? CCWRotation
                : NoRotation;
   }
 
   void appendRun(unsigned start,
@@ skipping 30 matching lines @@
     }
   }
 
   const GlyphBuffer& m_buffer;
   const Font* m_font;
   const float m_deviceScaleFactor;
   const bool m_hasVerticalOffsets;
 
   SkTextBlobBuilder m_builder;
   unsigned m_index;
+  unsigned m_endIndex;
   unsigned m_blobCount;
   BlobRotation m_rotation;
+  const Vector<bool>* m_skipGlyphs;
 };
 
 }  // anonymous namespace
 
 void Font::drawGlyphBuffer(SkCanvas* canvas,
                            const SkPaint& paint,
                            const TextRunPaintInfo& runInfo,
                            const GlyphBuffer& glyphBuffer,
                            const FloatPoint& point,
                            float deviceScaleFactor) const {
@@ skipping 21 matching lines @@
   //   2) the glyph buffer is encoded as a single blob, and
   //   3) the blob is not upright/rotated
   if (runInfo.cachedTextBlob && bloberizer.blobCount() == 1 &&
       blob.second == NoRotation) {
     ASSERT(!*runInfo.cachedTextBlob);
     *runInfo.cachedTextBlob = std::move(blob.first);
     ASSERT(*runInfo.cachedTextBlob);
   }
 }
 
+static std::unique_ptr<Vector<bool>> glyphsToSkipIntercepts(
+    const TextRun& run,
+    const GlyphBuffer& glyphBuffer) {
+  // Skipping ink leads to undesirable renderings for some scripts. Determine
+  // glyphs not to skip ink on a character-by-character basis.
+  DCHECK(!run.is8Bit());
+  std::unique_ptr<Vector<bool>> skipIndexes =
+      WTF::makeUnique<Vector<bool>>(glyphBuffer.size());
+  bool hasAnySkip = false;
+  for (unsigned index = 0; index < glyphBuffer.size(); index++) {
+    unsigned characterIndex = glyphBuffer.characterIndex(index);
+    UChar32 baseCharacter = run.codepointAt(characterIndex);

[drott, 2017/01/02 15:07:45]

Can we reuse Character::isCJKIdeographOrSymbol for this instead?

+    UBlockCode blockCode = ublock_getCode(baseCharacter);
+    switch (blockCode) {
+      case UBLOCK_BOPOMOFO:
+      case UBLOCK_BOPOMOFO_EXTENDED:
+      case UBLOCK_CJK_COMPATIBILITY:
+      case UBLOCK_CJK_COMPATIBILITY_FORMS:
+      case UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS:
+      case UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT:
+      case UBLOCK_CJK_RADICALS_SUPPLEMENT:
+      case UBLOCK_CJK_STROKES:
+      case UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION:
+      case UBLOCK_CJK_UNIFIED_IDEOGRAPHS:
+      case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A:
+      case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B:
+      case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C:
+      case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D:
+      case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E:
+      case UBLOCK_ENCLOSED_CJK_LETTERS_AND_MONTHS:
+      case UBLOCK_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT:
+      case UBLOCK_HANGUL_COMPATIBILITY_JAMO:
+      case UBLOCK_HANGUL_JAMO:
+      case UBLOCK_HANGUL_JAMO_EXTENDED_A:
+      case UBLOCK_HANGUL_JAMO_EXTENDED_B:
+      case UBLOCK_HANGUL_SYLLABLES:
+      case UBLOCK_HIRAGANA:
+      case UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS:
+      case UBLOCK_IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION:
+      case UBLOCK_KATAKANA:
+      case UBLOCK_LINEAR_B_IDEOGRAMS:
+      case UBLOCK_TANGUT:
+      case UBLOCK_TANGUT_COMPONENTS:
+        (*skipIndexes)[index] = true;
+        hasAnySkip = true;
+        break;
+      default:
+        break;
+    }
+  }
+  if (!hasAnySkip)
+    return nullptr;
+  return skipIndexes;
+}
+
 static int getInterceptsFromBloberizer(const GlyphBuffer& glyphBuffer,
                                        const Font* font,
                                        const SkPaint& paint,
                                        float deviceScaleFactor,
                                        const std::tuple<float, float>& bounds,
+                                       const Vector<bool>* skipGlyphs,
                                        SkScalar* interceptsBuffer) {
   SkScalar boundsArray[2] = {std::get<0>(bounds), std::get<1>(bounds)};
   GlyphBufferBloberizer bloberizer(glyphBuffer, font, deviceScaleFactor);
+  bloberizer.setSkipGlyphs(skipGlyphs);
   std::pair<sk_sp<SkTextBlob>, BlobRotation> blob;
 
   int numIntervals = 0;
   while (!bloberizer.done()) {
     blob = bloberizer.next();
     DCHECK(blob.first);
 
     // GlyphBufferBloberizer splits for a new blob rotation, but does not split
     // for a change in font. A TextBlob can contain runs with differing fonts
     // and the getTextBlobIntercepts method handles multiple fonts for us. For
@@ skipping 25 matching lines @@
     if (!numIntervals)
       return;
     DCHECK_EQ(numIntervals % 2, 0);
     intercepts.resize(numIntervals / 2);
     paint.getTextBlobIntercepts(runInfo.cachedTextBlob->get(), boundsArray,
                                 reinterpret_cast<SkScalar*>(intercepts.data()));
     return;
   }
 
   GlyphBuffer glyphBuffer;
-  buildGlyphBuffer(runInfo, glyphBuffer);
+  std::unique_ptr<Vector<bool>> skipGlyphs;
+  if (runInfo.run.is8Bit()) {
+    buildGlyphBuffer(runInfo, glyphBuffer);
+  } else {
+    glyphBuffer.saveCharacterIndexes();
+    buildGlyphBuffer(runInfo, glyphBuffer);
+    skipGlyphs = glyphsToSkipIntercepts(runInfo.run, glyphBuffer);
+  }
 
   // Get the number of intervals, without copying the actual values by
   // specifying nullptr for the buffer, following the Skia allocation model for
   // retrieving text intercepts.
-  int numIntervals = getInterceptsFromBloberizer(
-      glyphBuffer, this, paint, deviceScaleFactor, bounds, nullptr);
+  int numIntervals =
+      getInterceptsFromBloberizer(glyphBuffer, this, paint, deviceScaleFactor,
+                                  bounds, skipGlyphs.get(), nullptr);
   if (!numIntervals)
     return;
   DCHECK_EQ(numIntervals % 2, 0);
   intercepts.resize(numIntervals / 2);
 
   getInterceptsFromBloberizer(glyphBuffer, this, paint, deviceScaleFactor,
-                              bounds,
+                              bounds, skipGlyphs.get(),
                               reinterpret_cast<SkScalar*>(intercepts.data()));
 }
 
 static inline FloatRect pixelSnappedSelectionRect(FloatRect rect) {
   // Using roundf() rather than ceilf() for the right edge as a compromise to
   // ensure correct caret positioning.
   float roundedX = roundf(rect.x());
   return FloatRect(roundedX, rect.y(), roundf(rect.maxX() - roundedX),
                    rect.height());
 }
@@ skipping 154 matching lines @@
 
 bool Font::loadingCustomFonts() const {
   return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const {
   return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 }  // namespace blink