Moving string normalization out of HarfBuzz

third_party/WebKit/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 13 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/fonts/shaping/HarfBuzzShaper.h"
 
-#include "platform/RuntimeEnabledFeatures.h"
 #include "platform/fonts/Font.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/FontFallbackIterator.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/SmallCapsIterator.h"
 #include "platform/fonts/UTF16TextIterator.h"
 #include "platform/fonts/opentype/OpenTypeCapsSupport.h"
 #include "platform/fonts/shaping/CaseMappingHarfBuzzBufferFiller.h"
 #include "platform/fonts/shaping/HarfBuzzFace.h"
 #include "platform/fonts/shaping/RunSegmenter.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
-#include "platform/text/Character.h"
 #include "platform/text/TextBreakIterator.h"
 #include "wtf/Compiler.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/Unicode.h"
 #include <algorithm>
 #include <hb.h>
 #include <memory>
 #include <unicode/uchar.h>
 #include <unicode/uscript.h>
@@ skipping 19 matching lines @@
   }
 
   T* get() { return m_ptr; }
   void set(T* ptr) { m_ptr = ptr; }
 
  private:
   T* m_ptr;
   DestroyFunction m_destroy;
 };
 
-static void normalizeCharacters(const TextRun& run,
-                                unsigned length,
-                                UChar* destination,
-                                unsigned* destinationLength) {
-  unsigned position = 0;
-  bool error = false;
-  const UChar* source;
-  String stringFor8BitRun;
-  if (run.is8Bit()) {
-    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 (run.normalizeSpace() &&
-        Character::isNormalizedCanvasSpaceCharacter(character)) {
-      character = spaceCharacter;
-    } else if (Character::treatAsSpace(character) &&
-               character != noBreakSpaceCharacter) {
-      character = spaceCharacter;
-    } else if (!RuntimeEnabledFeatures::
-                   renderUnicodeControlCharactersEnabled() &&
-               Character::legacyTreatAsZeroWidthSpaceInComplexScript(
-                   character)) {
-      character = zeroWidthSpaceCharacter;
-    } else if (Character::treatAsZeroWidthSpaceInComplexScript(character)) {
-      character = zeroWidthSpaceCharacter;
-    }
-
-    U16_APPEND(destination, *destinationLength, length, character, error);
-    DCHECK(!error);
-  }
-}
-
-HarfBuzzShaper::HarfBuzzShaper(const TextRun& run)
-    : m_textRun(run), m_normalizedBufferLength(0) {
-  m_normalizedBuffer = wrapArrayUnique(new UChar[m_textRun.length() + 1]);
-  normalizeCharacters(m_textRun, m_textRun.length(), m_normalizedBuffer.get(),
-                      &m_normalizedBufferLength);
-}
+HarfBuzzShaper::HarfBuzzShaper(const UChar* text,
+                               unsigned length,
+                               TextDirection direction)
+    : m_normalizedBuffer(text),
+      m_normalizedBufferLength(length),
+      m_textDirection(direction) {}
 
 namespace {
 
 // A port of hb_icu_script_to_script because harfbuzz on CrOS is built
 // without hb-icu. See http://crbug.com/356929
 static inline hb_script_t ICUScriptToHBScript(UScriptCode script) {
   if (UNLIKELY(script == USCRIPT_INVALID_CODE))
     return HB_SCRIPT_INVALID;
 
   return hb_script_from_string(uscript_getShortName(script), -1);
@@ skipping 153 matching lines @@
 
     // If numCharacters is 0, that means we hit a NotDef before shaping the
     // whole grapheme. We do not append it here. For the next glyph we
     // encounter, atChange will be true, and the characters corresponding to
     // the grapheme will be added to the TODO queue again, attempting to
     // shape the whole grapheme with the next font.
     // When we're getting here with the last resort font, we have no other
     // choice than adding boxes to the ShapeResult.
     if ((currentClusterResult == NotDef && numCharacters) || isLastResort) {
       hb_direction_t direction = TextDirectionToHBDirection(
-          m_textRun.direction(), font->getFontDescription().orientation(),
+          m_textDirection, font->getFontDescription().orientation(),
           currentFont);
       // Here we need to specify glyph positions.
       ShapeResult::RunInfo* run = new ShapeResult::RunInfo(
           currentFont, direction, ICUScriptToHBScript(currentRunScript),
           startIndex, numGlyphsToInsert, numCharacters);
       shapeResult->insertRun(wrapUnique(run), lastChangePosition,
                              numGlyphsToInsert, harfBuzzBuffer);
     }
     lastChangePosition = glyphIndex;
   }
@@ skipping 24 matching lines @@
   hint.clear();
 
   size_t numCharsAdded = 0;
   for (auto it = holesQueue.begin(); it != holesQueue.end(); ++it) {
     if (it->m_action == HolesQueueNextFont)
       break;
 
     UChar32 hintChar;
     RELEASE_ASSERT(it->m_startIndex + it->m_numCharacters <=
                    m_normalizedBufferLength);
-    UTF16TextIterator iterator(m_normalizedBuffer.get() + it->m_startIndex,
+    UTF16TextIterator iterator(m_normalizedBuffer + it->m_startIndex,
                                it->m_numCharacters);
     while (iterator.consume(hintChar)) {
       hint.append(hintChar);
       numCharsAdded++;
       iterator.advance();
     }
   }
   return numCharsAdded > 0;
 }
 
@@ skipping 228 matching lines @@
   m_countFeatures++;
 }
 
 CapsFeatureSettingsScopedOverlay::~CapsFeatureSettingsScopedOverlay() {
   m_features->remove(0, m_countFeatures);
 }
 
 }  // namespace
 
 PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult(const Font* font) const {
-  RefPtr<ShapeResult> result = ShapeResult::create(
-      font, m_normalizedBufferLength, m_textRun.direction());
+  RefPtr<ShapeResult> result =
+      ShapeResult::create(font, m_normalizedBufferLength, m_textDirection);
   HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(),
                                                 hb_buffer_destroy);
   FeaturesVector fontFeatures;
   setFontFeatures(font, &fontFeatures);
   const FontDescription& fontDescription = font->getFontDescription();
   const hb_language_t language =
       fontDescription.localeOrDefault().harfbuzzLanguage();
 
   bool needsCapsHandling =
       fontDescription.variantCaps() != FontDescription::CapsNormal;
   OpenTypeCapsSupport capsSupport;
   FontOrientation orientation = font->getFontDescription().orientation();
 
   RunSegmenter::RunSegmenterRange segmentRange = {
       0, 0, USCRIPT_INVALID_CODE, OrientationIterator::OrientationInvalid,
       FontFallbackPriority::Invalid};
-  RunSegmenter runSegmenter(m_normalizedBuffer.get(), m_normalizedBufferLength,
+  RunSegmenter runSegmenter(m_normalizedBuffer, m_normalizedBufferLength,
                             orientation);
 
   Vector<UChar32> fallbackCharsHint;
 
   // TODO: Check whether this treatAsZerowidthspace from the previous script
   // segmentation plays a role here, does the new scriptRuniterator handle that
   // correctly?
   Deque<HolesQueueItem> holesQueue;
   while (runSegmenter.consume(&segmentRange)) {
     RefPtr<FontFallbackIterator> fallbackIterator =
@@ skipping 34 matching lines @@
 
       const SimpleFontData* fontData = currentFontDataForRangeSet->fontData();
       SmallCapsIterator::SmallCapsBehavior smallCapsBehavior =
           SmallCapsIterator::SmallCapsSameCase;
       if (needsCapsHandling) {
         capsSupport =
             OpenTypeCapsSupport(fontData->platformData().harfBuzzFace(),
                                 fontDescription.variantCaps(),
                                 ICUScriptToHBScript(segmentRange.script));
         if (capsSupport.needsRunCaseSplitting()) {
-          splitUntilNextCaseChange(m_normalizedBuffer.get(), &holesQueue,
+          splitUntilNextCaseChange(m_normalizedBuffer, &holesQueue,
                                    currentQueueItem, smallCapsBehavior);
         }
       }
 
       ASSERT(currentQueueItem.m_numCharacters);
 
       const SimpleFontData* smallcapsAdjustedFont =
           needsCapsHandling && capsSupport.needsSyntheticFont(smallCapsBehavior)
               ? fontData->smallCapsFontData(fontDescription).get()
               : fontData;
 
       // Compatibility with SimpleFontData approach of keeping a flag for
       // overriding drawing direction.
       // TODO: crbug.com/506224 This should go away in favor of storing that
       // information elsewhere, for example in ShapeResult.
       const SimpleFontData* directionAndSmallCapsAdjustedFont =
           fontDataAdjustedForOrientation(smallcapsAdjustedFont, orientation,
                                          segmentRange.renderOrientation);
 
       CaseMapIntend caseMapIntend = CaseMapIntend::KeepSameCase;
       if (needsCapsHandling)
         caseMapIntend = capsSupport.needsCaseChange(smallCapsBehavior);
 
       CaseMappingHarfBuzzBufferFiller(
           caseMapIntend, fontDescription.localeOrDefault(),
-          harfBuzzBuffer.get(), m_normalizedBuffer.get(),
-          m_normalizedBufferLength, currentQueueItem.m_startIndex,
-          currentQueueItem.m_numCharacters);
+          harfBuzzBuffer.get(), m_normalizedBuffer, m_normalizedBufferLength,
+          currentQueueItem.m_startIndex, currentQueueItem.m_numCharacters);
 
       CapsFeatureSettingsScopedOverlay capsOverlay(
           &fontFeatures, capsSupport.fontFeatureToUse(smallCapsBehavior));
 
-      hb_direction_t direction =
-          TextDirectionToHBDirection(m_textRun.direction(), orientation,
-                                     directionAndSmallCapsAdjustedFont);
+      hb_direction_t direction = TextDirectionToHBDirection(
+          m_textDirection, orientation, directionAndSmallCapsAdjustedFont);
 
       if (!shapeRange(harfBuzzBuffer.get(),
                       fontFeatures.isEmpty() ? 0 : fontFeatures.data(),
                       fontFeatures.size(), directionAndSmallCapsAdjustedFont,
                       currentFontDataForRangeSet->ranges(), segmentRange.script,
                       direction, language))
         DLOG(ERROR) << "Shaping range failed.";
 
       if (!extractShapeResults(
               harfBuzzBuffer.get(), result.get(), fontCycleQueued, &holesQueue,
               currentQueueItem, font, directionAndSmallCapsAdjustedFont,
               segmentRange.script, !fallbackIterator->hasNext()))
         DLOG(ERROR) << "Shape result extraction failed.";
 
       hb_buffer_reset(harfBuzzBuffer.get());
     }
   }
   return result.release();
 }
 
 }  // namespace blink