Eliminate FontBuilder::initForStyleResolve.

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 42 matching lines @@
     ~FontDescriptionChangeScope()
     {
         m_fontBuilder->didChangeFontParameters(m_fontBuilder->m_style->setFontDescription(m_fontDescription));
     }
 
 private:
     RawPtrWillBeMember<FontBuilder> m_fontBuilder;
     FontDescription m_fontDescription;
 };
 
-FontBuilder::FontBuilder()
-    : m_document(nullptr)
-    , m_style(0)
+FontBuilder::FontBuilder(const Document& document)
+    : m_document(document)
+    , m_style(nullptr)
     , m_fontDirty(false)
 {
-}
-
-void FontBuilder::initForStyleResolve(const Document& document, RenderStyle* style)
-{
     ASSERT(document.frame());
-    m_document = &document;
-    m_style = style;
-    m_fontDirty = false;
 }
 
 void FontBuilder::setInitial(float effectiveZoom)
 {
-    ASSERT(m_document && m_document->settings());
-    if (!m_document || !m_document->settings())
+    ASSERT(m_document.settings());
+    if (!m_document.settings())
         return;
 
     FontDescriptionChangeScope scope(this);
 
     scope.reset();
     setFamilyDescription(scope.fontDescription(), FontBuilder::initialFamilyDescription());
     setSize(scope.fontDescription(), FontBuilder::initialSize());
 }
 
 void FontBuilder::inheritFrom(const FontDescription& fontDescription)
@@ skipping 13 matching lines @@
     FontDescriptionChangeScope scope(this);
 
     FontDescription fontDescription;
     RenderTheme::theme().systemFont(valueId, fontDescription);
 
     // Double-check and see if the theme did anything. If not, don't bother updating the font.
     if (!fontDescription.isAbsoluteSize())
         return;
 
     // Make sure the rendering mode and printer font settings are updated.
-    const Settings* settings = m_document->settings();
+    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);
 }
 
 FontFamily FontBuilder::standardFontFamily() const
 {
     FontFamily family;
     family.setFamily(standardFontFamilyName());
     return family;
 }
 
 AtomicString FontBuilder::standardFontFamilyName() const
 {
-    ASSERT(m_document);
-    Settings* settings = m_document->settings();
+    Settings* settings = m_document.settings();
     if (settings)
         return settings->genericFontFamilySettings().standard();
     return AtomicString();
 }
 
 AtomicString FontBuilder::genericFontFamilyName(FontDescription::GenericFamilyType genericFamily) const
 {
     switch (genericFamily) {
     default:
         ASSERT_NOT_REACHED();
@@ skipping 112 matching lines @@
 
     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());
+        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())
+    if (LocalFrame* frame = m_document.frame())
         zoomFactor *= frame->textZoomFactor();
 
-    return FontSize::getComputedSizeFromSpecifiedSize(m_document, zoomFactor, fontDescription.isAbsoluteSize(), specifiedSize);
+    return FontSize::getComputedSizeFromSpecifiedSize(&m_document, zoomFactor, fontDescription.isAbsoluteSize(), specifiedSize);
 }
 
 static void getFontAndGlyphOrientation(const RenderStyle* style, FontOrientation& fontOrientation, NonCJKGlyphOrientation& glyphOrientation)
 {
     if (style->isHorizontalWritingMode()) {
         fontOrientation = Horizontal;
         glyphOrientation = NonCJKGlyphOrientationVerticalRight;
         return;
     }
 
@@ skipping 58 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, scope.fontDescription().keywordSize(), scope.fontDescription().fixedPitchFontType());
+        size = FontSize::fontSizeForKeyword(&m_document, scope.fontDescription().keywordSize(), scope.fontDescription().fixedPitchFontType());
     } else {
-        Settings* settings = m_document->settings();
+        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;
     }
 
     scope.fontDescription().setSpecifiedSize(size);
     updateComputedSize(scope.fontDescription(), style);
@@ skipping 40 matching lines @@
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }