Make style building for 'font-size' 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/css/FontSize.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/rendering/RenderTheme.h"
 #include "core/rendering/RenderView.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
@@ skipping 16 matching lines @@
         m_fontBuilder->didChangeFontParameters(m_fontBuilder->m_style->setFontDescription(m_fontDescription));
     }
 
 private:
     RawPtrWillBeMember<FontBuilder> m_fontBuilder;
     FontDescription m_fontDescription;
 };
 
 FontBuilder::FontBuilder()
     : m_document(nullptr)
-    , m_fontSizehasViewportUnits(false)
     , m_style(0)
     , m_fontDirty(false)
 {
 }
 
 void FontBuilder::initForStyleResolve(const Document& document, RenderStyle* style)
 {
     ASSERT(document.frame());
     m_document = &document;
     m_style = style;
@@ skipping 18 matching lines @@
 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);
-    scope.fontDescription().setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
-    setSize(scope.fontDescription(), effectiveZoom, FontSize::fontSizeForKeyword(m_document, CSSValueMedium, NonFixedPitchFont));
+    setSize(scope.fontDescription(), FontBuilder::initialSize());
 }
 
 void FontBuilder::inheritFrom(const FontDescription& fontDescription)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.set(fontDescription);
 }
 
 void FontBuilder::didChangeFontParameters(bool changed)
@@ skipping 109 matching lines @@
                 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) {
-        scope.fontDescription().setSpecifiedSize(FontSize::fontSizeForKeyword(m_document,
-        static_cast<CSSValueID>(CSSValueXxSmall + scope.fontDescription().keywordSize() - 1), scope.fontDescription().fixedPitchFontType()));
-    }
-}
-
-void FontBuilder::setFontSizeInitial()
-{
-    FontDescriptionChangeScope scope(this);
-
-    float size = FontSize::fontSizeForKeyword(m_document, CSSValueMedium, scope.fontDescription().fixedPitchFontType());
-
-    if (size < 0)
-        return;
-
-    scope.fontDescription().setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
-    scope.fontDescription().setSpecifiedSize(size);
-}
-
-void FontBuilder::setFontSizeInherit(const FontDescription& parentFontDescription)
-{
-    FontDescriptionChangeScope scope(this);
-
-    float size = parentFontDescription.specifiedSize();
-
-    if (size < 0)
-        return;
-
-    scope.fontDescription().setKeywordSize(parentFontDescription.keywordSize());
-    scope.fontDescription().setSpecifiedSize(size);
-}
-
-// FIXME: Figure out where we fall in the size ranges (xx-small to xxx-large)
-// and scale down/up to the next size level.
-static float largerFontSize(float size)
-{
-    return size * 1.2f;
-}
-
-static float smallerFontSize(float size)
-{
-    return size / 1.2f;
-}
-
-// FIXME: Have to pass RenderStyles here for calc/computed values. This shouldn't be neecessary.
-void FontBuilder::setFontSizeValue(CSSValue* value, RenderStyle* parentStyle, const RenderStyle* rootElementStyle)
-{
-    if (!value->isPrimitiveValue())
-        return;
-
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-
-    FontDescriptionChangeScope scope(this);
-
-    scope.fontDescription().setKeywordSize(0);
-    float parentSize = 0;
-    bool parentIsAbsoluteSize = false;
-    float size = 0;
-
-    // FIXME: Find out when parentStyle could be 0?
-    if (parentStyle) {
-        parentSize = parentStyle->fontDescription().specifiedSize();
-        parentIsAbsoluteSize = parentStyle->fontDescription().isAbsoluteSize();
-    }
-
-    if (CSSValueID valueID = primitiveValue->getValueID()) {
-        switch (valueID) {
-        case CSSValueXxSmall:
-        case CSSValueXSmall:
-        case CSSValueSmall:
-        case CSSValueMedium:
-        case CSSValueLarge:
-        case CSSValueXLarge:
-        case CSSValueXxLarge:
-        case CSSValueWebkitXxxLarge:
-            size = FontSize::fontSizeForKeyword(m_document, valueID, scope.fontDescription().fixedPitchFontType());
-            scope.fontDescription().setKeywordSize(valueID - CSSValueXxSmall + 1);
-            break;
-        case CSSValueLarger:
-            size = largerFontSize(parentSize);
-            break;
-        case CSSValueSmaller:
-            size = smallerFontSize(parentSize);
-            break;
-        default:
-            return;
-        }
-
-        scope.fontDescription().setIsAbsoluteSize(parentIsAbsoluteSize && (valueID == CSSValueLarger || valueID == CSSValueSmaller));
-    } else {
-        scope.fontDescription().setIsAbsoluteSize(parentIsAbsoluteSize || !(primitiveValue->isPercentage() || primitiveValue->isFontRelativeLength()));
-        if (primitiveValue->isPercentage()) {
-            size = (primitiveValue->getFloatValue() * parentSize) / 100.0f;
-        } else {
-            // If we have viewport units the conversion will mark the parent style as having viewport units.
-            bool parentHasViewportUnits = parentStyle->hasViewportUnits();
-            parentStyle->setHasViewportUnits(false);
-            CSSToLengthConversionData conversionData(parentStyle, rootElementStyle, m_document->renderView(), 1.0f, true);
-            if (primitiveValue->isLength())
-                size = primitiveValue->computeLength<float>(conversionData);
-            else if (primitiveValue->isCalculatedPercentageWithLength())
-                size = primitiveValue->cssCalcValue()->toCalcValue(conversionData)->evaluate(parentSize);
-            else
-                ASSERT_NOT_REACHED();
-            m_fontSizehasViewportUnits = parentStyle->hasViewportUnits();
-            parentStyle->setHasViewportUnits(parentHasViewportUnits);
-        }
-    }
-
-    if (size < 0)
-        return;
-
-    // Overly large font sizes will cause crashes on some platforms (such as Windows).
-    // Cap font size here to make sure that doesn't happen.
-    size = std::min(maximumAllowedFontSize, size);
-
-
-    scope.fontDescription().setSpecifiedSize(size);
+    if (scope.fontDescription().keywordSize() && scope.fontDescription().fixedPitchFontType() != oldFixedPitchFontType)
+        setSize(scope.fontDescription(), FontDescription::Size(scope.fontDescription().keywordSize(), 0.0f, false));
 }
 
 void FontBuilder::setWeight(FontWeight fontWeight)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.fontDescription().setWeight(fontWeight);
 }
 
+void FontBuilder::setSize(const FontDescription::Size& size)
+{
+    FontDescriptionChangeScope scope(this);
+
+    setSize(scope.fontDescription(), size);
+}
+
 void FontBuilder::setStretch(FontStretch fontStretch)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.fontDescription().setStretch(fontStretch);
 }
 
 void FontBuilder::setScript(const String& locale)
 {
     FontDescriptionChangeScope scope(this);
@@ skipping 44 matching lines @@
     scope.fontDescription().setFontSmoothing(foontSmoothingMode);
 }
 
 void FontBuilder::setFeatureSettings(PassRefPtr<FontFeatureSettings> settings)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.fontDescription().setFeatureSettings(settings);
 }
 
-void FontBuilder::setSize(FontDescription& fontDescription, float effectiveZoom, float size)
+void FontBuilder::setSize(FontDescription& fontDescription, const FontDescription::Size& size)
 {
-    fontDescription.setSpecifiedSize(size);
-    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, effectiveZoom, size));
+    float specifiedSize = size.value;
+
+    if (!specifiedSize && size.keyword)
+        specifiedSize = FontSize::fontSizeForKeyword(m_document, size.keyword, fontDescription.fixedPitchFontType());
+
+    if (specifiedSize < 0)
+        return;
+
+    // Overly large font sizes will cause crashes on some platforms (such as Windows).
+    // Cap font size here to make sure that doesn't happen.
+    specifiedSize = std::min(maximumAllowedFontSize, specifiedSize);
+
+    fontDescription.setKeywordSize(size.keyword);
+    fontDescription.setSpecifiedSize(specifiedSize);
+    fontDescription.setIsAbsoluteSize(size.isAbsolute);
 }
 
 float FontBuilder::getComputedSizeFromSpecifiedSize(FontDescription& fontDescription, float effectiveZoom, float specifiedSize)
 {
     float zoomFactor = effectiveZoom;
     // FIXME: Why is this here!!!!?!
     if (LocalFrame* frame = m_document->frame())
         zoomFactor *= frame->textZoomFactor();
 
     return FontSize::getComputedSizeFromSpecifiedSize(m_document, zoomFactor, fontDescription.isAbsoluteSize(), specifiedSize);
@@ skipping 68 matching lines @@
     if (scope.fontDescription().genericFamily() != FontDescription::MonospaceFamily
         && parentFontDescription.genericFamily() != FontDescription::MonospaceFamily)
         return;
 
     // We know the parent is monospace or the child is monospace, and that font
     // size was unspecified. We want to scale our font size as appropriate.
     // If the font uses a keyword size, then we refetch from the table rather than
     // multiplying by our scale factor.
     float size;
     if (scope.fontDescription().keywordSize()) {
-        size = FontSize::fontSizeForKeyword(m_document, static_cast<CSSValueID>(CSSValueXxSmall + scope.fontDescription().keywordSize() - 1), scope.fontDescription().fixedPitchFontType());
+        size = FontSize::fontSizeForKeyword(m_document, scope.fontDescription().keywordSize(), scope.fontDescription().fixedPitchFontType());
     } else {
         Settings* settings = m_document->settings();
         float fixedScaleFactor = (settings && settings->defaultFixedFontSize() && settings->defaultFontSize())
             ? static_cast<float>(settings->defaultFixedFontSize()) / settings->defaultFontSize()
             : 1;
         size = parentFontDescription.fixedPitchFontType() == FixedPitchFont ?
             scope.fontDescription().specifiedSize() / fixedScaleFactor :
             scope.fontDescription().specifiedSize() * fixedScaleFactor;
     }
 
-    setSize(scope.fontDescription(), style->effectiveZoom(), size);
+    scope.fontDescription().setSpecifiedSize(size);
+    updateComputedSize(scope.fontDescription(), style->effectiveZoom());
 }
 
-void FontBuilder::updateComputedSize(RenderStyle* style, const RenderStyle* parentStyle)
+void FontBuilder::updateComputedSize(RenderStyle* style)
 {
     FontDescriptionChangeScope scope(this);
+    updateComputedSize(scope.fontDescription(), style->effectiveZoom());
+}
 
-    scope.fontDescription().setComputedSize(getComputedSizeFromSpecifiedSize(scope.fontDescription(), style->effectiveZoom(), scope.fontDescription().specifiedSize()));
+void FontBuilder::updateComputedSize(FontDescription& fontDescription, float effectiveZoom)
+{
+    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, effectiveZoom, fontDescription.specifiedSize()));
 }
 
 // FIXME: style param should come first
 void FontBuilder::createFont(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, const RenderStyle* parentStyle, RenderStyle* style)
 {
     if (!m_fontDirty)
         return;
 
     updateComputedSize(style, parentStyle);
     checkForGenericFamilyChange(style, parentStyle);
     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);
-    fontDescription.setKeywordSize(CSSValueMedium - CSSValueXxSmall + 1);
-    int size = FontSize::fontSizeForKeyword(m_document, CSSValueMedium, NonFixedPitchFont);
-    fontDescription.setSpecifiedSize(size);
-    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, documentStyle->effectiveZoom(), size));
+
+    setSize(fontDescription, FontDescription::Size(FontSize::initialKeywordSize(), 0.0f, false));
+    updateComputedSize(fontDescription, documentStyle->effectiveZoom());
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }