Support includePartialGlyphs=false in Font::offsetForPositionForComplexText

third_party/WebKit/Source/platform/fonts/shaping/ShapeResult.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 71 matching lines @@
             for (; m_glyphData[glyphIndex].characterIndex == offset; --glyphIndex) {
                 position -= m_glyphData[glyphIndex].advance;
                 if (!glyphIndex)
                     break;
             }
         }
     }
     return position;
 }
 
-int ShapeResult::RunInfo::characterIndexForXPosition(float targetX) const
+int ShapeResult::RunInfo::characterIndexForXPosition(float targetX, bool includePartialGlyphs) const
 {
-    ASSERT(targetX <= m_width);
+    DCHECK(targetX >= 0 && targetX <= m_width);
     const unsigned numGlyphs = m_glyphData.size();
     float currentX = 0;
-    float currentAdvance = m_glyphData[0].advance;
+    float currentAdvance = 0;
     unsigned glyphIndex = 0;
+    unsigned prevCharacterIndex = m_numCharacters; // used only when rtl()
 
-    // Sum up advances that belong to the first character.
-    while (glyphIndex < numGlyphs - 1 && m_glyphData[glyphIndex].characterIndex == m_glyphData[glyphIndex + 1].characterIndex)
-        currentAdvance += m_glyphData[++glyphIndex].advance;
-    currentAdvance = currentAdvance / 2.0;
-    if (targetX <= currentAdvance)
-        return rtl() ? m_numCharacters : 0;
-
-    currentX = currentAdvance;
-    ++glyphIndex;
     while (glyphIndex < numGlyphs) {
-        unsigned prevCharacterIndex = m_glyphData[glyphIndex - 1].characterIndex;
         float prevAdvance = currentAdvance;
+        unsigned currentCharacterIndex = m_glyphData[glyphIndex].characterIndex;
         currentAdvance = m_glyphData[glyphIndex].advance;
-        while (glyphIndex < numGlyphs - 1 && m_glyphData[glyphIndex].characterIndex == m_glyphData[glyphIndex + 1].characterIndex)
+        while (glyphIndex < numGlyphs - 1 && currentCharacterIndex == m_glyphData[glyphIndex + 1].characterIndex)
             currentAdvance += m_glyphData[++glyphIndex].advance;
-        currentAdvance = currentAdvance / 2.0;
-        float nextX = currentX + prevAdvance + currentAdvance;
+        float nextX;
+        if (includePartialGlyphs) {

[eae, 2016/05/12 16:12:45]

Could you add a comment here explaining the logic please? Especially the / 2.0
part.

[kojii, 2016/05/12 16:35:58]

Done, thank you!

+            currentAdvance = currentAdvance / 2.0;
+            nextX = currentX + prevAdvance + currentAdvance;
+        } else {
+            nextX = currentX + currentAdvance;
+        }
         if (currentX <= targetX && targetX <= nextX)
-            return rtl() ? prevCharacterIndex : m_glyphData[glyphIndex].characterIndex;
+            return includePartialGlyphs && rtl() ? prevCharacterIndex : currentCharacterIndex;
         currentX = nextX;
+        prevCharacterIndex = currentCharacterIndex;
         ++glyphIndex;
     }
 
     return rtl() ? 0 : m_numCharacters;
 }
 
 void ShapeResult::RunInfo::setGlyphAndPositions(unsigned index,
     uint16_t glyphId, float advance, float offsetX, float offsetY)
 {
     HarfBuzzRunGlyphData& data = m_glyphData[index];
@@ skipping 32 matching lines @@
 
 size_t ShapeResult::byteSize() const
 {
     size_t selfByteSize = sizeof(this);
     for (unsigned i = 0; i < m_runs.size(); ++i) {
         selfByteSize += m_runs[i]->byteSize();
     }
     return selfByteSize;
 }
 
-int ShapeResult::offsetForPosition(float targetX) const
+int ShapeResult::offsetForPosition(float targetX, bool includePartialGlyphs) const
 {
     int charactersSoFar = 0;
     float currentX = 0;
 
     if (m_direction == RTL) {
         charactersSoFar = m_numCharacters;
         for (unsigned i = 0; i < m_runs.size(); ++i) {
             if (!m_runs[i])
                 continue;
             charactersSoFar -= m_runs[i]->m_numCharacters;
             float nextX = currentX + m_runs[i]->m_width;
             float offsetForRun = targetX - currentX;
             if (offsetForRun >= 0 && offsetForRun <= m_runs[i]->m_width) {
                 // The x value in question is within this script run.
-                const unsigned index = m_runs[i]->characterIndexForXPosition(offsetForRun);
+                const unsigned index = m_runs[i]->characterIndexForXPosition(offsetForRun, includePartialGlyphs);
                 return charactersSoFar + index;
             }
             currentX = nextX;
         }
     } else {
         for (unsigned i = 0; i < m_runs.size(); ++i) {
             if (!m_runs[i])
                 continue;
             float nextX = currentX + m_runs[i]->m_width;
             float offsetForRun = targetX - currentX;
             if (offsetForRun >= 0 && offsetForRun <= m_runs[i]->m_width) {
-                const unsigned index = m_runs[i]->characterIndexForXPosition(offsetForRun);
+                const unsigned index = m_runs[i]->characterIndexForXPosition(offsetForRun, includePartialGlyphs);
                 return charactersSoFar + index;
             }
             charactersSoFar += m_runs[i]->m_numCharacters;
             currentX = nextX;
         }
     }
 
     return charactersSoFar;
 }
 
@@ skipping 137 matching lines @@
                 break;
             }
         }
     }
     // If we didn't find an existing slot to place it, append.
     if (run)
         m_runs.append(run.release());
 }
 
 } // namespace blink