Remove RenderStyle member from FontBuilder.

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 24 matching lines @@
 
 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->m_style->fontDescription())
+        , m_fontDescription(fontBuilder->fontDescription())
     {
     }
 
-    void reset() { m_fontDescription = FontDescription(); }
-    void set(const FontDescription& fontDescription) { m_fontDescription = fontDescription; }
-    FontDescription& fontDescription() { return m_fontDescription; }
-
     ~FontDescriptionChangeScope()
     {
-        m_fontBuilder->didChangeFontParameters(m_fontBuilder->m_style->setFontDescription(m_fontDescription));
+        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_style(nullptr)
     , m_fontDirty(false)
 {
     ASSERT(document.frame());
 }
 
 void FontBuilder::setInitial(float effectiveZoom)
 {
     ASSERT(m_document.settings());
     if (!m_document.settings())
         return;
 
     FontDescriptionChangeScope scope(this);
 
-    scope.reset();
-    setFamilyDescription(scope.fontDescription(), FontBuilder::initialFamilyDescription());
-    setSize(scope.fontDescription(), FontBuilder::initialSize());
+    m_fontDescription = FontDescription();
+    setFamilyDescription(m_fontDescription, FontBuilder::initialFamilyDescription());
+    setSize(m_fontDescription, FontBuilder::initialSize());
 }
 
 void FontBuilder::inheritFrom(const FontDescription& fontDescription)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.set(fontDescription);
+    m_fontDescription = fontDescription;
 }
 
 void FontBuilder::didChangeFontParameters(bool changed)
 {
     m_fontDirty |= changed;
 }
 
 FontFamily FontBuilder::standardFontFamily() const
 {
     FontFamily family;
@@ skipping 30 matching lines @@
         return FontFamilyNames::webkit_fantasy;
     case FontDescription::PictographFamily:
         return FontFamilyNames::webkit_pictograph;
     }
 }
 
 void FontBuilder::setFamilyDescription(const FontDescription::FamilyDescription& familyDescription)
 {
     FontDescriptionChangeScope scope(this);
 
-    setFamilyDescription(scope.fontDescription(), familyDescription);
+    setFamilyDescription(m_fontDescription, familyDescription);
 }
 
 void FontBuilder::setWeight(FontWeight fontWeight)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setWeight(fontWeight);
+    m_fontDescription.setWeight(fontWeight);
 }
 
 void FontBuilder::setSize(const FontDescription::Size& size)
 {
     FontDescriptionChangeScope scope(this);
 
-    setSize(scope.fontDescription(), size);
+    setSize(m_fontDescription, size);
 }
 
 void FontBuilder::setStretch(FontStretch fontStretch)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setStretch(fontStretch);
+    m_fontDescription.setStretch(fontStretch);
 }
 
 void FontBuilder::setScript(const String& locale)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setLocale(locale);
-    scope.fontDescription().setScript(localeToScriptCodeForFontSelection(locale));
+    m_fontDescription.setLocale(locale);
+    m_fontDescription.setScript(localeToScriptCodeForFontSelection(locale));
 }
 
 void FontBuilder::setStyle(FontStyle italic)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setStyle(italic);
+    m_fontDescription.setStyle(italic);
 }
 
 void FontBuilder::setVariant(FontVariant smallCaps)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setVariant(smallCaps);
+    m_fontDescription.setVariant(smallCaps);
 }
 
 void FontBuilder::setVariantLigatures(const FontDescription::VariantLigatures& ligatures)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setVariantLigatures(ligatures);
+    m_fontDescription.setVariantLigatures(ligatures);
 }
 
 void FontBuilder::setTextRendering(TextRenderingMode textRenderingMode)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setTextRendering(textRenderingMode);
+    m_fontDescription.setTextRendering(textRenderingMode);
 }
 
 void FontBuilder::setKerning(FontDescription::Kerning kerning)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setKerning(kerning);
+    m_fontDescription.setKerning(kerning);
 }
 
 void FontBuilder::setFontSmoothing(FontSmoothingMode foontSmoothingMode)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setFontSmoothing(foontSmoothingMode);
+    m_fontDescription.setFontSmoothing(foontSmoothingMode);
 }
 
 void FontBuilder::setFeatureSettings(PassRefPtr<FontFeatureSettings> settings)
 {
     FontDescriptionChangeScope scope(this);
 
-    scope.fontDescription().setFeatureSettings(settings);
+    m_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);
@@ skipping 71 matching lines @@
 }
 
 void FontBuilder::checkForOrientationChange(RenderStyle* style)
 {
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(style, fontOrientation, glyphOrientation);
 
     FontDescriptionChangeScope scope(this);
 
-    if (scope.fontDescription().orientation() == fontOrientation && scope.fontDescription().nonCJKGlyphOrientation() == glyphOrientation)
+    if (m_fontDescription.orientation() == fontOrientation && m_fontDescription.nonCJKGlyphOrientation() == glyphOrientation)
         return;
 
-    scope.fontDescription().setNonCJKGlyphOrientation(glyphOrientation);
-    scope.fontDescription().setOrientation(fontOrientation);
+    m_fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
+    m_fontDescription.setOrientation(fontOrientation);
 }
 
 void FontBuilder::checkForGenericFamilyChange(RenderStyle* style, const RenderStyle* parentStyle)
 {
     FontDescriptionChangeScope scope(this);
 
-    if (scope.fontDescription().isAbsoluteSize() || !parentStyle)
+    if (m_fontDescription.isAbsoluteSize() || !parentStyle)
         return;
 
     const FontDescription& parentFontDescription = parentStyle->fontDescription();
-    if (scope.fontDescription().fixedPitchFontType() == parentFontDescription.fixedPitchFontType())
+    if (m_fontDescription.fixedPitchFontType() == parentFontDescription.fixedPitchFontType())
         return;
 
     // For now, lump all families but monospace together.
-    if (scope.fontDescription().genericFamily() != FontDescription::MonospaceFamily
+    if (m_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, scope.fontDescription().keywordSize(), scope.fontDescription().fixedPitchFontType());
+    if (m_fontDescription.keywordSize()) {
+        size = FontSize::fontSizeForKeyword(&m_document, m_fontDescription.keywordSize(), m_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;
+            m_fontDescription.specifiedSize() / fixedScaleFactor :
+            m_fontDescription.specifiedSize() * fixedScaleFactor;
     }
 
-    scope.fontDescription().setSpecifiedSize(size);
-    updateComputedSize(scope.fontDescription(), style);
+    m_fontDescription.setSpecifiedSize(size);
+    updateComputedSize(m_fontDescription, style);
 }
 
 void FontBuilder::updateComputedSize(RenderStyle* style, const RenderStyle* parentStyle)
 {
     FontDescriptionChangeScope scope(this);
-    updateComputedSize(scope.fontDescription(), style);
+    updateComputedSize(m_fontDescription, style);
 }
 
 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);
 }
 
-// FIXME: style param should come first
-void FontBuilder::createFont(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, const RenderStyle* parentStyle, RenderStyle* style)
+void FontBuilder::createFont(PassRefPtrWillBeRawPtr<FontSelector> fontSelector, RenderStyle* style, const RenderStyle* parentStyle)
 {
     if (!m_fontDirty)
         return;
 
     updateComputedSize(style, parentStyle);
     checkForGenericFamilyChange(style, parentStyle);
     checkForOrientationChange(style);
+    style->setFontDescription(m_fontDescription);
     style->font().update(fontSelector);
     m_fontDirty = false;
 }
 
 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));
     updateComputedSize(fontDescription, documentStyle);
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }