Clarify naming for fast-path in setLogicalWidthForTextRun

third_party/WebKit/Source/core/layout/LayoutBlockFlowLine.cpp

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All right reserved.
  * Copyright (C) 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
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 429 matching lines @@
         hyphenWidth = layoutText->hyphenWidth(font, run->direction());
 
     float measuredWidth = 0;
     FloatRect glyphBounds;
 
     bool kerningIsEnabled = font.fontDescription().typesettingFeatures() & Kerning;
 
 #if OS(MACOSX)
     // FIXME: Having any font feature settings enabled can lead to selection gaps on
     // Chromium-mac. https://bugs.webkit.org/show_bug.cgi?id=113418
-    bool canUseSimpleFontCodePath = layoutText->canUseSimpleFontCodePath() && !font.fontDescription().featureSettings();
+    bool canUseCachedWordMeasurements = layoutText->canUseSimpleFontCodePath() && !font.fontDescription().featureSettings();

[drott, 2015/11/25 12:46:24]

I am trying to understand what this line actually means and what we should be
doing with it.

The canUseSimpleCodePath implementation means: either 8bit or not complex only
character ranges...

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

Is that really intended? Or can we not use the word cache in more situations?

 #else
-    bool canUseSimpleFontCodePath = layoutText->canUseSimpleFontCodePath();
+    bool canUseCachedWordMeasurements = layoutText->canUseSimpleFontCodePath();
 #endif
 
-    if (canUseSimpleFontCodePath) {
+    if (canUseCachedWordMeasurements) {
         int lastEndOffset = run->m_start;
         for (size_t i = 0, size = wordMeasurements.size(); i < size && lastEndOffset < run->m_stop; ++i) {
             const WordMeasurement& wordMeasurement = wordMeasurements[i];
             if (wordMeasurement.startOffset == wordMeasurement.endOffset)
                 continue;
             if (wordMeasurement.layoutText != layoutText || wordMeasurement.startOffset != lastEndOffset || wordMeasurement.endOffset > run->m_stop)
                 continue;
 
             lastEndOffset = wordMeasurement.endOffset;
             if (kerningIsEnabled && lastEndOffset == run->m_stop) {
                 int wordLength = lastEndOffset - wordMeasurement.startOffset;
                 measuredWidth += layoutText->width(wordMeasurement.startOffset, wordLength, xPos, run->direction(), lineInfo.isFirstLine());
                 if (i > 0 && wordLength == 1 && layoutText->characterAt(wordMeasurement.startOffset) == ' ')
                     measuredWidth += layoutText->style()->wordSpacing();
             } else {
                 FloatRect wordGlyphBounds = wordMeasurement.glyphBounds;
                 wordGlyphBounds.move(measuredWidth, 0);
                 glyphBounds.unite(wordGlyphBounds);
                 measuredWidth += wordMeasurement.width;
             }
             if (!wordMeasurement.fallbackFonts.isEmpty()) {
                 HashSet<const SimpleFontData*>::const_iterator end = wordMeasurement.fallbackFonts.end();
                 for (HashSet<const SimpleFontData*>::const_iterator it = wordMeasurement.fallbackFonts.begin(); it != end; ++it)
                     fallbackFonts.add(*it);
             }
         }
         if (lastEndOffset != run->m_stop) {
             // If we don't have enough cached data, we'll measure the run again.
-            canUseSimpleFontCodePath = false;
+            canUseCachedWordMeasurements = false;
             fallbackFonts.clear();
         }
     }
 
-    // Don't put this into 'else' part of the above 'if' because canUseSimpleFontCodePath may be modified in the 'if' block.
-    if (!canUseSimpleFontCodePath)
+    // Don't put this into 'else' part of the above 'if' because canUseCachedWordMeasurements may be modified in the 'if' block.
+    if (!canUseCachedWordMeasurements)
         measuredWidth = layoutText->width(run->m_start, run->m_stop - run->m_start, xPos, run->direction(), lineInfo.isFirstLine(), &fallbackFonts, &glyphBounds);
 
     // Negative word-spacing and/or letter-spacing may cause some glyphs to overflow the left boundary and result
     // negative measured width. Reset measured width to 0 and adjust glyph bounds accordingly to cover the overflow.
     if (measuredWidth < 0) {
         if (measuredWidth < glyphBounds.x()) {
             glyphBounds.expand(glyphBounds.x() - measuredWidth, 0);
             glyphBounds.setX(measuredWidth);
         }
         measuredWidth = 0;
@@ skipping 1558 matching lines @@
     LayoutUnit logicalLeft = logicalLeftOffsetForLine(logicalHeight(), false);
     LayoutUnit availableLogicalWidth = logicalRightOffsetForLine(logicalHeight(), false) - logicalLeft;
     updateLogicalWidthForAlignment(textAlign, 0, 0, logicalLeft, totalLogicalWidth, availableLogicalWidth, 0);
 
     if (!style()->isLeftToRightDirection())
         return logicalWidth() - logicalLeft;
     return logicalLeft;
 }
 
 }