Changeset 146855 in webkit

Timestamp:

Mar 26, 2013 12:51:39 AM (11 years ago)

Author:

dominik.rottsches@intel.com

Message:

Remove HarfBuzzShaperBase
​https://bugs.webkit.org/show_bug.cgi?id=112087

Reviewed by Martin Robinson.

Folding HarfBuzzShaperBase into HarfBuzzShaper since
there is no harfbuzz-old vs. harfbuzz-ng distinction anymore.

No new tests, no change in behavior.

• GNUmakefile.list.am: Removing HarfBuzzShaperBase.*
• PlatformEfl.cmake: Removing HarfBuzzShaperBase.*
• WebCore.gypi: Removing HarfBuzzShaperBase.*
• platform/graphics/harfbuzz/HarfBuzzShaper.cpp: Folding base class members and methods into HarfBuzzShaper.

(WebCore::HarfBuzzShaper::HarfBuzzShaper):
(WebCore::normalizeSpacesAndMirrorChars):
(WebCore):
(WebCore::HarfBuzzShaper::setNormalizedBuffer):
(WebCore::HarfBuzzShaper::isWordEnd):
(WebCore::HarfBuzzShaper::determineWordBreakSpacing):
(WebCore::HarfBuzzShaper::setPadding):

• platform/graphics/harfbuzz/HarfBuzzShaper.h: Folding base class members and methods into HarfBuzzShaper.

(HarfBuzzShaper):
(WebCore::HarfBuzzShaper::isCodepointSpace):

• platform/graphics/harfbuzz/HarfBuzzShaperBase.cpp: Removed.
• platform/graphics/harfbuzz/HarfBuzzShaperBase.h: Removed.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• GNUmakefile.list.am (modified) (1 diff)
• PlatformEfl.cmake (modified) (1 diff)
• WebCore.gypi (modified) (1 diff)
• platform/graphics/harfbuzz/HarfBuzzShaper.cpp (modified) (2 diffs)
• platform/graphics/harfbuzz/HarfBuzzShaper.h (modified) (4 diffs)
• platform/graphics/harfbuzz/HarfBuzzShaperBase.cpp (deleted)
• platform/graphics/harfbuzz/HarfBuzzShaperBase.h (deleted)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-03-26  Dominik Röttsches  <dominik.rottsches@intel.com>
+
+        Remove HarfBuzzShaperBase
+        https://bugs.webkit.org/show_bug.cgi?id=112087
+
+        Reviewed by Martin Robinson.
+
+        Folding HarfBuzzShaperBase into HarfBuzzShaper since
+        there is no harfbuzz-old vs. harfbuzz-ng distinction anymore.
+
+        No new tests, no change in behavior.
+
+        * GNUmakefile.list.am: Removing HarfBuzzShaperBase.*
+        * PlatformEfl.cmake: Removing HarfBuzzShaperBase.*
+        * WebCore.gypi: Removing HarfBuzzShaperBase.*
+        * platform/graphics/harfbuzz/HarfBuzzShaper.cpp: Folding base class members and methods into HarfBuzzShaper.
+        (WebCore::HarfBuzzShaper::HarfBuzzShaper):
+        (WebCore::normalizeSpacesAndMirrorChars):
+        (WebCore):
+        (WebCore::HarfBuzzShaper::setNormalizedBuffer):
+        (WebCore::HarfBuzzShaper::isWordEnd):
+        (WebCore::HarfBuzzShaper::determineWordBreakSpacing):
+        (WebCore::HarfBuzzShaper::setPadding):
+        * platform/graphics/harfbuzz/HarfBuzzShaper.h: Folding base class members and methods into HarfBuzzShaper.
+        (HarfBuzzShaper):
+        (WebCore::HarfBuzzShaper::isCodepointSpace):
+        * platform/graphics/harfbuzz/HarfBuzzShaperBase.cpp: Removed.
+        * platform/graphics/harfbuzz/HarfBuzzShaperBase.h: Removed.
+
 2013-03-22  Hajime Morrita  <morrita@google.com>
 

trunk/Source/WebCore/GNUmakefile.list.am

@@ -4334 +4334 @@
         Source/WebCore/platform/graphics/freetype/SimpleFontDataFreeType.cpp \
         Source/WebCore/platform/graphics/freetype/UTF16UChar32Iterator.h \
-        Source/WebCore/platform/graphics/harfbuzz/HarfBuzzShaperBase.cpp \
-        Source/WebCore/platform/graphics/harfbuzz/HarfBuzzShaperBase.h \
         Source/WebCore/platform/graphics/harfbuzz/HarfBuzzFace.cpp \
         Source/WebCore/platform/graphics/harfbuzz/HarfBuzzFace.h \

trunk/Source/WebCore/PlatformEfl.cmake

@@ -131 +131 @@
     platform/graphics/gstreamer/WebKitWebSourceGStreamer.cpp
 
-    platform/graphics/harfbuzz/HarfBuzzShaperBase.cpp
     platform/graphics/harfbuzz/HarfBuzzFaceCairo.cpp
     platform/graphics/harfbuzz/HarfBuzzFace.cpp

trunk/Source/WebCore/WebCore.gypi

@@ -4235 +4235 @@
             'platform/graphics/harfbuzz/HarfBuzzShaper.cpp',
             'platform/graphics/harfbuzz/HarfBuzzShaper.h',
-            'platform/graphics/harfbuzz/HarfBuzzShaperBase.cpp',
-            'platform/graphics/harfbuzz/HarfBuzzShaperBase.h',
             'platform/graphics/mac/ColorMac.mm',
             'platform/graphics/mac/ComplexTextController.cpp',

trunk/Source/WebCore/platform/graphics/harfbuzz/HarfBuzzShaper.cpp

@@ -185 +185 @@
 
 HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run)
-    : HarfBuzzShaperBase(font, run)
+    : m_font(font)
+    , m_normalizedBufferLength(0)
+    , m_run(run)
+    , m_wordSpacingAdjustment(font->wordSpacing())
+    , m_padding(0)
+    , m_padPerWordBreak(0)
+    , m_padError(0)
+    , m_letterSpacing(font->letterSpacing())
     , m_fromIndex(0)
     , m_toIndex(m_run.length())
@@ -199 +206 @@
 {
 }
+
+static void normalizeSpacesAndMirrorChars(const UChar* source, UChar* destination, int length, HarfBuzzShaper::NormalizeMode normalizeMode)
+{
+    int position = 0;
+    bool error = false;
+    // Iterate characters in source and mirror character if needed.
+    while (position < length) {
+        UChar32 character;
+        int nextPosition = position;
+        U16_NEXT(source, nextPosition, length, character);
+        // Don't normalize tabs as they are not treated as spaces for word-end
+        if (Font::treatAsSpace(character) && character != '\t')
+            character = ' ';
+        else if (Font::treatAsZeroWidthSpace(character))
+            character = zeroWidthSpace;
+        else if (normalizeMode == HarfBuzzShaper::NormalizeMirrorChars)
+            character = u_charMirror(character);
+        U16_APPEND(destination, position, length, character, error);
+        ASSERT_UNUSED(error, !error);
+        position = nextPosition;
+    }
+}
+
+void HarfBuzzShaper::setNormalizedBuffer(NormalizeMode normalizeMode)
+{
+    // Normalize the text run in three ways:
+    // 1) Convert the |originalRun| to NFC normalized form if combining diacritical marks
+    // (U+0300..) are used in the run. This conversion is necessary since most OpenType
+    // fonts (e.g., Arial) don't have substitution rules for the diacritical marks in
+    // their GSUB tables.
+    //
+    // Note that we don't use the icu::Normalizer::isNormalized(UNORM_NFC) API here since
+    // the API returns FALSE (= not normalized) for complex runs that don't require NFC
+    // normalization (e.g., Arabic text). Unless the run contains the diacritical marks,
+    // HarfBuzz will do the same thing for us using the GSUB table.
+    // 2) Convert spacing characters into plain spaces, as some fonts will provide glyphs
+    // for characters like '\n' otherwise.
+    // 3) Convert mirrored characters such as parenthesis for rtl text.
+
+    // Convert to NFC form if the text has diacritical marks.
+    icu::UnicodeString normalizedString;
+    UErrorCode error = U_ZERO_ERROR;
+
+    const UChar* runCharacters;
+    String stringFor8BitRun;
+    if (m_run.is8Bit()) {
+        stringFor8BitRun = String::make16BitFrom8BitSource(m_run.characters8(), m_run.length());
+        runCharacters = stringFor8BitRun.characters16();
+    } else
+        runCharacters = m_run.characters16();
+
+    for (int i = 0; i < m_run.length(); ++i) {
+        UChar ch = runCharacters[i];
+        if (::ublock_getCode(ch) == UBLOCK_COMBINING_DIACRITICAL_MARKS) {
+            icu::Normalizer::normalize(icu::UnicodeString(runCharacters,
+                m_run.length()), UNORM_NFC, 0 /* no options */,
+                normalizedString, error);
+            if (U_FAILURE(error))
+                normalizedString.remove();
+            break;
+        }
+    }
+
+    const UChar* sourceText;
+    if (normalizedString.isEmpty()) {
+        m_normalizedBufferLength = m_run.length();
+        sourceText = runCharacters;
+    } else {
+        m_normalizedBufferLength = normalizedString.length();
+        sourceText = normalizedString.getBuffer();
+    }
+
+    m_normalizedBuffer = adoptArrayPtr(new UChar[m_normalizedBufferLength + 1]);
+    normalizeSpacesAndMirrorChars(sourceText, m_normalizedBuffer.get(), m_normalizedBufferLength, normalizeMode);
+}
+
+bool HarfBuzzShaper::isWordEnd(unsigned index)
+{
+    // This could refer a high-surrogate, but should work.
+    return index && isCodepointSpace(m_normalizedBuffer[index]);
+}
+
+int HarfBuzzShaper::determineWordBreakSpacing()
+{
+    int wordBreakSpacing = m_wordSpacingAdjustment;
+
+    if (m_padding > 0) {
+        int toPad = roundf(m_padPerWordBreak + m_padError);
+        m_padError += m_padPerWordBreak - toPad;
+
+        if (m_padding < toPad)
+            toPad = m_padding;
+        m_padding -= toPad;
+        wordBreakSpacing += toPad;
+    }
+    return wordBreakSpacing;
+}
+
+// setPadding sets a number of pixels to be distributed across the TextRun.
+// WebKit uses this to justify text.
+void HarfBuzzShaper::setPadding(int padding)
+{
+    m_padding = padding;
+    m_padError = 0;
+    if (!m_padding)
+        return;
+
+    // If we have padding to distribute, then we try to give an equal
+    // amount to each space. The last space gets the smaller amount, if
+    // any.
+    unsigned numWordEnds = 0;
+
+    for (unsigned i = 0; i < m_normalizedBufferLength; i++) {
+        if (isWordEnd(i))
+            numWordEnds++;
+    }
+
+    if (numWordEnds)
+        m_padPerWordBreak = m_padding / numWordEnds;
+    else
+        m_padPerWordBreak = 0;
+}
+
 
 void HarfBuzzShaper::setDrawRange(int from, int to)

trunk/Source/WebCore/platform/graphics/harfbuzz/HarfBuzzShaper.h

@@ -34 +34 @@
 #include "FloatPoint.h"
 #include "GlyphBuffer.h"
-#include "HarfBuzzShaperBase.h"
 #include "TextRun.h"
 #include "hb.h"
 #include <wtf/HashSet.h>
+#include <wtf/OwnArrayPtr.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/PassOwnPtr.h>
 #include <wtf/Vector.h>
+#include <wtf/unicode/CharacterNames.h>
 
 namespace WebCore {
@@ -47 +48 @@
 class SimpleFontData;
 
-class HarfBuzzShaper : public HarfBuzzShaperBase {
+class HarfBuzzShaper {
 public:
+    enum NormalizeMode {
+        DoNotNormalizeMirrorChars,
+        NormalizeMirrorChars
+    };
+
     HarfBuzzShaper(const Font*, const TextRun&);
     virtual ~HarfBuzzShaper();
@@ -102 +108 @@
     };
 
+    void setNormalizedBuffer(NormalizeMode = DoNotNormalizeMirrorChars);
+
+    bool isWordEnd(unsigned);
+    int determineWordBreakSpacing();
+    // setPadding sets a number of pixels to be distributed across the TextRun.
+    // WebKit uses this to justify text.
+    void setPadding(int);
+
+    // In complex text word-spacing affects each line-break, space (U+0020) and non-breaking space (U+00A0).
+    static bool isCodepointSpace(UChar c) { return c == ' ' || c == noBreakSpace || c == '\n'; }
+
     void setFontFeatures();
 
@@ -111 +128 @@
 
     GlyphBufferAdvance createGlyphBufferAdvance(float, float);
+
+    const Font* m_font;
+    OwnArrayPtr<UChar> m_normalizedBuffer;
+    unsigned m_normalizedBufferLength;
+    const TextRun& m_run;
+
+    int m_wordSpacingAdjustment; // Delta adjustment (pixels) for each word break.
+    float m_padding; // Pixels to be distributed over the line at word breaks.
+    float m_padPerWordBreak; // Pixels to be added to each word break.
+    float m_padError; // m_padPerWordBreak might have a fractional component. Since we only add a whole number of padding pixels at each word break we accumulate error. This is the number of pixels that we are behind so far.
+    int m_letterSpacing; // Pixels to be added after each glyph.
 
     Vector<hb_feature_t, 4> m_features;