Make style building for 'font-family' less custom.

Source/core/css/resolver/FontBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/css/resolver/FontBuilder.h"
 
-#include "core/css/CSSCalculationValue.h"
-#include "core/css/CSSToLengthConversionData.h"
+#include "core/CSSValueKeywords.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/rendering/RenderTheme.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/TextAutosizer.h"
+#include "platform/FontFamilyNames.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/text/LocaleToScriptMapping.h"
 
 namespace blink {
 
 // FIXME: This scoping class is a short-term fix to minimize the changes in
 // Font-constructing logic.
 class FontDescriptionChangeScope {
     STACK_ALLOCATED();
 public:
@@ skipping 25 matching lines @@
 }
 
 void FontBuilder::initForStyleResolve(const Document& document, RenderStyle* style)
 {
     ASSERT(document.frame());
     m_document = &document;
     m_style = style;
     m_fontDirty = false;
 }
 
-inline static void setFontFamilyToStandard(FontDescription& fontDescription, const Document* document)
-{
-    if (!document || !document->settings())
-        return;
-
-    fontDescription.setGenericFamily(FontDescription::StandardFamily);
-    const AtomicString& standardFontFamily = document->settings()->genericFontFamilySettings().standard();
-    if (standardFontFamily.isEmpty())
-        return;
-
-    fontDescription.firstFamily().setFamily(standardFontFamily);
-    // FIXME: Why is this needed here?
-    fontDescription.firstFamily().appendFamily(nullptr);
-}
-
 void FontBuilder::setInitial(float effectiveZoom)
 {
     ASSERT(m_document && m_document->settings());
     if (!m_document || !m_document->settings())
         return;
 
     FontDescriptionChangeScope scope(this);
 
     scope.reset();
-    setFontFamilyToStandard(scope.fontDescription(), m_document);
+    setFamilyDescription(scope.fontDescription(), FontBuilder::initialFamilyDescription());
     setSize(scope.fontDescription(), FontBuilder::initialSize());
 }
 
 void FontBuilder::inheritFrom(const FontDescription& fontDescription)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.set(fontDescription);
 }
 
@@ skipping 17 matching lines @@
     const Settings* settings = 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;
 
     // Handle the zoom factor.
     fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, effectiveZoom, fontDescription.specifiedSize()));
     scope.set(fontDescription);
 }
 
-void FontBuilder::setFontFamilyInitial()
+FontFamily FontBuilder::standardFontFamily() const
+{
+    FontFamily family;
+    family.setFamily(standardFontFamilyName());
+    return family;
+}
+
+AtomicString FontBuilder::standardFontFamilyName() const
+{
+    ASSERT(m_document);
+    Settings* settings = m_document->settings();
+    if (settings)
+        return settings->genericFontFamilySettings().standard();
+    return AtomicString();
+}
+
+AtomicString FontBuilder::genericFontFamilyName(FontDescription::GenericFamilyType genericFamily) const

[dglazkov, 2014/09/26 17:52:52]

AWESOME!!

+{
+    switch (genericFamily) {
+    default:
+        ASSERT_NOT_REACHED();
+    case FontDescription::NoFamily:
+        return AtomicString();
+    case FontDescription::StandardFamily:
+        return standardFontFamilyName();
+    case FontDescription::SerifFamily:
+        return FontFamilyNames::webkit_serif;
+    case FontDescription::SansSerifFamily:
+        return FontFamilyNames::webkit_sans_serif;
+    case FontDescription::MonospaceFamily:
+        return FontFamilyNames::webkit_monospace;
+    case FontDescription::CursiveFamily:
+        return FontFamilyNames::webkit_cursive;
+    case FontDescription::FantasyFamily:
+        return FontFamilyNames::webkit_fantasy;
+    case FontDescription::PictographFamily:
+        return FontFamilyNames::webkit_pictograph;
+    }
+}
+
+void FontBuilder::setFamilyDescription(const FontDescription::FamilyDescription& familyDescription)
 {
     FontDescriptionChangeScope scope(this);
 
-    setFontFamilyToStandard(scope.fontDescription(), m_document);
-}
-
-void FontBuilder::setFontFamilyInherit(const FontDescription& parentFontDescription)
-{
-    FontDescriptionChangeScope scope(this);
-
-    scope.fontDescription().setGenericFamily(parentFontDescription.genericFamily());
-    scope.fontDescription().setFamily(parentFontDescription.family());
-}
-
-// FIXME: I am not convinced FontBuilder needs to know anything about CSSValues.
-void FontBuilder::setFontFamilyValue(CSSValue* value)
-{
-    FontDescriptionChangeScope scope(this);
-
-    if (!value->isValueList())
-        return;
-
-    FontFamily& firstFamily = scope.fontDescription().firstFamily();
-    FontFamily* currFamily = 0;
-
-    // Before mapping in a new font-family property, we should reset the generic family.
-    FixedPitchFontType oldFixedPitchFontType = scope.fontDescription().fixedPitchFontType();
-    scope.fontDescription().setGenericFamily(FontDescription::NoFamily);
-
-    for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
-        CSSValue* item = i.value();
-        if (!item->isPrimitiveValue())
-            continue;
-        CSSPrimitiveValue* contentValue = toCSSPrimitiveValue(item);
-        AtomicString face;
-        Settings* settings = m_document->settings();
-        if (contentValue->isString()) {
-            face = AtomicString(contentValue->getStringValue());
-        } else if (settings) {
-            switch (contentValue->getValueID()) {
-            case CSSValueWebkitBody:
-                face = settings->genericFontFamilySettings().standard();
-                break;
-            case CSSValueSerif:
-                face = FontFamilyNames::webkit_serif;
-                scope.fontDescription().setGenericFamily(FontDescription::SerifFamily);
-                break;
-            case CSSValueSansSerif:
-                face = FontFamilyNames::webkit_sans_serif;
-                scope.fontDescription().setGenericFamily(FontDescription::SansSerifFamily);
-                break;
-            case CSSValueCursive:
-                face = FontFamilyNames::webkit_cursive;
-                scope.fontDescription().setGenericFamily(FontDescription::CursiveFamily);
-                break;
-            case CSSValueFantasy:
-                face = FontFamilyNames::webkit_fantasy;
-                scope.fontDescription().setGenericFamily(FontDescription::FantasyFamily);
-                break;
-            case CSSValueMonospace:
-                face = FontFamilyNames::webkit_monospace;
-                scope.fontDescription().setGenericFamily(FontDescription::MonospaceFamily);
-                break;
-            case CSSValueWebkitPictograph:
-                face = FontFamilyNames::webkit_pictograph;
-                scope.fontDescription().setGenericFamily(FontDescription::PictographFamily);
-                break;
-            default:
-                break;
-            }
-        }
-
-        if (!face.isEmpty()) {
-            if (!currFamily) {
-                // Filling in the first family.
-                firstFamily.setFamily(face);
-                firstFamily.appendFamily(nullptr); // Remove any inherited family-fallback list.
-                currFamily = &firstFamily;
-            } else {
-                RefPtr<SharedFontFamily> newFamily = SharedFontFamily::create();
-                newFamily->setFamily(face);
-                currFamily->appendFamily(newFamily);
-                currFamily = newFamily.get();
-            }
-        }
-    }
-
-    // We can't call useFixedDefaultSize() until all new font families have been added
-    // If currFamily is non-zero then we set at least one family on this description.
-    if (!currFamily)
-        return;
-
-    if (scope.fontDescription().keywordSize() && scope.fontDescription().fixedPitchFontType() != oldFixedPitchFontType)
-        setSize(scope.fontDescription(), FontDescription::Size(scope.fontDescription().keywordSize(), 0.0f, false));
+    setFamilyDescription(scope.fontDescription(), familyDescription);
 }
 
 void FontBuilder::setWeight(FontWeight fontWeight)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.fontDescription().setWeight(fontWeight);
 }
 
 void FontBuilder::setSize(const FontDescription::Size& size)
@@ skipping 60 matching lines @@
     scope.fontDescription().setFontSmoothing(foontSmoothingMode);
 }
 
 void FontBuilder::setFeatureSettings(PassRefPtr<FontFeatureSettings> settings)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.fontDescription().setFeatureSettings(settings);
 }
 
+void FontBuilder::setFamilyDescription(FontDescription& fontDescription, const FontDescription::FamilyDescription& familyDescription)
+{
+    FixedPitchFontType oldFixedPitchFontType = fontDescription.fixedPitchFontType();
+
+    bool isInitial = familyDescription.genericFamily == FontDescription::StandardFamily && familyDescription.family.familyIsEmpty();
+
+    fontDescription.setGenericFamily(familyDescription.genericFamily);
+    fontDescription.setFamily(isInitial ? standardFontFamily() : familyDescription.family);
+
+    if (fontDescription.keywordSize() && fontDescription.fixedPitchFontType() != oldFixedPitchFontType)
+        setSize(fontDescription, FontDescription::Size(fontDescription.keywordSize(), 0.0f, false));
+}
+
 void FontBuilder::setSize(FontDescription& fontDescription, const FontDescription::Size& size)
 {
     float specifiedSize = size.value;
 
     if (!specifiedSize && size.keyword)
         specifiedSize = FontSize::fontSizeForKeyword(m_document, size.keyword, fontDescription.fixedPitchFontType());
 
     if (specifiedSize < 0)
         return;
 
@@ skipping 133 matching lines @@
     checkForOrientationChange(style);
     style->font().update(fontSelector);
     m_fontDirty = false;
 }
 
 void FontBuilder::createFontForDocument(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, RenderStyle* documentStyle)
 {
     FontDescription fontDescription = FontDescription();
     fontDescription.setScript(localeToScriptCodeForFontSelection(documentStyle->locale()));
 
-    setFontFamilyToStandard(fontDescription, m_document);
-
+    setFamilyDescription(fontDescription, FontBuilder::initialFamilyDescription());
     setSize(fontDescription, FontDescription::Size(FontSize::initialKeywordSize(), 0.0f, false));
     updateComputedSize(fontDescription, documentStyle);
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }