Remove FontDescriptionChangeScope, and let FontBuilder partially apply values.

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.
  *
@@ skipping 17 matching lines @@
 #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:
-    FontDescriptionChangeScope(FontBuilder* fontBuilder)
-        : m_fontBuilder(fontBuilder)
-        , m_fontDescription(fontBuilder->fontDescription())
-    {
-    }
-
-    ~FontDescriptionChangeScope()
-    {
-        if (m_fontBuilder->fontDirty())
-            return;
-        m_fontBuilder->didChangeFontParameters(m_fontBuilder->fontDescription() != m_fontDescription);
-    }
-
-private:
-    RawPtrWillBeMember<FontBuilder> m_fontBuilder;
-    FontDescription m_fontDescription;
-};
-
 FontBuilder::FontBuilder(const Document& document)
     : m_document(document)
-    , m_fontDirty(false)
+    , m_flags(0)
 {
     ASSERT(document.frame());
 }
 
 void FontBuilder::setInitial(float effectiveZoom)
 {
     ASSERT(m_document.settings());
     if (!m_document.settings())
         return;
 
-    FontDescriptionChangeScope scope(this);
-
-    m_fontDescription = FontDescription();
     setFamilyDescription(m_fontDescription, FontBuilder::initialFamilyDescription());
     setSize(m_fontDescription, FontBuilder::initialSize());
 }
 
-void FontBuilder::inheritFrom(const FontDescription& fontDescription)
+void FontBuilder::didChangeEffectiveZoom(bool changed)
 {
-    FontDescriptionChangeScope scope(this);
-
-    m_fontDescription = fontDescription;
+    if (changed)
+        set(IsSetFlag::EffectiveZoom);
 }
 
-void FontBuilder::didChangeFontParameters(bool changed)
+void FontBuilder::didChangeTextOrientation(bool changed)
 {
-    m_fontDirty |= changed;
+    if (changed)
+        set(IsSetFlag::TextOrientation);
+}
+
+void FontBuilder::didChangeWritingMode(bool changed)
+{
+    if (changed)
+        set(IsSetFlag::WritingMode);
 }
 
 FontFamily FontBuilder::standardFontFamily() const
 {
     FontFamily family;
     family.setFamily(standardFontFamilyName());
     return family;
 }
 
 AtomicString FontBuilder::standardFontFamilyName() const
@@ skipping 23 matching lines @@
         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);
-
     setFamilyDescription(m_fontDescription, familyDescription);
 }
 
 void FontBuilder::setWeight(FontWeight fontWeight)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::Weight);
 
     m_fontDescription.setWeight(fontWeight);
 }
 
 void FontBuilder::setSize(const FontDescription::Size& size)
 {
-    FontDescriptionChangeScope scope(this);
-
     setSize(m_fontDescription, size);
 }
 
 void FontBuilder::setStretch(FontStretch fontStretch)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::Stretch);
 
     m_fontDescription.setStretch(fontStretch);
 }
 
 void FontBuilder::setScript(const String& locale)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::Script);
 
     m_fontDescription.setLocale(locale);
     m_fontDescription.setScript(localeToScriptCodeForFontSelection(locale));
 }
 
 void FontBuilder::setStyle(FontStyle italic)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::Style);
 
     m_fontDescription.setStyle(italic);
 }
 
 void FontBuilder::setVariant(FontVariant smallCaps)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::Variant);
 
     m_fontDescription.setVariant(smallCaps);
 }
 
 void FontBuilder::setVariantLigatures(const FontDescription::VariantLigatures& ligatures)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::VariantLigatures);
 
     m_fontDescription.setVariantLigatures(ligatures);
 }
 
 void FontBuilder::setTextRendering(TextRenderingMode textRenderingMode)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::TextRendering);
 
     m_fontDescription.setTextRendering(textRenderingMode);
 }
 
 void FontBuilder::setKerning(FontDescription::Kerning kerning)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::Kerning);
 
     m_fontDescription.setKerning(kerning);
 }
 
 void FontBuilder::setFontSmoothing(FontSmoothingMode foontSmoothingMode)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::FontSmoothing);
 
     m_fontDescription.setFontSmoothing(foontSmoothingMode);
 }
 
 void FontBuilder::setFeatureSettings(PassRefPtr<FontFeatureSettings> settings)
 {
-    FontDescriptionChangeScope scope(this);
+    set(IsSetFlag::FeatureSettings);
 
     m_fontDescription.setFeatureSettings(settings);
 }
 
 void FontBuilder::setFamilyDescription(FontDescription& fontDescription, const FontDescription::FamilyDescription& familyDescription)
 {
-    FixedPitchFontType oldFixedPitchFontType = fontDescription.fixedPitchFontType();
+    set(IsSetFlag::Family);
 
     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;
 
+    set(IsSetFlag::Size);
+
     // 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)
@@ skipping 38 matching lines @@
         glyphOrientation = NonCJKGlyphOrientationVerticalRight;
         return;
     default:
         ASSERT_NOT_REACHED();
         fontOrientation = Horizontal;
         glyphOrientation = NonCJKGlyphOrientationVerticalRight;
         return;
     }
 }
 
-void FontBuilder::checkForOrientationChange(RenderStyle* style)
+void FontBuilder::updateOrientation(FontDescription& description, RenderStyle* style)
 {
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(style, fontOrientation, glyphOrientation);
 
-    FontDescriptionChangeScope scope(this);
+    description.setNonCJKGlyphOrientation(glyphOrientation);
+    description.setOrientation(fontOrientation);
+}
 
-    if (m_fontDescription.orientation() == fontOrientation && m_fontDescription.nonCJKGlyphOrientation() == glyphOrientation)
+void FontBuilder::checkForGenericFamilyChange(const FontDescription& oldDescription, FontDescription& newDescription)
+{
+    if (newDescription.isAbsoluteSize())
         return;
 
-    m_fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
-    m_fontDescription.setOrientation(fontOrientation);
-}
-
-void FontBuilder::checkForGenericFamilyChange(RenderStyle* style, const RenderStyle* parentStyle)
-{
-    FontDescriptionChangeScope scope(this);
-
-    if (m_fontDescription.isAbsoluteSize() || !parentStyle)
-        return;
-
-    const FontDescription& parentFontDescription = parentStyle->fontDescription();
-    if (m_fontDescription.fixedPitchFontType() == parentFontDescription.fixedPitchFontType())
+    if (newDescription.fixedPitchFontType() == oldDescription.fixedPitchFontType())
         return;
 
     // For now, lump all families but monospace together.
-    if (m_fontDescription.genericFamily() != FontDescription::MonospaceFamily
-        && parentFontDescription.genericFamily() != FontDescription::MonospaceFamily)
+    if (newDescription.genericFamily() != FontDescription::MonospaceFamily
+        && oldDescription.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 (m_fontDescription.keywordSize()) {
-        size = FontSize::fontSizeForKeyword(&m_document, m_fontDescription.keywordSize(), m_fontDescription.fixedPitchFontType());
+    if (newDescription.keywordSize()) {
+        size = FontSize::fontSizeForKeyword(&m_document, newDescription.keywordSize(), newDescription.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 ?
-            m_fontDescription.specifiedSize() / fixedScaleFactor :
-            m_fontDescription.specifiedSize() * fixedScaleFactor;
+        size = oldDescription.fixedPitchFontType() == FixedPitchFont ?
+            newDescription.specifiedSize() / fixedScaleFactor :
+            newDescription.specifiedSize() * fixedScaleFactor;
     }
 
-    m_fontDescription.setSpecifiedSize(size);
-    updateComputedSize(m_fontDescription, style);
+    newDescription.setSpecifiedSize(size);
 }
 
-void FontBuilder::updateComputedSize(RenderStyle* style, const RenderStyle* parentStyle)
+void FontBuilder::updateSpecifiedSize(FontDescription& fontDescription, RenderStyle* style)
 {
-    FontDescriptionChangeScope scope(this);
-    updateComputedSize(m_fontDescription, style);
+    float specifiedSize = fontDescription.specifiedSize();
+
+    if (!specifiedSize && fontDescription.keywordSize())
+        specifiedSize = FontSize::fontSizeForKeyword(&m_document, fontDescription.keywordSize(), fontDescription.fixedPitchFontType());
+
+    fontDescription.setSpecifiedSize(specifiedSize);
+
+    checkForGenericFamilyChange(style->fontDescription(), fontDescription);
 }
 
 void FontBuilder::updateComputedSize(FontDescription& fontDescription, RenderStyle* style)
 {
     float computedSize = getComputedSizeFromSpecifiedSize(fontDescription, style->effectiveZoom(), fontDescription.specifiedSize());
     float multiplier = style->textAutosizingMultiplier();
     if (multiplier > 1)
         computedSize = TextAutosizer::computeAutosizedFontSize(computedSize, multiplier);
     fontDescription.setComputedSize(computedSize);
 }
 
-void FontBuilder::createFont(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, RenderStyle* style, const RenderStyle* parentStyle)
+void FontBuilder::createFont(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, RenderStyle* style)
 {
-    if (!m_fontDirty)
+    if (!m_flags)
         return;
 
-    updateComputedSize(style, parentStyle);
-    checkForGenericFamilyChange(style, parentStyle);
-    checkForOrientationChange(style);
-    style->setFontDescription(m_fontDescription);
+    FontDescription description = style->fontDescription();
+
+    if (isSet(IsSetFlag::Family)) {

[andersr, 2014/12/18 13:01:59]

Note: I've verified with a microbenchmark that all these 'if' statements do not
degrade font building performance measurably. (Actually, it increased slightly).

+        description.setGenericFamily(m_fontDescription.genericFamily());
+        description.setFamily(m_fontDescription.family());
+    }
+    if (isSet(IsSetFlag::Size)) {
+        description.setKeywordSize(m_fontDescription.keywordSize());
+        description.setSpecifiedSize(m_fontDescription.specifiedSize());
+        description.setIsAbsoluteSize(m_fontDescription.isAbsoluteSize());
+    }
+    if (isSet(IsSetFlag::Weight))
+        description.setWeight(m_fontDescription.weight());
+    if (isSet(IsSetFlag::Stretch))
+        description.setStretch(m_fontDescription.stretch());
+    if (isSet(IsSetFlag::FeatureSettings))
+        description.setFeatureSettings(m_fontDescription.featureSettings());
+    if (isSet(IsSetFlag::Script)) {
+        description.setLocale(m_fontDescription.locale());
+        description.setScript(m_fontDescription.script());
+    }
+    if (isSet(IsSetFlag::Style))
+        description.setStyle(m_fontDescription.style());
+    if (isSet(IsSetFlag::Variant))
+        description.setVariant(m_fontDescription.variant());
+    if (isSet(IsSetFlag::VariantLigatures))
+        description.setVariantLigatures(m_fontDescription.variantLigatures());
+    if (isSet(IsSetFlag::TextRendering))
+        description.setTextRendering(m_fontDescription.textRendering());
+    if (isSet(IsSetFlag::Kerning))
+        description.setKerning(m_fontDescription.kerning());
+    if (isSet(IsSetFlag::FontSmoothing))
+        description.setFontSmoothing(m_fontDescription.fontSmoothing());
+    if (isSet(IsSetFlag::TextOrientation) || isSet(IsSetFlag::WritingMode))
+        updateOrientation(description, style);
+
+    updateSpecifiedSize(description, style);
+    updateComputedSize(description, style);
+
+    style->setFontDescription(description);
     style->font().update(fontSelector);
-    m_fontDirty = false;
+    m_flags = 0;
 }
 
 void FontBuilder::createFontForDocument(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, RenderStyle* documentStyle)
 {
     FontDescription fontDescription = FontDescription();
     fontDescription.setLocale(documentStyle->locale());
     fontDescription.setScript(localeToScriptCodeForFontSelection(documentStyle->locale()));
 
     setFamilyDescription(fontDescription, FontBuilder::initialFamilyDescription());
     setSize(fontDescription, FontDescription::Size(FontSize::initialKeywordSize(), 0.0f, false));
+    updateSpecifiedSize(fontDescription, documentStyle);
     updateComputedSize(fontDescription, documentStyle);
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }