Rename m_run to m_textRun in Shaper

Source/platform/fonts/shaping/HarfBuzzShaper.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 360 matching lines @@
 }
 
 HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run, const GlyphData* emphasisData,
     HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* bounds)
     : Shaper(font, run, emphasisData, fallbackFonts, bounds)
     , m_normalizedBufferLength(0)
     , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
     , m_letterSpacing(font->fontDescription().letterSpacing())
     , m_expansionOpportunityCount(0)
     , m_fromIndex(0)
-    , m_toIndex(m_run.length())
+    , m_toIndex(m_textRun.length())
     , m_totalWidth(0)
 {
-    m_normalizedBuffer = adoptArrayPtr(new UChar[m_run.length() + 1]);
-    normalizeCharacters(m_run, m_run.length(), m_normalizedBuffer.get(), &m_normalizedBufferLength);
-    setExpansion(m_run.expansion());
+    m_normalizedBuffer = adoptArrayPtr(new UChar[m_textRun.length() + 1]);
+    normalizeCharacters(m_textRun, m_textRun.length(), m_normalizedBuffer.get(), &m_normalizedBufferLength);
+    setExpansion(m_textRun.expansion());
     setFontFeatures();
 }
 
 float HarfBuzzShaper::nextExpansionPerOpportunity()
 {
     if (!m_expansionOpportunityCount) {
         ASSERT_NOT_REACHED(); // failures indicate that the logic in HarfBuzzShaper does not match to the one in expansionOpportunityCount()
         return 0;
     }
     if (!--m_expansionOpportunityCount) {
         float remaining = m_expansion;
         m_expansion = 0;
         return remaining;
     }
     m_expansion -= m_expansionPerOpportunity;
     return m_expansionPerOpportunity;
 }
 
 // setPadding sets a number of pixels to be distributed across the TextRun.
 // WebKit uses this to justify text.
 void HarfBuzzShaper::setExpansion(float padding)
 {
     m_expansion = padding;
     if (!m_expansion)
         return;
 
     // If we have padding to distribute, then we try to give an equal
     // amount to each expansion opportunity.
     bool isAfterExpansion = m_isAfterExpansion;
-    m_expansionOpportunityCount = Character::expansionOpportunityCount(m_normalizedBuffer.get(), m_normalizedBufferLength, m_run.direction(), isAfterExpansion, m_run.textJustify());
-    if (isAfterExpansion && !m_run.allowsTrailingExpansion()) {
+    m_expansionOpportunityCount = Character::expansionOpportunityCount(m_normalizedBuffer.get(), m_normalizedBufferLength, m_textRun.direction(), isAfterExpansion, m_textRun.textJustify());
+    if (isAfterExpansion && !m_textRun.allowsTrailingExpansion()) {
         ASSERT(m_expansionOpportunityCount > 0);
         --m_expansionOpportunityCount;
     }
 
     if (m_expansionOpportunityCount)
         m_expansionPerOpportunity = m_expansion / m_expansionOpportunityCount;
     else
         m_expansionPerOpportunity = 0;
 }
 
 
 void HarfBuzzShaper::setDrawRange(int from, int to)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(from >= 0);
-    ASSERT_WITH_SECURITY_IMPLICATION(to <= m_run.length());
+    ASSERT_WITH_SECURITY_IMPLICATION(to <= m_textRun.length());
     m_fromIndex = from;
     m_toIndex = to;
 }
 
 void HarfBuzzShaper::setFontFeatures()
 {
     const FontDescription& description = m_font->fontDescription();
 
     static hb_feature_t noKern = { HB_TAG('k', 'e', 'r', 'n'), 0, 0, static_cast<unsigned>(-1) };
     static hb_feature_t noVkrn = { HB_TAG('v', 'k', 'r', 'n'), 0, 0, static_cast<unsigned>(-1) };
@@ skipping 249 matching lines @@
 }
 
 // For ideographic (CJK) documents, 90-95% of calls from width() are one character length
 // because most characters have break opportunities both before and after.
 bool HarfBuzzShaper::createHarfBuzzRunsForSingleCharacter()
 {
     ASSERT(m_normalizedBufferLength == 1);
     UChar32 character = m_normalizedBuffer[0];
     if (!U16_IS_SINGLE(character))
         return false;
-    const SimpleFontData* fontData = m_font->glyphDataForCharacter(character, false, m_run.normalizeSpace()).fontData;
+    const SimpleFontData* fontData = m_font->glyphDataForCharacter(character, false, m_textRun.normalizeSpace()).fontData;
     UErrorCode errorCode = U_ZERO_ERROR;
     UScriptCode script = uscript_getScript(character, &errorCode);
     if (U_FAILURE(errorCode))
         return false;
     addHarfBuzzRun(0, 1, fontData, script);
     return true;
 }
 
 bool HarfBuzzShaper::createHarfBuzzRuns()
 {
     if (m_normalizedBufferLength == 1)
         return createHarfBuzzRunsForSingleCharacter();
 
     Vector<CandidateRun> candidateRuns;
     if (!collectCandidateRuns(m_normalizedBuffer.get(),
-        m_normalizedBufferLength, m_font, &candidateRuns, m_run.normalizeSpace()))
+        m_normalizedBufferLength, m_font, &candidateRuns, m_textRun.normalizeSpace()))
         return false;
 
     if (!resolveCandidateRuns(candidateRuns))
         return false;
 
     size_t length = candidateRuns.size();
     for (size_t i = 0; i < length; ) {
         CandidateRun& run = candidateRuns[i];
         CandidateRun lastMatchingRun = run;
         for (i++; i < length; i++) {
@@ skipping 26 matching lines @@
 void HarfBuzzShaper::addHarfBuzzRun(unsigned startCharacter,
     unsigned endCharacter, const SimpleFontData* fontData,
     UScriptCode script)
 {
     ASSERT(endCharacter > startCharacter);
     ASSERT(script != USCRIPT_INVALID_CODE);
     if (m_fallbackFonts)
         trackNonPrimaryFallbackFont(fontData);
     return m_harfBuzzRuns.append(HarfBuzzRun::create(fontData,
         startCharacter, endCharacter - startCharacter,
-        TextDirectionToHBDirection(m_run.direction(), m_font->fontDescription().orientation(), fontData),
+        TextDirectionToHBDirection(m_textRun.direction(), m_font->fontDescription().orientation(), fontData),
         ICUScriptToHBScript(script)));
 }
 
 static inline bool isValidCachedResult(const Font* font, hb_direction_t dir,
     const String& localeString, const CachedShapingResults* cachedResults)
 {
     ASSERT(cachedResults);
     return cachedResults->dir == dir
         && cachedResults->font == *font
         && !cachedResults->font.loadingCustomFonts()
@@ skipping 33 matching lines @@
 {
     HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
 
     HarfBuzzRunCache& runCache = harfBuzzRunCache();
     const FontDescription& fontDescription = m_font->fontDescription();
     const String& localeString = fontDescription.locale();
     CString locale = localeString.latin1();
     const hb_language_t language = hb_language_from_string(locale.data(), locale.length());
 
     for (unsigned i = 0; i < m_harfBuzzRuns.size(); ++i) {
-        unsigned runIndex = m_run.rtl() ? m_harfBuzzRuns.size() - i - 1 : i;
+        unsigned runIndex = m_textRun.rtl() ? m_harfBuzzRuns.size() - i - 1 : i;
         HarfBuzzRun* currentRun = m_harfBuzzRuns[runIndex].get();
 
         const SimpleFontData* currentFontData = currentRun->fontData();
         FontPlatformData* platformData = const_cast<FontPlatformData*>(&currentFontData->platformData());
         HarfBuzzFace* face = platformData->harfBuzzFace();
         if (!face)
             return false;
 
         hb_buffer_set_language(harfBuzzBuffer.get(), language);
         hb_buffer_set_script(harfBuzzBuffer.get(), currentRun->script());
@@ skipping 84 matching lines @@
 
         if (isClusterEnd)
             spacing += adjustSpacing(currentRun, i, currentCharacterIndex, *directionOffset, totalAdvance);
 
         if (currentFontData->isZeroWidthSpaceGlyph(glyph)) {
             currentRun->setGlyphAndPositions(i, glyph, 0, 0, 0);
             continue;
         }
 
         advance += spacing;
-        if (m_run.rtl()) {
+        if (m_textRun.rtl()) {
             // In RTL, spacing should be added to left side of glyphs.
             *directionOffset += spacing;
             if (!isClusterEnd)
                 *directionOffset += m_letterSpacing;
         }
 
         currentRun->setGlyphAndPositions(i, glyph, advance, offsetX, offsetY);
 
         if (m_glyphBoundingBox) {
             FloatRect glyphBounds = currentFontData->boundsForGlyph(glyph);
             glyphBounds.move(glyphOrigin.x(), glyphOrigin.y());
             m_glyphBoundingBox->unite(glyphBounds);
             glyphOrigin += FloatSize(advance + offsetX, offsetY);
         }
 
         totalAdvance += advance;
     }
     currentRun->setWidth(totalAdvance > 0.0 ? totalAdvance : 0.0);
     m_totalWidth += currentRun->width();
 }
 
 float HarfBuzzShaper::adjustSpacing(HarfBuzzRun* currentRun, size_t glyphIndex, unsigned currentCharacterIndex, float& offset, float& totalAdvance)
 {
     float spacing = 0;
     UChar32 character = m_normalizedBuffer[currentCharacterIndex];
     if (m_letterSpacing && !Character::treatAsZeroWidthSpace(character))
         spacing += m_letterSpacing;
 
     bool treatAsSpace = Character::treatAsSpace(character);
-    if (treatAsSpace && currentCharacterIndex && (character != '\t' || !m_run.allowTabs()))
+    if (treatAsSpace && currentCharacterIndex && (character != '\t' || !m_textRun.allowTabs()))
         spacing += m_wordSpacingAdjustment;
 
     if (!m_expansionOpportunityCount)
         return spacing;
 
     if (treatAsSpace) {
         spacing += nextExpansionPerOpportunity();
         m_isAfterExpansion = true;
         return spacing;
     }
 
-    if (m_run.textJustify() != TextJustify::TextJustifyAuto) {
+    if (m_textRun.textJustify() != TextJustify::TextJustifyAuto) {
         m_isAfterExpansion = false;
         return spacing;
     }
 
     // isCJKIdeographOrSymbol() has expansion opportunities both before and after each character.
     // http://www.w3.org/TR/jlreq/#line_adjustment
     if (U16_IS_LEAD(character) && currentCharacterIndex + 1 < m_normalizedBufferLength && U16_IS_TRAIL(m_normalizedBuffer[currentCharacterIndex + 1]))
         character = U16_GET_SUPPLEMENTARY(character, m_normalizedBuffer[currentCharacterIndex + 1]);
     if (!Character::isCJKIdeographOrSymbol(character)) {
         m_isAfterExpansion = false;
         return spacing;
     }
 
     if (!m_isAfterExpansion) {
         // Take the expansion opportunity before this ideograph.
         float expandBefore = nextExpansionPerOpportunity();
         if (expandBefore) {
             if (glyphIndex > 0) {
                 currentRun->addAdvance(glyphIndex - 1, expandBefore);
                 totalAdvance += expandBefore;
             } else {
                 offset += expandBefore;
                 spacing += expandBefore;
             }
         }
         if (!m_expansionOpportunityCount)
             return spacing;
     }
 
-    // Don't need to check m_run.allowsTrailingExpansion() since it's covered by !m_expansionOpportunityCount above
+    // Don't need to check m_textRun.allowsTrailingExpansion() since it's covered by !m_expansionOpportunityCount above
     spacing += nextExpansionPerOpportunity();
     m_isAfterExpansion = true;
     return spacing;
 }
 
 float HarfBuzzShaper::fillGlyphBufferFromHarfBuzzRun(GlyphBuffer* glyphBuffer,
     HarfBuzzRun* currentRun, float initialAdvance)
 {
     unsigned numGlyphs = currentRun->numGlyphs();
     float advanceSoFar = initialAdvance;
-    if (m_run.rtl()) {
+    if (m_textRun.rtl()) {
         for (unsigned i = 0; i < numGlyphs; ++i) {
             HarfBuzzRunGlyphData& glyphData = currentRun->glyphData(i);
             uint16_t currentCharacterIndex = currentRun->startIndex() + glyphData.characterIndex;
             if (currentCharacterIndex >= m_toIndex) {
                 advanceSoFar += glyphData.advance;
             } else if (currentCharacterIndex >= m_fromIndex) {
                 FloatPoint runStartOffset = HB_DIRECTION_IS_HORIZONTAL(currentRun->direction()) ?
                     FloatPoint(advanceSoFar, 0) : FloatPoint(0, advanceSoFar);
                 glyphBuffer->add(glyphData.glyph, currentRun->fontData(), runStartOffset + glyphData.offset);
                 advanceSoFar += glyphData.advance;
@@ skipping 25 matching lines @@
     uint16_t clusterStart;
 
     // 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.
 
-    if (m_run.rtl())
+    if (m_textRun.rtl())
         clusterStart = currentRun->startIndex() + currentRun->numCharacters();
     else
         clusterStart = currentRun->glyphToCharacterIndex(0);
 
     float advanceSoFar = initialAdvance;
     for (unsigned i = 0; i < numGlyphs; ++i) {
         HarfBuzzRunGlyphData& glyphData = currentRun->glyphData(i);
         uint16_t currentCharacterIndex = currentRun->startIndex() + glyphData.characterIndex;
         bool isRunEnd = (i + 1 == numGlyphs);
         bool isClusterEnd =  isRunEnd || (currentRun->glyphToCharacterIndex(i + 1) != currentCharacterIndex);
 
-        if ((m_run.rtl() && currentCharacterIndex >= m_toIndex) || (!m_run.rtl() && currentCharacterIndex < m_fromIndex)) {
+        if ((m_textRun.rtl() && currentCharacterIndex >= m_toIndex) || (!m_textRun.rtl() && currentCharacterIndex < m_fromIndex)) {
             advanceSoFar += glyphData.advance;
-            m_run.rtl() ? --clusterStart : ++clusterStart;
+            m_textRun.rtl() ? --clusterStart : ++clusterStart;
             continue;
         }
 
         clusterAdvance += glyphData.advance;
 
         if (isClusterEnd) {
             uint16_t clusterEnd;
-            if (m_run.rtl())
+            if (m_textRun.rtl())
                 clusterEnd = currentCharacterIndex;
             else
                 clusterEnd = isRunEnd ? currentRun->startIndex() + currentRun->numCharacters() : currentRun->glyphToCharacterIndex(i + 1);
 
             graphemesInCluster = countGraphemesInCluster(m_normalizedBuffer.get(), m_normalizedBufferLength, 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(m_run[currentCharacterIndex]))
+                if (Character::canReceiveTextEmphasis(m_textRun[currentCharacterIndex]))
                     addEmphasisMark(glyphBuffer, advanceSoFar + glyphAdvanceX / 2);
 
                 advanceSoFar += glyphAdvanceX;
             }
             clusterStart = clusterEnd;
             clusterAdvance = 0;
         }
     }
 
     return advanceSoFar - initialAdvance;
 }
 
 bool HarfBuzzShaper::fillGlyphBuffer(GlyphBuffer* glyphBuffer)
 {
     ASSERT(glyphBuffer);
 
     unsigned numRuns = m_harfBuzzRuns.size();
     float advanceSoFar = 0;
     for (unsigned runIndex = 0; runIndex < numRuns; ++runIndex) {
-        HarfBuzzRun* currentRun = m_harfBuzzRuns[m_run.ltr() ? runIndex : numRuns - runIndex - 1].get();
+        HarfBuzzRun* currentRun = m_harfBuzzRuns[m_textRun.ltr() ? runIndex : numRuns - runIndex - 1].get();
         // Skip runs that only contain control characters.
         if (!currentRun->numGlyphs())
             continue;
         advanceSoFar += forTextEmphasis()
             ? fillGlyphBufferForTextEmphasis(glyphBuffer, currentRun, advanceSoFar)
             : fillGlyphBufferFromHarfBuzzRun(glyphBuffer, currentRun, advanceSoFar);
     }
     return glyphBuffer->size();
 }
 
 int HarfBuzzShaper::offsetForPosition(float targetX)
 {
     int charactersSoFar = 0;
     float currentX = 0;
 
-    if (m_run.rtl()) {
+    if (m_textRun.rtl()) {
         charactersSoFar = m_normalizedBufferLength;
         for (int i = m_harfBuzzRuns.size() - 1; i >= 0; --i) {
             charactersSoFar -= m_harfBuzzRuns[i]->numCharacters();
             float nextX = currentX + m_harfBuzzRuns[i]->width();
             float offsetForRun = targetX - currentX;
             if (offsetForRun >= 0 && offsetForRun <= m_harfBuzzRuns[i]->width()) {
                 // The x value in question is within this script run.
                 const unsigned index = m_harfBuzzRuns[i]->characterIndexForXPosition(offsetForRun);
                 return charactersSoFar + index;
             }
@@ skipping 16 matching lines @@
 }
 
 FloatRect HarfBuzzShaper::selectionRect(const FloatPoint& point, int height, int from, int to)
 {
     float currentX = 0;
     float fromX = 0;
     float toX = 0;
     bool foundFromX = false;
     bool foundToX = false;
 
-    if (m_run.rtl())
+    if (m_textRun.rtl())
         currentX = m_totalWidth;
     for (unsigned i = 0; i < m_harfBuzzRuns.size(); ++i) {
-        if (m_run.rtl())
+        if (m_textRun.rtl())
             currentX -= m_harfBuzzRuns[i]->width();
         int numCharacters = m_harfBuzzRuns[i]->numCharacters();
         if (!foundFromX && from >= 0 && from < numCharacters) {
             fromX = m_harfBuzzRuns[i]->xPositionForOffset(from) + currentX;
             foundFromX = true;
         } else {
             from -= numCharacters;
         }
 
         if (!foundToX && to >= 0 && to < numCharacters) {
             toX = m_harfBuzzRuns[i]->xPositionForOffset(to) + currentX;
             foundToX = true;
         } else {
             to -= numCharacters;
         }
 
         if (foundFromX && foundToX)
             break;
-        if (!m_run.rtl())
+        if (!m_textRun.rtl())
             currentX += m_harfBuzzRuns[i]->width();
     }
 
     // The position in question might be just after the text.
     if (!foundFromX)
         fromX = 0;
     if (!foundToX)
-        toX = m_run.rtl() ? 0 : m_totalWidth;
+        toX = m_textRun.rtl() ? 0 : m_totalWidth;
     // None of our HarfBuzzRuns is part of the selection,
     // possibly invalid from, to arguments.
     if (!foundToX && !foundFromX)
         fromX = toX = 0;
 
     if (fromX < toX)
         return FloatRect(point.x() + fromX, point.y(), toX - fromX, height);
     return FloatRect(point.x() + toX, point.y(), fromX - toX, height);
 }
 
 } // namespace blink