Avoid re-parsing of string in fillText and measureText in Canvas

Source/platform/fonts/harfbuzz/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 339 matching lines @@
         stringFor8BitRun = String::make16BitFrom8BitSource(run.characters8(), run.length());
         source = stringFor8BitRun.characters16();
     } else
         source = run.characters16();
 
     *destinationLength = 0;
     while (position < length) {
         UChar32 character;
         U16_NEXT(source, position, length, character);
         // Don't normalize tabs as they are not treated as spaces for word-end.
-        if (Character::treatAsSpace(character) && character != characterTabulation)
+        if (run.normalizeSpace() && Character::isNormalizedCanvasSpaceCharacter(character))
+            character = space;
+        else if (Character::treatAsSpace(character) && character != characterTabulation)
             character = space;
         else if (Character::treatAsZeroWidthSpaceInComplexScript(character))
             character = zeroWidthSpace;
+
         U16_APPEND(destination, *destinationLength, length, character, error);
         ASSERT_UNUSED(error, !error);
     }
 }
 
 HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run, ForTextEmphasisOrNot forTextEmphasis, HashSet<const SimpleFontData*>* fallbackFonts)
     : m_font(font)
     , m_normalizedBufferLength(0)
     , m_run(run)
     , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
@@ skipping 231 matching lines @@
 
 struct CandidateRun {
     UChar32 character;
     unsigned start;
     unsigned end;
     const SimpleFontData* fontData;
     UScriptCode script;
 };
 
 static inline bool collectCandidateRuns(const UChar* normalizedBuffer,
-    size_t bufferLength, const Font* font, Vector<CandidateRun>* runs)
+    size_t bufferLength, const Font* font, Vector<CandidateRun>* runs, bool isSpaceNormalize)
 {
     const UChar* normalizedBufferEnd = normalizedBuffer + bufferLength;
     SurrogatePairAwareTextIterator iterator(normalizedBuffer, 0, bufferLength, bufferLength);
     UChar32 character;
     unsigned clusterLength = 0;
     unsigned startIndexOfCurrentRun = 0;
+
     if (!iterator.consume(character, clusterLength))
         return false;
 
-    const SimpleFontData* nextFontData = font->glyphDataForCharacter(character, false).fontData;
+    const SimpleFontData* nextFontData = font->glyphDataForCharacter(character, false, isSpaceNormalize).fontData;
     UErrorCode errorCode = U_ZERO_ERROR;
     UScriptCode nextScript = uscript_getScript(character, &errorCode);
     if (U_FAILURE(errorCode))
         return false;
 
     do {
         const UChar* currentCharacterPosition = iterator.characters();
         const SimpleFontData* currentFontData = nextFontData;
         UScriptCode currentScript = nextScript;
 
         UChar32 lastCharacter = character;
         for (iterator.advance(clusterLength); iterator.consume(character, clusterLength); iterator.advance(clusterLength)) {
             if (Character::treatAsZeroWidthSpace(character))
                 continue;
 
             int length = handleMultipleUChar(character, clusterLength, currentFontData, currentCharacterPosition, iterator.characters() + clusterLength, normalizedBufferEnd);
             if (length) {
                 clusterLength = length;
                 continue;
             }
 
-            nextFontData = font->glyphDataForCharacter(character, false).fontData;
+            nextFontData = font->glyphDataForCharacter(character, false, isSpaceNormalize).fontData;
             nextScript = uscript_getScript(character, &errorCode);
             if (U_FAILURE(errorCode))
                 return false;
             if (lastCharacter == zeroWidthJoiner)
                 currentFontData = nextFontData;
             if ((nextFontData != currentFontData) || ((currentScript != nextScript) && (nextScript != USCRIPT_INHERITED) && (!uscript_hasScript(character, currentScript))))
                 break;
             currentCharacterPosition = iterator.characters();
             lastCharacter = character;
         }
@@ skipping 88 matching lines @@
 
         i = std::max(i, nextResolvedRun);
     }
     return true;
 }
 
 bool HarfBuzzShaper::createHarfBuzzRuns()
 {
     Vector<CandidateRun> candidateRuns;
     if (!collectCandidateRuns(m_normalizedBuffer.get(),
-        m_normalizedBufferLength, m_font, &candidateRuns))
+        m_normalizedBufferLength, m_font, &candidateRuns, m_run.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 85 matching lines @@
                 runCache.moveToBack(cachedResults);
 
                 continue;
             }
 
             runCache.remove(cachedResults);
         }
 
         // Add a space as pre-context to the buffer. This prevents showing dotted-circle
         // for combining marks at the beginning of runs.
-        static const uint16_t preContext = ' ';
+        static const uint16_t preContext = space;
         hb_buffer_add_utf16(harfBuzzBuffer.get(), &preContext, 1, 1, 0);
 
         if (fontDescription.variant() == FontVariantSmallCaps && u_islower(m_normalizedBuffer[currentRun->startIndex()])) {
             String upperText = String(m_normalizedBuffer.get() + currentRun->startIndex(), currentRun->numCharacters()).upper();
             ASSERT(!upperText.is8Bit()); // m_normalizedBuffer is 16 bit, therefore upperText is 16 bit, even after we call makeUpper().
             hb_buffer_add_utf16(harfBuzzBuffer.get(), toUint16(upperText.characters16()), currentRun->numCharacters(), 0, currentRun->numCharacters());
         } else {
             hb_buffer_add_utf16(harfBuzzBuffer.get(), toUint16(m_normalizedBuffer.get() + currentRun->startIndex()), currentRun->numCharacters(), 0, currentRun->numCharacters());
         }
 
@@ skipping 270 matching lines @@
             point.x() + fromX, point.x() + toX,
             point.y(), height);
     }
 
     return Font::pixelSnappedSelectionRect(
         point.x() + toX, point.x() + fromX,
         point.y(), height);
 }
 
 } // namespace blink