Initial step of removing CSS zoom related properties.

sky/engine/core/rendering/style/RenderStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 486 matching lines @@
     TextAlignLast textAlignLast() const { return static_cast<TextAlignLast>(rareInheritedData->m_textAlignLast); }
     TextJustify textJustify() const { return static_cast<TextJustify>(rareInheritedData->m_textJustify); }
     TextDecoration textDecorationsInEffect() const;
     const Vector<AppliedTextDecoration>& appliedTextDecorations() const;
     TextDecoration textDecoration() const { return static_cast<TextDecoration>(visual->textDecoration); }
     TextUnderlinePosition textUnderlinePosition() const { return static_cast<TextUnderlinePosition>(rareInheritedData->m_textUnderlinePosition); }
     TextDecorationStyle textDecorationStyle() const { return static_cast<TextDecorationStyle>(rareNonInheritedData->m_textDecorationStyle); }
     float wordSpacing() const;
     float letterSpacing() const;
 
-    float zoom() const { return visual->m_zoom; }
-    float effectiveZoom() const { return rareInheritedData->m_effectiveZoom; }
+    // FIXME(sky): Remove
+    float zoom() const { return 1.0f; }
+    float effectiveZoom() const { return 1.0f; }
 
     TextDirection direction() const { return static_cast<TextDirection>(inherited_flags._direction); }
     bool isLeftToRightDirection() const { return direction() == LTR; }
 
     const Length& specifiedLineHeight() const;
     Length lineHeight() const;
     int computedLineHeight() const;
 
     EWhiteSpace whiteSpace() const { return static_cast<EWhiteSpace>(inherited_flags._white_space); }
     static bool autoWrap(EWhiteSpace ws)
@@ skipping 445 matching lines @@
     void setTextAlign(ETextAlign v) { inherited_flags._text_align = v; }
     void setTextAlignLast(TextAlignLast v) { SET_VAR(rareInheritedData, m_textAlignLast, v); }
     void setTextJustify(TextJustify v) { SET_VAR(rareInheritedData, m_textJustify, v); }
     void applyTextDecorations();
     void clearAppliedTextDecorations();
     void setTextDecoration(TextDecoration v) { SET_VAR(visual, textDecoration, v); }
     void setTextUnderlinePosition(TextUnderlinePosition v) { SET_VAR(rareInheritedData, m_textUnderlinePosition, v); }
     void setTextDecorationStyle(TextDecorationStyle v) { SET_VAR(rareNonInheritedData, m_textDecorationStyle, v); }
     void setDirection(TextDirection v) { inherited_flags._direction = v; }
     void setLineHeight(const Length& specifiedLineHeight);
-    bool setZoom(float);
-    bool setEffectiveZoom(float);
 
     void setImageRendering(EImageRendering v) { SET_VAR(rareInheritedData, m_imageRendering, v); }
 
     void setWhiteSpace(EWhiteSpace v) { inherited_flags._white_space = v; }
 
     // FIXME: Remove these two and replace them with respective FontBuilder calls.
     void setWordSpacing(float);
     void setLetterSpacing(float);
 
     void adjustBackgroundLayers()
@@ skipping 300 matching lines @@
     static EVerticalAlign initialVerticalAlign() { return BASELINE; }
     static short initialWidows() { return 2; }
     static short initialOrphans() { return 2; }
     static Length initialLineHeight() { return Length(-100.0, Percent); }
     static ETextAlign initialTextAlign() { return TASTART; }
     static TextAlignLast initialTextAlignLast() { return TextAlignLastAuto; }
     static TextJustify initialTextJustify() { return TextJustifyAuto; }
     static TextDecoration initialTextDecoration() { return TextDecorationNone; }
     static TextUnderlinePosition initialTextUnderlinePosition() { return TextUnderlinePositionAuto; }
     static TextDecorationStyle initialTextDecorationStyle() { return TextDecorationStyleSolid; }
-    static float initialZoom() { return 1.0f; }
     static int initialOutlineOffset() { return 0; }
     static float initialOpacity() { return 1.0f; }
     static EBoxAlignment initialBoxAlign() { return BSTRETCH; }
     static EBoxDecorationBreak initialBoxDecorationBreak() { return DSLICE; }
     static EBoxDirection initialBoxDirection() { return BNORMAL; }
     static EBoxLines initialBoxLines() { return SINGLE; }
     static EBoxOrient initialBoxOrient() { return HORIZONTAL; }
     static EBoxPack initialBoxPack() { return Start; }
     static float initialBoxFlex() { return 0.0f; }
     static unsigned initialBoxFlexGroup() { return 1; }
@@ skipping 130 matching lines @@
     void addAppliedTextDecoration(const AppliedTextDecoration&);
 
     bool diffNeedsFullLayoutAndPaintInvalidation(const RenderStyle& other) const;
     bool diffNeedsFullLayout(const RenderStyle& other) const;
     bool diffNeedsPaintInvalidationLayer(const RenderStyle& other) const;
     bool diffNeedsPaintInvalidationObject(const RenderStyle& other) const;
     bool diffNeedsRecompositeLayer(const RenderStyle& other) const;
     void updatePropertySpecificDifferences(const RenderStyle& other, StyleDifference&) const;
 };
 
-// FIXME: Reduce/remove the dependency on zoom adjusted int values.
-// The float or LayoutUnit versions of layout values should be used.
-inline int adjustForAbsoluteZoom(int value, float zoomFactor)
-{
-    if (zoomFactor == 1)
-        return value;
-    // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
-    float fvalue = value;
-    if (zoomFactor > 1) {
-        if (value < 0)
-            fvalue -= 0.5f;
-        else
-            fvalue += 0.5f;
-    }
-
-    return roundForImpreciseConversion<int>(fvalue / zoomFactor);
-}
-
-inline int adjustForAbsoluteZoom(int value, const RenderStyle* style)
-{
-    return adjustForAbsoluteZoom(value, style->effectiveZoom());
-}
-
-inline float adjustFloatForAbsoluteZoom(float value, const RenderStyle& style)
-{
-    return value / style.effectiveZoom();
-}
-
-inline double adjustDoubleForAbsoluteZoom(double value, const RenderStyle& style)
-{
-    return value / style.effectiveZoom();
-}
-
-inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const RenderStyle& style)
-{
-    return value / style.effectiveZoom();
-}
-
-inline bool RenderStyle::setZoom(float f)
-{
-    if (compareEqual(visual->m_zoom, f))
-        return false;
-    visual.access()->m_zoom = f;
-    setEffectiveZoom(effectiveZoom() * zoom());
-    return true;
-}
-
-inline bool RenderStyle::setEffectiveZoom(float f)
-{
-    if (compareEqual(rareInheritedData->m_effectiveZoom, f))
-        return false;
-    rareInheritedData.access()->m_effectiveZoom = f;
-    return true;
-}
-
 inline bool RenderStyle::isSharable() const
 {
     return !unique();
 }
 
 inline bool RenderStyle::setTextOrientation(TextOrientation textOrientation)
 {
     if (compareEqual(rareInheritedData->m_textOrientation, textOrientation))
         return false;
 
     rareInheritedData.access()->m_textOrientation = textOrientation;
     return true;
 }
 
 float calcBorderRadiiConstraintScaleFor(const FloatRect&, const FloatRoundedRect::Radii&);
 
 } // namespace blink
 
 #endif // RenderStyle_h