(CANCELED) Limit word length to shape when !getTypesettingFeatures

third_party/WebKit/Source/platform/fonts/shaping/CachingWordShapeIterator.h

 /*
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 35 matching lines @@
         : m_shapeCache(cache), m_textRun(run), m_font(font)
         , m_spacing(run, font->getFontDescription())
         , m_widthSoFar(0), m_startIndex(0)
     {
         ASSERT(font);
 
         // Shaping word by word is faster as each word is cached. If we cannot
         // use the cache or if the font doesn't support word by word shaping
         // fall back on shaping the entire run.
         m_shapeByWord = m_font->canShapeWordByWord();
+
+        // Minified JS/CSS and hex/base64 data have extraordinary long "words".
+        m_limitWordLength = m_shapeByWord && m_textRun.is8Bit()
+            && !m_font->getFontDescription().getTypesettingFeatures();
     }
 
     bool next(RefPtr<ShapeResult>* wordResult)
     {
         if (UNLIKELY(m_textRun.allowTabs()))
             return nextForAllowTabs(wordResult);
 
         if (!m_shapeByWord) {
             if (m_startIndex)
                 return false;
@@ skipping 75 matching lines @@
                             hasAnyScript = true;
                             continue;
                         }
                     }
                     return end;
                 }
                 return length;
             }
         }
 
+        const unsigned limit = m_limitWordLength
+            ? std::min(length, m_startIndex + ShapeCache::maxLengthToCache())
+            : length;
         for (unsigned i = m_startIndex + 1; ; i++) {
-            if (i == length || isWordDelimiter(m_textRun[i])) {
+            if (i == limit || isWordDelimiter(m_textRun[i]))
                 return i;
-            }
+
             if (!m_textRun.is8Bit()) {
                 UChar32 nextChar;
                 U16_GET(m_textRun.characters16(), 0, i, length, nextChar);
                 if (Character::isCJKIdeographOrSymbolBase(nextChar))
                     return i;
             }
         }
     }
 
     bool shapeToEndIndex(RefPtr<ShapeResult>* result, unsigned endIndex)
@@ skipping 48 matching lines @@
         ASSERT(*wordResult);
         m_widthSoFar += (*wordResult)->width();
         return true;
     }
 
     ShapeCache* m_shapeCache;
     const TextRun& m_textRun;
     const Font* m_font;
     ShapeResultSpacing m_spacing;
     float m_widthSoFar; // Used only when allowTabs()
-    unsigned m_startIndex : 31;
+    unsigned m_startIndex : 30;
     unsigned m_shapeByWord : 1;
+    unsigned m_limitWordLength : 1;
 };
 
 } // namespace blink
 
 #endif // CachingWordShapeIterator_h