Attachment #98483 for bug #10874

View Details Raw Unified Return to Bug 10874

| Differences between



2011-06-24  Matt Falkenhagen  <falken@chromium.org>

        Reviewed by NOBODY (OOPS!).

        lang, xml:lang, content-language ignored when choosing fonts
        https://bugs.webkit.org/show_bug.cgi?id=10874

        No new tests. (OOPS!)

        * css/CSSFontSelector.cpp:
        (WebCore::fontDataForGenericFamily):
        (WebCore::CSSFontSelector::getFontData):
        * css/CSSStyleSelector.cpp:
        (WebCore::CSSStyleSelector::styleForElement):
        (WebCore::CSSStyleSelector::applyProperty):
        (WebCore::CSSStyleSelector::languageTagToScriptCode):
        (WebCore::LanguageScript::if):
        (WebCore::LanguageScript::while):
        * css/CSSStyleSelector.h:
        * dom/Document.cpp:
        (WebCore::Document::Document):
        (WebCore::Document::dominantScript):
        (WebCore::Document::encodingToScriptCode):
        (WebCore::EncodingScript::if):
        * dom/Document.h:
        * page/Settings.cpp:
        (WebCore::getGenericFontFamilyForScript):
        * platform/graphics/FontDescription.h:
        (WebCore::FontDescription::FontDescription):
        (WebCore::FontDescription::script):
        (WebCore::FontDescription::setScript):
        (WebCore::FontDescription::operator==):
        * rendering/InlineTextBox.cpp:
        (WebCore::paintTextWithShadows):

2011-06-23  Zhenyao Mo  <zmo@google.com>

        Reviewed by Kenneth Russell.



        return 0;
    
    AtomicString genericFamily;
    UScriptCode script = fontDescription.script();
    if (familyName == "-webkit-serif")
        genericFamily = settings->serifFontFamily(script);
    else if (familyName == "-webkit-sans-serif")
        genericFamily = settings->sansSerifFontFamily(script);
    else if (familyName == "-webkit-cursive")
        genericFamily = settings->cursiveFontFamily(script);
    else if (familyName == "-webkit-fantasy")
        genericFamily = settings->fantasyFontFamily(script);
    else if (familyName == "-webkit-monospace")
        genericFamily = settings->fixedFontFamily(script);
    else if (familyName == "-webkit-standard")
        genericFamily = settings->standardFontFamily(script);

    if (!genericFamily.isEmpty())
        return fontCache()->getCachedFontData(fontDescription, genericFamily);

    if (m_fontFaces.isEmpty()) {
        if (familyName.startsWith("-webkit-"))
            return fontDataForGenericFamily(m_document, fontDescription, familyName);
        // USCRIPT_COMMON would resolve to "Times" but for some reason "Lucida Grande" is expected.
        if (!fontDescription.isSpecifiedFont() && fontDescription.script() != USCRIPT_COMMON)
            return fontDataForGenericFamily(m_document, fontDescription, "-webkit-standard");
        return 0;
    }




    }
    applyDeclarations<true>(true, firstUARule, lastUARule);
    
    // Update font description with language.
    FontDescription modFontDesc(m_style->fontDescription());
    AtomicString lang = m_element->computeInheritedLanguage();
    UScriptCode script;
    if (lang.isNull())
        script = m_element->document()->dominantScript();
    else
        script = CSSStyleSelector::languageTagToScriptCode(lang);
    if (script != USCRIPT_INVALID_CODE && script != USCRIPT_COMMON)
        modFontDesc.setScript(script);
    if (m_style->setFontDescription(modFontDesc))
        m_fontDirty = true;

    // If our font got dirtied, go ahead and update it now.
    if (m_fontDirty)
        updateFont();

        bool oldFamilyUsedFixedDefaultSize = fontDescription.useFixedDefaultSize();
        fontDescription.setGenericFamily(FontDescription::NoFamily);

        AtomicString lang = m_element->computeInheritedLanguage();
        UScriptCode script = CSSStyleSelector::languageTagToScriptCode(lang);
        if (script != USCRIPT_INVALID_CODE && script != USCRIPT_COMMON)
            fontDescription.setScript(script);

        for (int i = 0; i < len; i++) {
            CSSValue* item = list->itemWithoutBoundsCheck(i);
            if (!item->isPrimitiveValue())

            } else if (contentValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT && settings) {
                switch (contentValue->getIdent()) {
                    case CSSValueWebkitBody:
                        face = settings->standardFontFamily(script);
                        break;
                    case CSSValueSerif:
                        face = "-webkit-serif";

    m_pendingImageProperties.clear();
}

UScriptCode CSSStyleSelector::languageTagToScriptCode(const String& languageTag)
{
    struct LanguageScript {
        const char* languageTag;
        UScriptCode script;
    };

    // TODO: Need to add all the scripts.
    const LanguageScript languageScriptList[] = {
        { "de", USCRIPT_LATIN },
        { "en", USCRIPT_LATIN },
        { "es", USCRIPT_LATIN },
        { "fr", USCRIPT_LATIN },
        { "ja", USCRIPT_KATAKANA_OR_HIRAGANA },
        { "ko", USCRIPT_HANGUL },
        { "ru", USCRIPT_CYRILLIC },
        { "zh", USCRIPT_HAN },
        { "zh-cn", USCRIPT_SIMPLIFIED_HAN },
        { "zh-hans", USCRIPT_SIMPLIFIED_HAN },
        { "zh-hant", USCRIPT_TRADITIONAL_HAN },
        { "zh-tw", USCRIPT_TRADITIONAL_HAN }
    };

    typedef HashMap<String, UScriptCode> LanguageScriptMap;
    DEFINE_STATIC_LOCAL(LanguageScriptMap, languageScriptMap, ());
    if (languageScriptMap.isEmpty()) {
        for (size_t i = 0; i < sizeof(languageScriptList) / sizeof(languageScriptList[0]); ++i)
            languageScriptMap.set(languageScriptList[i].languageTag, languageScriptList[i].script);
    }

    String language = languageTag.lower();
    while (!language.isEmpty()) {
        HashMap<String, UScriptCode>::iterator it = languageScriptMap.find(language);
        if (it != languageScriptMap.end())
            return it->second;
        size_t pos = language.reverseFind('-');
        if (pos == notFound)
            break;
        language = language.substring(0, pos);
    }
    return USCRIPT_COMMON;
}



} // namespace WebCore

Lines 115-120 public: a/Source/WebCore/css/CSSStyleSelector.h_sec1
- a/Source/WebCore/css/CSSStyleSelector.h +1 lines
115	FontDescription parentFontDescription() {return parentStyle()->fontDescription(); }	115	FontDescription parentFontDescription() {return parentStyle()->fontDescription(); }
116	void setFontDescription(FontDescription fontDescription) { m_fontDirty \|= style()->setFontDescription(fontDescription); }	116	void setFontDescription(FontDescription fontDescription) { m_fontDirty \|= style()->setFontDescription(fontDescription); }
117		117
		118	static UScriptCode languageTagToScriptCode(const String& languageTag);
118	private:	119	private:
119	void initForStyleResolve(Element, RenderStyle parentStyle = 0, PseudoId = NOPSEUDO);	120	void initForStyleResolve(Element, RenderStyle parentStyle = 0, PseudoId = NOPSEUDO);
120	void initElement(Element*);	121	void initElement(Element*);



#include "htmlediting.h"
#include <wtf/CurrentTime.h>
#include <wtf/HashFunctions.h>
#include <wtf/HashMap.h>
#include <wtf/MainThread.h>
#include <wtf/PassRefPtr.h>
#include <wtf/StdLibExtras.h>

    , m_scriptRunner(ScriptRunner::create(this))
    , m_xmlVersion("1.0")
    , m_xmlStandalone(false)
    , m_dominantScript(USCRIPT_INVALID_CODE)
    , m_savedRenderer(0)
    , m_designMode(inherit)
#if ENABLE(DASHBOARD_SUPPORT)

    decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
}

UScriptCode Document::dominantScript()
{
    if (m_dominantScript != USCRIPT_INVALID_CODE)
        return m_dominantScript;
    String encoding = inputEncoding();
    if (encoding.isEmpty())
        return m_dominantScript;
    m_dominantScript = encodingToScriptCode(encoding);
    return m_dominantScript;
}

UScriptCode Document::encodingToScriptCode(const String& encoding)
{
    struct EncodingScript {
        const char* encoding;
        UScriptCode script;
    };

    // inputEncoding() always returns a canonical name. We use
    // MIME names and IANA names (if the former is not available).
    static const EncodingScript encodingScriptList[] = {
        { "GB2312", USCRIPT_SIMPLIFIED_HAN },
        { "GBK", USCRIPT_SIMPLIFIED_HAN },
        { "GB18030", USCRIPT_SIMPLIFIED_HAN },
        { "Big5", USCRIPT_TRADITIONAL_HAN },
        { "Big5-HKSCS", USCRIPT_TRADITIONAL_HAN },
        { "Shift_JIS", USCRIPT_KATAKANA_OR_HIRAGANA },
        { "EUC-JP", USCRIPT_KATAKANA_OR_HIRAGANA },
        { "ISO-2022-JP", USCRIPT_KATAKANA_OR_HIRAGANA },
        { "ISO-2022-KR", USCRIPT_HANGUL },
        { "EUC-KR", USCRIPT_HANGUL },
        { "TIS-620", USCRIPT_THAI },
        { "ISO-8859-1", USCRIPT_LATIN },
        { "ISO-8859-15", USCRIPT_LATIN },
        { "windows-1252", USCRIPT_LATIN },
        { "ISO-8859-2", USCRIPT_LATIN },
        { "windows-1250", USCRIPT_LATIN },
        { "ISO-8859-3", USCRIPT_LATIN },
        { "ISO-8859-4", USCRIPT_LATIN },
        { "ISO-8859-13", USCRIPT_LATIN },
        { "windows-1257", USCRIPT_LATIN },
        { "ISO-8859-5", USCRIPT_CYRILLIC },
        { "windows-1251", USCRIPT_CYRILLIC },
        { "KOI8-R", USCRIPT_CYRILLIC },
        { "KOI8-U", USCRIPT_CYRILLIC },
        { "ISO-8859-6", USCRIPT_ARABIC },
        { "windows-1256", USCRIPT_ARABIC },
        { "ISO-8859-7", USCRIPT_GREEK },
        { "windows-1253", USCRIPT_GREEK },
        { "ISO-8859-8", USCRIPT_HEBREW },
        { "windows-1255", USCRIPT_HEBREW },
        { "ISO-8859-9", USCRIPT_LATIN }, // Turkish
        { "windows-1254", USCRIPT_LATIN },
        { "ISO-8859-10", USCRIPT_LATIN }, // Nordic
        { "ISO-8859-14", USCRIPT_LATIN }, // Celtic
        { "ISO-8859-16", USCRIPT_LATIN }, // Romanian
        { "windows-1258", USCRIPT_LATIN }, // Vietnamese
    };

    typedef HashMap<String, UScriptCode> EncodingScriptMap;
    DEFINE_STATIC_LOCAL(EncodingScriptMap, encodingScriptMap, ());

    if (encodingScriptMap.isEmpty()) {
        for (unsigned i = 0; i < sizeof(encodingScriptList) / sizeof(encodingScriptList[0]); ++i)
            encodingScriptMap.set(encodingScriptList[i].encoding,
                                  encodingScriptList[i].script);
    }
    HashMap<String, UScriptCode>::iterator it = encodingScriptMap.find(encoding);
    UScriptCode dominantScript;
    if (it != encodingScriptMap.end())
        dominantScript = it->second;
    else
        // TODO(jungshik) : should return a script corresponding to the locale.
        dominantScript = USCRIPT_COMMON;
    return dominantScript;
}

void Document::setXMLVersion(const String& version, ExceptionCode& ec)
{
    if (!implementation()->hasFeature("XML", String())) {

Lines 374-379 public: a/Source/WebCore/dom/Document.h_sec1
- a/Source/WebCore/dom/Document.h +5 lines
374	String contentLanguage() const { return m_contentLanguage; }	374	String contentLanguage() const { return m_contentLanguage; }
375	void setContentLanguage(const String& lang) { m_contentLanguage = lang; }	375	void setContentLanguage(const String& lang) { m_contentLanguage = lang; }
376		376
		377	UScriptCode dominantScript();
		378	static UScriptCode encodingToScriptCode(const String& encoding);
		379
377	String xmlEncoding() const { return m_xmlEncoding; }	380	String xmlEncoding() const { return m_xmlEncoding; }
378	String xmlVersion() const { return m_xmlVersion; }	381	String xmlVersion() const { return m_xmlVersion; }
379	bool xmlStandalone() const { return m_xmlStandalone; }	382	bool xmlStandalone() const { return m_xmlStandalone; }
Lines 1305-1310 private: a/Source/WebCore/dom/Document.h_sec2
1305		1308
1306	String m_contentLanguage;	1309	String m_contentLanguage;
1307		1310
		1311	UScriptCode m_dominantScript;
		1312
1308	#if ENABLE(XHTMLMP)	1313	#if ENABLE(XHTMLMP)
1309	bool m_shouldProcessNoScriptElement;	1314	bool m_shouldProcessNoScriptElement;
1310	#endif	1315	#endif

Lines 63-69 static inline const AtomicString& getGenericFontFamilyForScript(const ScriptFont a/Source/WebCore/page/Settings.cpp_sec1
- a/Source/WebCore/page/Settings.cpp -1 / +3 lines
63	ScriptFontFamilyMap::const_iterator it = fontMap.find(static_cast<int>(script));	63	ScriptFontFamilyMap::const_iterator it = fontMap.find(static_cast<int>(script));
64	if (it != fontMap.end())	64	if (it != fontMap.end())
65	return it->second;	65	return it->second;
66	return emptyAtom;	66	if (script == USCRIPT_COMMON)
		67	return emptyAtom;
		68	return getGenericFontFamilyForScript(fontMap, USCRIPT_COMMON);
67	}	69	}
68		70
69	#if USE(SAFARI_THEME)	71	#if USE(SAFARI_THEME)



        , m_fontSmoothing(AutoSmoothing)
        , m_textRendering(AutoTextRendering)
        , m_isSpecifiedFont(false)
        , m_script(USCRIPT_COMMON)
    {
    }


    unsigned keywordSize() const { return m_keywordSize; }
    FontSmoothingMode fontSmoothing() const { return static_cast<FontSmoothingMode>(m_fontSmoothing); }
    TextRenderingMode textRenderingMode() const { return static_cast<TextRenderingMode>(m_textRendering); }
    UScriptCode script() const { return m_script; }

    FontTraitsMask traitsMask() const;
    bool isSpecifiedFont() const { return m_isSpecifiedFont; }

    void setOrientation(FontOrientation orientation) { m_orientation = orientation; }
    void setTextOrientation(TextOrientation textOrientation) { m_textOrientation = textOrientation; }
    void setWidthVariant(FontWidthVariant widthVariant) { m_widthVariant = widthVariant; }
    void setScript(UScriptCode s) { m_script = s; }

private:
    FontFamily m_familyList; // The list of font families to be used.

    unsigned m_fontSmoothing : 2; // FontSmoothingMode
    unsigned m_textRendering : 2; // TextRenderingMode
    bool m_isSpecifiedFont : 1; // True if a web page specifies a non-generic font family as the first font family.
    UScriptCode m_script; // The script of the text, used to choose an appropriate font for the generic font family.
};

inline bool FontDescription::operator==(const FontDescription& other) const

        && m_isSpecifiedFont == other.m_isSpecifiedFont
        && m_orientation == other.m_orientation
        && m_textOrientation == other.m_textOrientation
        && m_widthVariant == other.m_widthVariant
        && m_script == other.m_script;
}

}

Lines 397-402 static void paintTextWithShadows(GraphicsContext* context, const Font& font, con a/Source/WebCore/rendering/InlineTextBox.cpp_sec1
- a/Source/WebCore/rendering/InlineTextBox.cpp +1 lines
397	if (!opaque)	397	if (!opaque)
398	context->setFillColor(Color::black, fillColorSpace);	398	context->setFillColor(Color::black, fillColorSpace);
399		399
		400	FontCachePurgePreventer fontCachePurgePreventer;
400	do {	401	do {
401	IntSize extraOffset;	402	IntSize extraOffset;
402	if (shadow)	403	if (shadow)



2011-06-24  Matt Falkenhagen  <falken@chromium.org>

        Reviewed by NOBODY (OOPS!).

        lang, xml:lang, content-language ignored when choosing fonts
        https://bugs.webkit.org/show_bug.cgi?id=10874

        * src/WebSettingsImpl.cpp:
        (WebKit::WebSettingsImpl::setStandardFontFamily):
        (WebKit::WebSettingsImpl::setFixedFontFamily):
        (WebKit::WebSettingsImpl::setSerifFontFamily):
        (WebKit::WebSettingsImpl::setSansSerifFontFamily):

2011-06-23  John Bates  <jbates@google.com>

        Reviewed by James Robinson.

Lines 57-77 WebSettingsImpl::WebSettingsImpl(Settings* settings) a/Source/WebKit/chromium/src/WebSettingsImpl.cpp_sec1
- a/Source/WebKit/chromium/src/WebSettingsImpl.cpp +16 lines
57	void WebSettingsImpl::setStandardFontFamily(const WebString& font)	57	void WebSettingsImpl::setStandardFontFamily(const WebString& font)
58	{	58	{
59	m_settings->setStandardFontFamily(font);	59	m_settings->setStandardFontFamily(font);
		60	m_settings->setStandardFontFamily("WenQuanYi Micro Hei", USCRIPT_HAN);
		61	m_settings->setStandardFontFamily("WenQuanYi Micro Hei", USCRIPT_SIMPLIFIED_HAN);
		62	m_settings->setStandardFontFamily("PMingLiu", USCRIPT_TRADITIONAL_HAN);
		63	m_settings->setStandardFontFamily("IPAPGothic", USCRIPT_KATAKANA_OR_HIRAGANA);
60	}	64	}
61		65
62	void WebSettingsImpl::setFixedFontFamily(const WebString& font)	66	void WebSettingsImpl::setFixedFontFamily(const WebString& font)
63	{	67	{
64	m_settings->setFixedFontFamily((String)font);	68	m_settings->setFixedFontFamily((String)font);
		69	m_settings->setFixedFontFamily("WenQuanYi Micro Hei Mono", USCRIPT_HAN);
		70	m_settings->setFixedFontFamily("WenQuanYi Micro Hei Mono", USCRIPT_SIMPLIFIED_HAN);
		71	m_settings->setFixedFontFamily("MingLiu", USCRIPT_TRADITIONAL_HAN);
		72	m_settings->setFixedFontFamily("IPAGothic", USCRIPT_KATAKANA_OR_HIRAGANA);
65	}	73	}
66		74
67	void WebSettingsImpl::setSerifFontFamily(const WebString& font)	75	void WebSettingsImpl::setSerifFontFamily(const WebString& font)
68	{	76	{
69	m_settings->setSerifFontFamily((String)font);	77	m_settings->setSerifFontFamily((String)font);
		78	m_settings->setSerifFontFamily("WenQuanYi Micro Hei", USCRIPT_HAN);
		79	m_settings->setSerifFontFamily("WenQuanYi Micro Hei", USCRIPT_SIMPLIFIED_HAN);
		80	m_settings->setSerifFontFamily("PMingLiu", USCRIPT_TRADITIONAL_HAN);
		81	m_settings->setSerifFontFamily("IPAPMincho", USCRIPT_KATAKANA_OR_HIRAGANA);
70	}	82	}
71		83
72	void WebSettingsImpl::setSansSerifFontFamily(const WebString& font)	84	void WebSettingsImpl::setSansSerifFontFamily(const WebString& font)
73	{	85	{
74	m_settings->setSansSerifFontFamily((String)font);	86	m_settings->setSansSerifFontFamily((String)font);
		87	m_settings->setSansSerifFontFamily("WenQuanYi Micro Hei", USCRIPT_HAN);
		88	m_settings->setSansSerifFontFamily("WenQuanYi Micro Hei", USCRIPT_SIMPLIFIED_HAN);
		89	m_settings->setSansSerifFontFamily("PMingLiu", USCRIPT_TRADITIONAL_HAN);
		90	m_settings->setSansSerifFontFamily("IPAPGothic", USCRIPT_KATAKANA_OR_HIRAGANA);
75	}	91	}
76		92
77	void WebSettingsImpl::setCursiveFontFamily(const WebString& font)	93	void WebSettingsImpl::setCursiveFontFamily(const WebString& font)



2011-06-24  Matt Falkenhagen  <falken@chromium.org>

        Reviewed by NOBODY (OOPS!).

        lang, xml:lang, content-language ignored when choosing fonts
        https://bugs.webkit.org/show_bug.cgi?id=10874

        * WebView/WebView.mm:
        (-[WebView _preferencesChanged:]):

2011-06-22  Sam Weinig  <sam@webkit.org>

        Roll out r89469 (Add preference for setting the html parser depth limit)



    settings->setSansSerifFontFamily([preferences sansSerifFontFamily]);
    settings->setSerifFontFamily([preferences serifFontFamily]);
    settings->setStandardFontFamily([preferences standardFontFamily]);
    // TODO move these to WebPreferences.mm
    settings->setStandardFontFamily(@"STHeiti", USCRIPT_HAN);
    settings->setSansSerifFontFamily(@"STHeiti", USCRIPT_HAN);
    settings->setSerifFontFamily(@"STSong", USCRIPT_HAN);
    settings->setStandardFontFamily(@"STHeiti", USCRIPT_SIMPLIFIED_HAN);
    settings->setSansSerifFontFamily(@"STHeiti", USCRIPT_SIMPLIFIED_HAN);
    settings->setSerifFontFamily(@"STSong", USCRIPT_SIMPLIFIED_HAN);
    settings->setStandardFontFamily(@"Apple LiGothic", USCRIPT_TRADITIONAL_HAN);
    settings->setSansSerifFontFamily(@"Apple LiGothic", USCRIPT_TRADITIONAL_HAN);
    settings->setSerifFontFamily(@"Apple LiSung", USCRIPT_TRADITIONAL_HAN);
    settings->setStandardFontFamily(@"AppleGothic", USCRIPT_HANGUL);
    settings->setSansSerifFontFamily(@"AppleGothic", USCRIPT_HANGUL);
    settings->setSerifFontFamily(@"AppleMyungjo", USCRIPT_HANGUL);
    settings->setStandardFontFamily(@"Hiragino Kaku Gothic Pro", USCRIPT_KATAKANA_OR_HIRAGANA);
    settings->setSansSerifFontFamily(@"Hiragino Kaku Gothic Pro", USCRIPT_KATAKANA_OR_HIRAGANA);
    settings->setSerifFontFamily(@"Hiragino Mincho Pro", USCRIPT_KATAKANA_OR_HIRAGANA);
    settings->setLoadsImagesAutomatically([preferences loadsImagesAutomatically]);
    settings->setLoadsSiteIconsIgnoringImageLoadingSetting([preferences loadsSiteIconsIgnoringImageLoadingPreference]);
    settings->setShouldPrintBackgrounds([preferences shouldPrintBackgrounds]);

Return to Bug 10874

Lines 1500-1505 PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* e, RenderStyl a/Source/WebCore/css/CSSStyleSelector.cpp_sec1
- a/Source/WebCore/css/CSSStyleSelector.cpp -1 / +64 lines
1500	}	1500	}
1501	applyDeclarations<true>(true, firstUARule, lastUARule);	1501	applyDeclarations<true>(true, firstUARule, lastUARule);
1502		1502
		1503	// Update font description with language.
		1504	FontDescription modFontDesc(m_style->fontDescription());
		1505	AtomicString lang = m_element->computeInheritedLanguage();
		1506	UScriptCode script;
		1507	if (lang.isNull())
		1508	script = m_element->document()->dominantScript();
		1509	else
		1510	script = CSSStyleSelector::languageTagToScriptCode(lang);
		1511	if (script != USCRIPT_INVALID_CODE && script != USCRIPT_COMMON)
		1512	modFontDesc.setScript(script);
		1513	if (m_style->setFontDescription(modFontDesc))
		1514	m_fontDirty = true;
		1515
1503	// If our font got dirtied, go ahead and update it now.	1516	// If our font got dirtied, go ahead and update it now.
1504	if (m_fontDirty)	1517	if (m_fontDirty)
1505	updateFont();	1518	updateFont();
Lines 4290-4295 void CSSStyleSelector::applyProperty(int id, CSSValue *value) a/Source/WebCore/css/CSSStyleSelector.cpp_sec2
4290	bool oldFamilyUsedFixedDefaultSize = fontDescription.useFixedDefaultSize();	4303	bool oldFamilyUsedFixedDefaultSize = fontDescription.useFixedDefaultSize();
4291	fontDescription.setGenericFamily(FontDescription::NoFamily);	4304	fontDescription.setGenericFamily(FontDescription::NoFamily);
4292		4305
		4306	AtomicString lang = m_element->computeInheritedLanguage();
		4307	UScriptCode script = CSSStyleSelector::languageTagToScriptCode(lang);
		4308	if (script != USCRIPT_INVALID_CODE && script != USCRIPT_COMMON)
		4309	fontDescription.setScript(script);
		4310
4293	for (int i = 0; i < len; i++) {	4311	for (int i = 0; i < len; i++) {
4294	CSSValue* item = list->itemWithoutBoundsCheck(i);	4312	CSSValue* item = list->itemWithoutBoundsCheck(i);
4295	if (!item->isPrimitiveValue())	4313	if (!item->isPrimitiveValue())
Lines 4303-4309 void CSSStyleSelector::applyProperty(int id, CSSValue *value) a/Source/WebCore/css/CSSStyleSelector.cpp_sec3
4303	} else if (contentValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT && settings) {	4321	} else if (contentValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT && settings) {
4304	switch (contentValue->getIdent()) {	4322	switch (contentValue->getIdent()) {
4305	case CSSValueWebkitBody:	4323	case CSSValueWebkitBody:
4306	face = settings->standardFontFamily();	4324	face = settings->standardFontFamily(script);
4307	break;	4325	break;
4308	case CSSValueSerif:	4326	case CSSValueSerif:
4309	face = "-webkit-serif";	4327	face = "-webkit-serif";
Lines 6793-6796 void CSSStyleSelector::loadPendingImages() a/Source/WebCore/css/CSSStyleSelector.cpp_sec4
6793	m_pendingImageProperties.clear();	6811	m_pendingImageProperties.clear();
6794	}	6812	}
6795		6813
		6814	UScriptCode CSSStyleSelector::languageTagToScriptCode(const String& languageTag)
		6815	{
		6816	struct LanguageScript {
		6817	const char* languageTag;
		6818	UScriptCode script;
		6819	};
		6820
		6821	// TODO: Need to add all the scripts.
		6822	const LanguageScript languageScriptList[] = {
		6823	{ "de", USCRIPT_LATIN },
		6824	{ "en", USCRIPT_LATIN },
		6825	{ "es", USCRIPT_LATIN },
		6826	{ "fr", USCRIPT_LATIN },
		6827	{ "ja", USCRIPT_KATAKANA_OR_HIRAGANA },
		6828	{ "ko", USCRIPT_HANGUL },
		6829	{ "ru", USCRIPT_CYRILLIC },
		6830	{ "zh", USCRIPT_HAN },
		6831	{ "zh-cn", USCRIPT_SIMPLIFIED_HAN },
		6832	{ "zh-hans", USCRIPT_SIMPLIFIED_HAN },
		6833	{ "zh-hant", USCRIPT_TRADITIONAL_HAN },
		6834	{ "zh-tw", USCRIPT_TRADITIONAL_HAN }
		6835	};
		6836
		6837	typedef HashMap<String, UScriptCode> LanguageScriptMap;
		6838	DEFINE_STATIC_LOCAL(LanguageScriptMap, languageScriptMap, ());
		6839	if (languageScriptMap.isEmpty()) {
		6840	for (size_t i = 0; i < sizeof(languageScriptList) / sizeof(languageScriptList[0]); ++i)
		6841	languageScriptMap.set(languageScriptList[i].languageTag, languageScriptList[i].script);
		6842	}
		6843
		6844	String language = languageTag.lower();
		6845	while (!language.isEmpty()) {
		6846	HashMap<String, UScriptCode>::iterator it = languageScriptMap.find(language);
		6847	if (it != languageScriptMap.end())
		6848	return it->second;
		6849	size_t pos = language.reverseFind('-');
		6850	if (pos == notFound)
		6851	break;
		6852	language = language.substring(0, pos);
		6853	}
		6854	return USCRIPT_COMMON;
		6855	}
		6856
		6857
		6858
6796	} // namespace WebCore	6859	} // namespace WebCore

Lines 153-158 a/Source/WebCore/dom/Document.cpp_sec1
- a/Source/WebCore/dom/Document.cpp +79 lines
153	#include "htmlediting.h"	153	#include "htmlediting.h"
154	#include <wtf/CurrentTime.h>	154	#include <wtf/CurrentTime.h>
155	#include <wtf/HashFunctions.h>	155	#include <wtf/HashFunctions.h>
		156	#include <wtf/HashMap.h>
156	#include <wtf/MainThread.h>	157	#include <wtf/MainThread.h>
157	#include <wtf/PassRefPtr.h>	158	#include <wtf/PassRefPtr.h>
158	#include <wtf/StdLibExtras.h>	159	#include <wtf/StdLibExtras.h>
Lines 393-398 Document::Document(Frame* frame, const KURL& url, bool isXHTML, bool isHTML) a/Source/WebCore/dom/Document.cpp_sec2
393	, m_scriptRunner(ScriptRunner::create(this))	394	, m_scriptRunner(ScriptRunner::create(this))
394	, m_xmlVersion("1.0")	395	, m_xmlVersion("1.0")
395	, m_xmlStandalone(false)	396	, m_xmlStandalone(false)
		397	, m_dominantScript(USCRIPT_INVALID_CODE)
396	, m_savedRenderer(0)	398	, m_savedRenderer(0)
397	, m_designMode(inherit)	399	, m_designMode(inherit)
398	#if ENABLE(DASHBOARD_SUPPORT)	400	#if ENABLE(DASHBOARD_SUPPORT)
Lines 1045-1050 void Document::setCharset(const String& charset) a/Source/WebCore/dom/Document.cpp_sec3
1045	decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);	1047	decoder()->setEncoding(charset, TextResourceDecoder::UserChosenEncoding);
1046	}	1048	}
1047		1049
		1050	UScriptCode Document::dominantScript()
		1051	{
		1052	if (m_dominantScript != USCRIPT_INVALID_CODE)
		1053	return m_dominantScript;
		1054	String encoding = inputEncoding();
		1055	if (encoding.isEmpty())
		1056	return m_dominantScript;
		1057	m_dominantScript = encodingToScriptCode(encoding);
		1058	return m_dominantScript;
		1059	}
		1060
		1061	UScriptCode Document::encodingToScriptCode(const String& encoding)
		1062	{
		1063	struct EncodingScript {
		1064	const char* encoding;
		1065	UScriptCode script;
		1066	};
		1067
		1068	// inputEncoding() always returns a canonical name. We use
		1069	// MIME names and IANA names (if the former is not available).
		1070	static const EncodingScript encodingScriptList[] = {
		1071	{ "GB2312", USCRIPT_SIMPLIFIED_HAN },
		1072	{ "GBK", USCRIPT_SIMPLIFIED_HAN },
		1073	{ "GB18030", USCRIPT_SIMPLIFIED_HAN },
		1074	{ "Big5", USCRIPT_TRADITIONAL_HAN },
		1075	{ "Big5-HKSCS", USCRIPT_TRADITIONAL_HAN },
		1076	{ "Shift_JIS", USCRIPT_KATAKANA_OR_HIRAGANA },
		1077	{ "EUC-JP", USCRIPT_KATAKANA_OR_HIRAGANA },
		1078	{ "ISO-2022-JP", USCRIPT_KATAKANA_OR_HIRAGANA },
		1079	{ "ISO-2022-KR", USCRIPT_HANGUL },
		1080	{ "EUC-KR", USCRIPT_HANGUL },
		1081	{ "TIS-620", USCRIPT_THAI },
		1082	{ "ISO-8859-1", USCRIPT_LATIN },
		1083	{ "ISO-8859-15", USCRIPT_LATIN },
		1084	{ "windows-1252", USCRIPT_LATIN },
		1085	{ "ISO-8859-2", USCRIPT_LATIN },
		1086	{ "windows-1250", USCRIPT_LATIN },
		1087	{ "ISO-8859-3", USCRIPT_LATIN },
		1088	{ "ISO-8859-4", USCRIPT_LATIN },
		1089	{ "ISO-8859-13", USCRIPT_LATIN },
		1090	{ "windows-1257", USCRIPT_LATIN },
		1091	{ "ISO-8859-5", USCRIPT_CYRILLIC },
		1092	{ "windows-1251", USCRIPT_CYRILLIC },
		1093	{ "KOI8-R", USCRIPT_CYRILLIC },
		1094	{ "KOI8-U", USCRIPT_CYRILLIC },
		1095	{ "ISO-8859-6", USCRIPT_ARABIC },
		1096	{ "windows-1256", USCRIPT_ARABIC },
		1097	{ "ISO-8859-7", USCRIPT_GREEK },
		1098	{ "windows-1253", USCRIPT_GREEK },
		1099	{ "ISO-8859-8", USCRIPT_HEBREW },
		1100	{ "windows-1255", USCRIPT_HEBREW },
		1101	{ "ISO-8859-9", USCRIPT_LATIN }, // Turkish
		1102	{ "windows-1254", USCRIPT_LATIN },
		1103	{ "ISO-8859-10", USCRIPT_LATIN }, // Nordic
		1104	{ "ISO-8859-14", USCRIPT_LATIN }, // Celtic
		1105	{ "ISO-8859-16", USCRIPT_LATIN }, // Romanian
		1106	{ "windows-1258", USCRIPT_LATIN }, // Vietnamese
		1107	};
		1108
		1109	typedef HashMap<String, UScriptCode> EncodingScriptMap;
		1110	DEFINE_STATIC_LOCAL(EncodingScriptMap, encodingScriptMap, ());
		1111
		1112	if (encodingScriptMap.isEmpty()) {
		1113	for (unsigned i = 0; i < sizeof(encodingScriptList) / sizeof(encodingScriptList[0]); ++i)
1114	encodingScriptMap.set(encodingScriptList[i].encoding,
1115	encodingScriptList[i].script);
1116	}
1117	HashMap<String, UScriptCode>::iterator it = encodingScriptMap.find(encoding);
1118	UScriptCode dominantScript;
1119	if (it != encodingScriptMap.end())
1120	dominantScript = it->second;
1121	else
1122	// TODO(jungshik) : should return a script corresponding to the locale.
1123	dominantScript = USCRIPT_COMMON;
1124	return dominantScript;
1125	}
1126
1048	void Document::setXMLVersion(const String& version, ExceptionCode& ec)	1127	void Document::setXMLVersion(const String& version, ExceptionCode& ec)
1049	{	1128	{
1050	if (!implementation()->hasFeature("XML", String())) {	1129	if (!implementation()->hasFeature("XML", String())) {

Lines 1509-1514 static bool needsSelfRetainWhileLoadingQuirk() a/Source/WebKit/mac/WebView/WebView.mm_sec1
- a/Source/WebKit/mac/WebView/WebView.mm +16 lines
1509	settings->setSansSerifFontFamily([preferences sansSerifFontFamily]);	1509	settings->setSansSerifFontFamily([preferences sansSerifFontFamily]);
1510	settings->setSerifFontFamily([preferences serifFontFamily]);	1510	settings->setSerifFontFamily([preferences serifFontFamily]);
1511	settings->setStandardFontFamily([preferences standardFontFamily]);	1511	settings->setStandardFontFamily([preferences standardFontFamily]);
		1512	// TODO move these to WebPreferences.mm
		1513	settings->setStandardFontFamily(@"STHeiti", USCRIPT_HAN);
		1514	settings->setSansSerifFontFamily(@"STHeiti", USCRIPT_HAN);
		1515	settings->setSerifFontFamily(@"STSong", USCRIPT_HAN);
		1516	settings->setStandardFontFamily(@"STHeiti", USCRIPT_SIMPLIFIED_HAN);
		1517	settings->setSansSerifFontFamily(@"STHeiti", USCRIPT_SIMPLIFIED_HAN);
		1518	settings->setSerifFontFamily(@"STSong", USCRIPT_SIMPLIFIED_HAN);
		1519	settings->setStandardFontFamily(@"Apple LiGothic", USCRIPT_TRADITIONAL_HAN);
		1520	settings->setSansSerifFontFamily(@"Apple LiGothic", USCRIPT_TRADITIONAL_HAN);
		1521	settings->setSerifFontFamily(@"Apple LiSung", USCRIPT_TRADITIONAL_HAN);
		1522	settings->setStandardFontFamily(@"AppleGothic", USCRIPT_HANGUL);
		1523	settings->setSansSerifFontFamily(@"AppleGothic", USCRIPT_HANGUL);
		1524	settings->setSerifFontFamily(@"AppleMyungjo", USCRIPT_HANGUL);
		1525	settings->setStandardFontFamily(@"Hiragino Kaku Gothic Pro", USCRIPT_KATAKANA_OR_HIRAGANA);
		1526	settings->setSansSerifFontFamily(@"Hiragino Kaku Gothic Pro", USCRIPT_KATAKANA_OR_HIRAGANA);
		1527	settings->setSerifFontFamily(@"Hiragino Mincho Pro", USCRIPT_KATAKANA_OR_HIRAGANA);
1512	settings->setLoadsImagesAutomatically([preferences loadsImagesAutomatically]);	1528	settings->setLoadsImagesAutomatically([preferences loadsImagesAutomatically]);
1513	settings->setLoadsSiteIconsIgnoringImageLoadingSetting([preferences loadsSiteIconsIgnoringImageLoadingPreference]);	1529	settings->setLoadsSiteIconsIgnoringImageLoadingSetting([preferences loadsSiteIconsIgnoringImageLoadingPreference]);
1514	settings->setShouldPrintBackgrounds([preferences shouldPrintBackgrounds]);	1530	settings->setShouldPrintBackgrounds([preferences shouldPrintBackgrounds]);

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +35 lines
		1	2011-06-24 Matt Falkenhagen <falken@chromium.org>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	lang, xml:lang, content-language ignored when choosing fonts
		6	https://bugs.webkit.org/show_bug.cgi?id=10874
		7
		8	No new tests. (OOPS!)
		9
		10	* css/CSSFontSelector.cpp:
		11	(WebCore::fontDataForGenericFamily):
		12	(WebCore::CSSFontSelector::getFontData):
		13	* css/CSSStyleSelector.cpp:
		14	(WebCore::CSSStyleSelector::styleForElement):
		15	(WebCore::CSSStyleSelector::applyProperty):
		16	(WebCore::CSSStyleSelector::languageTagToScriptCode):
		17	(WebCore::LanguageScript::if):
		18	(WebCore::LanguageScript::while):
		19	* css/CSSStyleSelector.h:
		20	* dom/Document.cpp:
		21	(WebCore::Document::Document):
		22	(WebCore::Document::dominantScript):
		23	(WebCore::Document::encodingToScriptCode):
		24	(WebCore::EncodingScript::if):
		25	* dom/Document.h:
		26	* page/Settings.cpp:
		27	(WebCore::getGenericFontFamilyForScript):
		28	* platform/graphics/FontDescription.h:
		29	(WebCore::FontDescription::FontDescription):
		30	(WebCore::FontDescription::script):
		31	(WebCore::FontDescription::setScript):
		32	(WebCore::FontDescription::operator==):
		33	* rendering/InlineTextBox.cpp:
		34	(WebCore::paintTextWithShadows):
		35
1	2011-06-23 Zhenyao Mo <zmo@google.com>	36	2011-06-23 Zhenyao Mo <zmo@google.com>
2		37
3	Reviewed by Kenneth Russell.	38	Reviewed by Kenneth Russell.

Lines 389-406 static FontData* fontDataForGenericFamily(Document* document, const FontDescript a/Source/WebCore/css/CSSFontSelector.cpp_sec1
- a/Source/WebCore/css/CSSFontSelector.cpp -6 / +10 lines
389	return 0;	389	return 0;
390		390
391	AtomicString genericFamily;	391	AtomicString genericFamily;
		392	UScriptCode script = fontDescription.script();
392	if (familyName == "-webkit-serif")	393	if (familyName == "-webkit-serif")
393	genericFamily = settings->serifFontFamily();	394	genericFamily = settings->serifFontFamily(script);
394	else if (familyName == "-webkit-sans-serif")	395	else if (familyName == "-webkit-sans-serif")
395	genericFamily = settings->sansSerifFontFamily();	396	genericFamily = settings->sansSerifFontFamily(script);
396	else if (familyName == "-webkit-cursive")	397	else if (familyName == "-webkit-cursive")
397	genericFamily = settings->cursiveFontFamily();	398	genericFamily = settings->cursiveFontFamily(script);
398	else if (familyName == "-webkit-fantasy")	399	else if (familyName == "-webkit-fantasy")
399	genericFamily = settings->fantasyFontFamily();	400	genericFamily = settings->fantasyFontFamily(script);
400	else if (familyName == "-webkit-monospace")	401	else if (familyName == "-webkit-monospace")
401	genericFamily = settings->fixedFontFamily();	402	genericFamily = settings->fixedFontFamily(script);
402	else if (familyName == "-webkit-standard")	403	else if (familyName == "-webkit-standard")
403	genericFamily = settings->standardFontFamily();	404	genericFamily = settings->standardFontFamily(script);
404		405
405	if (!genericFamily.isEmpty())	406	if (!genericFamily.isEmpty())
406	return fontCache()->getCachedFontData(fontDescription, genericFamily);	407	return fontCache()->getCachedFontData(fontDescription, genericFamily);
Lines 495-500 FontData* CSSFontSelector::getFontData(const FontDescription& fontDescription, c a/Source/WebCore/css/CSSFontSelector.cpp_sec2
495	if (m_fontFaces.isEmpty()) {	496	if (m_fontFaces.isEmpty()) {
496	if (familyName.startsWith("-webkit-"))	497	if (familyName.startsWith("-webkit-"))
497	return fontDataForGenericFamily(m_document, fontDescription, familyName);	498	return fontDataForGenericFamily(m_document, fontDescription, familyName);
		499	// USCRIPT_COMMON would resolve to "Times" but for some reason "Lucida Grande" is expected.
		500	if (!fontDescription.isSpecifiedFont() && fontDescription.script() != USCRIPT_COMMON)
		501	return fontDataForGenericFamily(m_document, fontDescription, "-webkit-standard");
498	return 0;	502	return 0;
499	}	503	}
500		504

Lines 82-87 public: a/Source/WebCore/platform/graphics/FontDescription.h_sec1
- a/Source/WebCore/platform/graphics/FontDescription.h -1 / +6 lines
82	, m_fontSmoothing(AutoSmoothing)	82	, m_fontSmoothing(AutoSmoothing)
83	, m_textRendering(AutoTextRendering)	83	, m_textRendering(AutoTextRendering)
84	, m_isSpecifiedFont(false)	84	, m_isSpecifiedFont(false)
		85	, m_script(USCRIPT_COMMON)
85	{	86	{
86	}	87	}
87		88
Lines 107-112 public: a/Source/WebCore/platform/graphics/FontDescription.h_sec2
107	unsigned keywordSize() const { return m_keywordSize; }	108	unsigned keywordSize() const { return m_keywordSize; }
108	FontSmoothingMode fontSmoothing() const { return static_cast<FontSmoothingMode>(m_fontSmoothing); }	109	FontSmoothingMode fontSmoothing() const { return static_cast<FontSmoothingMode>(m_fontSmoothing); }
109	TextRenderingMode textRenderingMode() const { return static_cast<TextRenderingMode>(m_textRendering); }	110	TextRenderingMode textRenderingMode() const { return static_cast<TextRenderingMode>(m_textRendering); }
		111	UScriptCode script() const { return m_script; }
110		112
111	FontTraitsMask traitsMask() const;	113	FontTraitsMask traitsMask() const;
112	bool isSpecifiedFont() const { return m_isSpecifiedFont; }	114	bool isSpecifiedFont() const { return m_isSpecifiedFont; }
Lines 137-142 public: a/Source/WebCore/platform/graphics/FontDescription.h_sec3
137	void setOrientation(FontOrientation orientation) { m_orientation = orientation; }	139	void setOrientation(FontOrientation orientation) { m_orientation = orientation; }
138	void setTextOrientation(TextOrientation textOrientation) { m_textOrientation = textOrientation; }	140	void setTextOrientation(TextOrientation textOrientation) { m_textOrientation = textOrientation; }
139	void setWidthVariant(FontWidthVariant widthVariant) { m_widthVariant = widthVariant; }	141	void setWidthVariant(FontWidthVariant widthVariant) { m_widthVariant = widthVariant; }
		142	void setScript(UScriptCode s) { m_script = s; }
140		143
141	private:	144	private:
142	FontFamily m_familyList; // The list of font families to be used.	145	FontFamily m_familyList; // The list of font families to be used.
Lines 167-172 private: a/Source/WebCore/platform/graphics/FontDescription.h_sec4
167	unsigned m_fontSmoothing : 2; // FontSmoothingMode	170	unsigned m_fontSmoothing : 2; // FontSmoothingMode
168	unsigned m_textRendering : 2; // TextRenderingMode	171	unsigned m_textRendering : 2; // TextRenderingMode
169	bool m_isSpecifiedFont : 1; // True if a web page specifies a non-generic font family as the first font family.	172	bool m_isSpecifiedFont : 1; // True if a web page specifies a non-generic font family as the first font family.
		173	UScriptCode m_script; // The script of the text, used to choose an appropriate font for the generic font family.
170	};	174	};
171		175
172	inline bool FontDescription::operator==(const FontDescription& other) const	176	inline bool FontDescription::operator==(const FontDescription& other) const
Lines 187-193 inline bool FontDescription::operator==(const FontDescription& other) const a/Source/WebCore/platform/graphics/FontDescription.h_sec5
187	&& m_isSpecifiedFont == other.m_isSpecifiedFont	191	&& m_isSpecifiedFont == other.m_isSpecifiedFont
188	&& m_orientation == other.m_orientation	192	&& m_orientation == other.m_orientation
189	&& m_textOrientation == other.m_textOrientation	193	&& m_textOrientation == other.m_textOrientation
190	&& m_widthVariant == other.m_widthVariant;	194	&& m_widthVariant == other.m_widthVariant
		195	&& m_script == other.m_script;
191	}	196	}
192		197
193	}	198	}

Lines 1-3 a/Source/WebKit/chromium/ChangeLog_sec1
- a/Source/WebKit/chromium/ChangeLog +13 lines
		1	2011-06-24 Matt Falkenhagen <falken@chromium.org>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	lang, xml:lang, content-language ignored when choosing fonts
		6	https://bugs.webkit.org/show_bug.cgi?id=10874
		7
		8	* src/WebSettingsImpl.cpp:
		9	(WebKit::WebSettingsImpl::setStandardFontFamily):
		10	(WebKit::WebSettingsImpl::setFixedFontFamily):
		11	(WebKit::WebSettingsImpl::setSerifFontFamily):
		12	(WebKit::WebSettingsImpl::setSansSerifFontFamily):
		13
1	2011-06-23 John Bates <jbates@google.com>	14	2011-06-23 John Bates <jbates@google.com>
2		15
3	Reviewed by James Robinson.	16	Reviewed by James Robinson.

Lines 1-3 a/Source/WebKit/mac/ChangeLog_sec1
- a/Source/WebKit/mac/ChangeLog +10 lines
		1	2011-06-24 Matt Falkenhagen <falken@chromium.org>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	lang, xml:lang, content-language ignored when choosing fonts
		6	https://bugs.webkit.org/show_bug.cgi?id=10874
		7
		8	* WebView/WebView.mm:
		9	(-[WebView _preferencesChanged:]):
		10
1	2011-06-22 Sam Weinig <sam@webkit.org>	11	2011-06-22 Sam Weinig <sam@webkit.org>
2		12
3	Roll out r89469 (Add preference for setting the html parser depth limit)	13	Roll out r89469 (Add preference for setting the html parser depth limit)