Remove zoom() and effectiveZoom().

sky/engine/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 73 matching lines @@
     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)
+void FontBuilder::setInitial()
 {
     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(), FontSize::fontSizeForKeyword(m_document, CSSValueMedium, NonFixedPitchFont));
 }
 
 void FontBuilder::inheritFrom(const FontDescription& fontDescription)
 {
     FontDescriptionChangeScope scope(this);
 
     scope.set(fontDescription);
 }
 
 void FontBuilder::didChangeFontParameters(bool changed)
 {
     m_fontDirty |= changed;
 }
 
-void FontBuilder::fromSystemFont(CSSValueID valueId, float effectiveZoom)
+void FontBuilder::fromSystemFont(CSSValueID valueId)
 {
     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();
     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()));
+    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, fontDescription.specifiedSize()));
     scope.set(fontDescription);
 }
 
 void FontBuilder::setFontFamilyInitial()
 {
     FontDescriptionChangeScope scope(this);
 
     setFontFamilyToStandard(scope.fontDescription(), m_document);
 }
 
@@ skipping 173 matching lines @@
 
         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);
+            CSSToLengthConversionData conversionData(parentStyle, rootElementStyle, m_document->renderView(), 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);
         }
     }
@@ skipping 73 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, float size)
 {
     fontDescription.setSpecifiedSize(size);
-    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, effectiveZoom, size));
+    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, size));
 }
 
-float FontBuilder::getComputedSizeFromSpecifiedSize(FontDescription& fontDescription, float effectiveZoom, float specifiedSize)
+float FontBuilder::getComputedSizeFromSpecifiedSize(FontDescription& fontDescription, 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);
+    return FontSize::getComputedSizeFromSpecifiedSize(m_document, fontDescription.isAbsoluteSize(), specifiedSize);
 }
 
 static void getFontAndGlyphOrientation(const RenderStyle* style, FontOrientation& fontOrientation, NonCJKGlyphOrientation& glyphOrientation)
 {
     // FIXME(sky): Remove this function now that we don't have writing modes.
     fontOrientation = Horizontal;
     glyphOrientation = NonCJKGlyphOrientationVerticalRight;
 }
 
 void FontBuilder::checkForOrientationChange(RenderStyle* style)
@@ skipping 37 matching lines @@
     } 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);
+    setSize(scope.fontDescription(), size);
 }
 
 void FontBuilder::updateComputedSize(RenderStyle* style, const RenderStyle* parentStyle)
 {
     FontDescriptionChangeScope scope(this);
 
-    float computedSize = getComputedSizeFromSpecifiedSize(scope.fontDescription(), style->effectiveZoom(), scope.fontDescription().specifiedSize());
+    float computedSize = getComputedSizeFromSpecifiedSize(scope.fontDescription(), scope.fontDescription().specifiedSize());
     scope.fontDescription().setComputedSize(computedSize);
 }
 
 // FIXME: style param should come first
 void FontBuilder::createFont(PassRefPtr<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(PassRefPtr<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));
+    fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(fontDescription, size));
 
     FontOrientation fontOrientation;
     NonCJKGlyphOrientation glyphOrientation;
     getFontAndGlyphOrientation(documentStyle, fontOrientation, glyphOrientation);
     fontDescription.setOrientation(fontOrientation);
     fontDescription.setNonCJKGlyphOrientation(glyphOrientation);
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(fontSelector);
 }
 
 }