Roll out dominantScript, getGenericFontForScript patches to unfork a bunch of...

third_party/WebKit/WebCore/css/CSSStyleSelector.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 34 matching lines @@
 #include "CSSStyleSheet.h"
 #include "CSSTimingFunctionValue.h"
 #include "CSSValueList.h"
 #include "CSSVariableDependentValue.h"
 #include "CSSVariablesDeclaration.h"
 #include "CSSVariablesRule.h"
 #include "CachedImage.h"
 #include "Counter.h"
 #include "CounterContent.h"
 #include "FocusController.h"
-#include "FontCache.h"
 #include "FontFamilyValue.h"
 #include "FontValue.h"
 #include "Frame.h"
 #include "FrameView.h"
 #include "HTMLDocument.h"
 #include "HTMLElement.h"
 #include "HTMLInputElement.h"
 #include "HTMLNames.h"
 #include "HTMLTextAreaElement.h"
 #include "LinkHash.h"
@@ skipping 2742 matching lines @@
             if (directives.m_increment)
                 directives.m_incrementValue += value;
             else {
                 directives.m_increment = true;
                 directives.m_incrementValue = value;
             }
         }
     }
 }
 
-struct ScriptFamilyState {
-  bool isGenericAdded;
-  bool isPerScriptGenericChecked;
-  ScriptFamilyState() : isGenericAdded(false), isPerScriptGenericChecked(false)
-  {}
-};
-
-inline static void handleScriptFamily(const char* webkitFamily, UScriptCode script,
-                                      FontDescription::GenericFamilyType generic,
-                                      AtomicString& face, ScriptFamilyState& state,                                       FontDescription& fontDescription,
-                                      int& familyIndex)
-{
-    if (!state.isGenericAdded) {
-        face = webkitFamily;
-        state.isGenericAdded = true;
-        fontDescription.setGenericFamily(generic);
-        // go through this once more to add per-script generic family.
-        --familyIndex;
-    } else if (!state.isPerScriptGenericChecked) {
-        face = FontCache::getGenericFontForScript(script, fontDescription);
-        state.isPerScriptGenericChecked = true;
-    }
-}
-
 void CSSStyleSelector::applyPropertyToStyle(int id, CSSValue *value, RenderStyle* style)
 {
     initElementAndPseudoState(0);
     initForStyleResolve(0, style);
     m_style = style;
     applyProperty(id, value);
 }
 
 void CSSStyleSelector::applyProperty(int id, CSSValue *value)
 {
@@ skipping 1252 matching lines @@
         FontDescription fontDescription = m_style->fontDescription();
         CSSValueList *list = static_cast<CSSValueList*>(value);
         int len = list->length();
         FontFamily& firstFamily = fontDescription.firstFamily();
         FontFamily *currFamily = 0;
         
         // Before mapping in a new font-family property, we should reset the generic family.
         bool oldFamilyIsMonospace = fontDescription.genericFamily() == FontDescription::MonospaceFamily;
         fontDescription.setGenericFamily(FontDescription::NoFamily);
 
-        // |script| is used to add a font per script and per CSS generic family. 
-        // Adding it here is not very efficient because we may never use it 
-        // if all the characters are covered by fonts specified for this element.
-        // TODO(jungshik): Currently, it's document-wide constant inferred from
-        // the document charset, but we should infer it from the value of 
-        // xml:lang or lang for |m_element|.
-        UScriptCode script = m_checker.m_document->dominantScript();
-        // serif, sans-serif, cursive, fantasy, monospace
-        ScriptFamilyState scriptFamilyStates[5]; 
-        Settings* settings = m_checker.m_document->settings();
         for (int i = 0; i < len; i++) {
             CSSValue *item = list->itemWithoutBoundsCheck(i);
             if (!item->isPrimitiveValue()) continue;
             CSSPrimitiveValue *val = static_cast<CSSPrimitiveValue*>(item);
             AtomicString face;
+            Settings* settings = m_checker.m_document->settings();
             if (val->primitiveType() == CSSPrimitiveValue::CSS_STRING)
                 face = static_cast<FontFamilyValue*>(val)->familyName();
             else if (val->primitiveType() == CSSPrimitiveValue::CSS_IDENT && settings) {
                 switch (val->getIdent()) {
                     case CSSValueWebkitBody:
                         face = settings->standardFontFamily();
                         break;
-                    // For each of 5 CSS generic families,
-                    // we add '-webkit-FOO' and a per-script generic family.
-                    // When |Settings| becomes expressive enough to support
-                    // per-script&per-generic family and we have a UI for
-                    // that, we'd just add the latter. Even without that,
-                    // I'm tempted to add per-script generic first, but I can't.
-                    // If I did, our font-selection UI would be all but
-                    // non-functional. Another issue is that we're adding 
-                    // these fonts without regard for actual need in page
-                    // rendering. That is, it's not done in a lazy manner.
-                    // Somewhere in getGlyphDataForCharacter() could be
-                    // a better place in terms of performance.
-                    // See https://bugs.webkit.org/show_bug.cgi?id=18085
-                    // and http://bugs.webkit.org/show_bug.cgi?id=10874
                     case CSSValueSerif:
-                        handleScriptFamily("-webkit-serif", script,
-                             FontDescription::SerifFamily, face,
-                             scriptFamilyStates[0], fontDescription, i);
+                        face = "-webkit-serif";
+                        fontDescription.setGenericFamily(FontDescription::SerifFamily);
                         break;
                     case CSSValueSansSerif:
-                        handleScriptFamily("-webkit-sans-serif", script,
-                             FontDescription::SansSerifFamily, face,
-                             scriptFamilyStates[1], fontDescription, i);
+                        face = "-webkit-sans-serif";
+                        fontDescription.setGenericFamily(FontDescription::SansSerifFamily);
                         break;
                     case CSSValueCursive:
-                        handleScriptFamily("-webkit-cursive", script,
-                             FontDescription::CursiveFamily, face,
-                             scriptFamilyStates[2], fontDescription, i);
+                        face = "-webkit-cursive";
+                        fontDescription.setGenericFamily(FontDescription::CursiveFamily);
                         break;
                     case CSSValueFantasy:
-                        handleScriptFamily("-webkit-fantasy", script,
-                             FontDescription::FantasyFamily, face,
-                             scriptFamilyStates[3], fontDescription, i);
+                        face = "-webkit-fantasy";
+                        fontDescription.setGenericFamily(FontDescription::FantasyFamily);
                         break;
                     case CSSValueMonospace:
-                        handleScriptFamily("-webkit-monospace", script,
-                             FontDescription::MonospaceFamily, face,
-                             scriptFamilyStates[4], fontDescription, i);
+                        face = "-webkit-monospace";
+                        fontDescription.setGenericFamily(FontDescription::MonospaceFamily);
                         break;
                 }
             }
     
             if (!face.isEmpty()) {
                 if (!currFamily) {
                     // Filling in the first family.
                     firstFamily.setFamily(face);
                     currFamily = &firstFamily;
                 }
                 else {
                     RefPtr<SharedFontFamily> newFamily = SharedFontFamily::create();
                     newFamily->setFamily(face);
                     currFamily->appendFamily(newFamily);
                     currFamily = newFamily.get();
                 }
     
                 if (fontDescription.keywordSize() && (fontDescription.genericFamily() == FontDescription::MonospaceFamily) != oldFamilyIsMonospace)
                     setFontSize(fontDescription, fontSizeForKeyword(CSSValueXxSmall + fontDescription.keywordSize() - 1, m_style->htmlHacks(), !oldFamilyIsMonospace));
             
                 if (m_style->setFontDescription(fontDescription))
                     m_fontDirty = true;
             }
         }
-
-        if (fontDescription.genericFamily() == FontDescription::NoFamily && currFamily) {
-            FontDescription::GenericFamilyType generic;
-            // TODO(jungshik) : Perhaps, we'd better add isStandardSerif()
-            // method to |Settings| which will be set via WebPreference.
-            if (settings) {
-                if (settings->serifFontFamily() == settings->standardFontFamily())
-                    generic = FontDescription::SerifFamily ;
-                else 
-                    generic = FontDescription::SansSerifFamily;
-            } else
-              generic = FontDescription::StandardFamily; 
-            fontDescription.setGenericFamily(generic);
-            AtomicString face = FontCache::getGenericFontForScript(script, fontDescription);
-            if (!face.isEmpty()) {
-                RefPtr<SharedFontFamily> newFamily = SharedFontFamily::create();
-                newFamily->setFamily(face);
-                currFamily->appendFamily(newFamily);
-                currFamily = newFamily.get();
-                if (m_style->setFontDescription(fontDescription))
-                    m_fontDirty = true;
-            }
-        }
       return;
     }
     case CSSPropertyTextDecoration: {
         // list of ident
         HANDLE_INHERIT_AND_INITIAL(textDecoration, TextDecoration)
         int t = RenderStyle::initialTextDecoration();
         if (primitiveValue && primitiveValue->getIdent() == CSSValueNone) {
             // do nothing
         } else {
             if (!value->isValueList()) return;
@@ skipping 205 matching lines @@
             setFontSize(fontDescription, fontSizeForKeyword(CSSValueMedium, m_style->htmlHacks(), false));
             m_style->setLineHeight(RenderStyle::initialLineHeight());
             m_lineHeightValue = 0;
             if (m_style->setFontDescription(fontDescription))
                 m_fontDirty = true;
         } else if (primitiveValue) {
             m_style->setLineHeight(RenderStyle::initialLineHeight());
             m_lineHeightValue = 0;
             
             FontDescription fontDescription;
-            theme()->systemFont(primitiveValue->getIdent(), m_checker.m_document, fontDescription);
+            theme()->systemFont(primitiveValue->getIdent(), fontDescription);
  
             // Double-check and see if the theme did anything.  If not, don't bother updating the font.
             if (fontDescription.isAbsoluteSize()) {
                 // Make sure the rendering mode and printer font settings are updated.
                 Settings* settings = m_checker.m_document->settings();
                 ASSERT(settings); // If we're doing style resolution, this document should always be in a frame and thus have settings
                 if (!settings)
                     return;
                 fontDescription.setRenderingMode(settings->fontRenderingMode());
                 fontDescription.setUsePrinterFont(m_checker.m_document->printing());
@@ skipping 1759 matching lines @@
                     ASSERT_NOT_REACHED();
                     break;
             }
         }
     }
     outOperations = operations;
     return true;
 }
 
 } // namespace WebCore