Move viewport unit resolution to style recalc time

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 122 matching lines @@
     case CSS_S:
         return CSSPrimitiveValue::UTime;
     case CSS_DEG:
     case CSS_RAD:
     case CSS_GRAD:
     case CSS_TURN:
         return CSSPrimitiveValue::UAngle;
     case CSS_HZ:
     case CSS_KHZ:
         return CSSPrimitiveValue::UFrequency;
-    case CSS_VW:
-    case CSS_VH:
-    case CSS_VMIN:
-    case CSS_VMAX:
-        return CSSPrimitiveValue::UViewportPercentageLength;
     case CSS_DPPX:
     case CSS_DPI:
     case CSS_DPCM:
         return CSSPrimitiveValue::UResolution;
     default:
         return CSSPrimitiveValue::UOther;
     }
 }
 
 bool CSSPrimitiveValue::colorIsDerivedFromElement() const
@@ skipping 121 matching lines @@
     switch (length.type()) {
     case Auto:
     case Intrinsic:
     case MinIntrinsic:
     case MinContent:
     case MaxContent:
     case FillAvailable:
     case FitContent:
     case ExtendToZoom:
     case Percent:
-    case ViewportPercentageWidth:
-    case ViewportPercentageHeight:
-    case ViewportPercentageMin:
-    case ViewportPercentageMax:
         init(length);
         return;
     case Fixed:
         m_primitiveUnitType = CSS_PX;
         m_value.num = length.value() / zoom;
         return;
     case Calculated:
         init(CSSCalcValue::create(length.calculationValue(), zoom));
         return;
+    case DeviceWidth:
+    case DeviceHeight:
     case Undefined:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 void CSSPrimitiveValue::init(const Length& length)
 {
     switch (length.type()) {
         case Auto:
@@ skipping 30 matching lines @@
             break;
         case ExtendToZoom:
             m_primitiveUnitType = CSS_VALUE_ID;
             m_value.valueID = CSSValueInternalExtendToZoom;
             break;
         case Percent:
             m_primitiveUnitType = CSS_PERCENTAGE;
             ASSERT(std::isfinite(length.percent()));
             m_value.num = length.percent();
             break;
-        case ViewportPercentageWidth:
-            m_primitiveUnitType = CSS_VW;
-            m_value.num = length.viewportPercentageLength();
-            break;
-        case ViewportPercentageHeight:
-            m_primitiveUnitType = CSS_VH;
-            m_value.num = length.viewportPercentageLength();
-            break;
-        case ViewportPercentageMin:
-            m_primitiveUnitType = CSS_VMIN;
-            m_value.num = length.viewportPercentageLength();
-            break;
-        case ViewportPercentageMax:
-            m_primitiveUnitType = CSS_VMAX;
-            m_value.num = length.viewportPercentageLength();
-            break;
+        case DeviceWidth:
+        case DeviceHeight:
         case Calculated:
         case Undefined:
             ASSERT_NOT_REACHED();
             break;
     }
 }
 
 void CSSPrimitiveValue::init(PassRefPtr<Counter> c)
 {
     m_primitiveUnitType = CSS_COUNTER;
@@ skipping 215 matching lines @@
             break;
         case CSS_IN:
             factor = cssPixelsPerInch;
             break;
         case CSS_PT:
             factor = cssPixelsPerPoint;
             break;
         case CSS_PC:
             factor = cssPixelsPerPica;
             break;
+        case CSS_VW:
+            factor = conversionData.viewportWidthPercent();
+            break;
+        case CSS_VH:
+            factor = conversionData.viewportHeightPercent();
+            break;
+        case CSS_VMIN:
+            factor = conversionData.viewportMinPercent();
+            break;
+        case CSS_VMAX:
+            factor = conversionData.viewportMaxPercent();
+            break;
         case CSS_CALC_PERCENTAGE_WITH_LENGTH:
         case CSS_CALC_PERCENTAGE_WITH_NUMBER:
             ASSERT_NOT_REACHED();
             return -1.0;
         default:
             ASSERT_NOT_REACHED();
             return -1.0;
     }
 
     // We do not apply the zoom factor when we are computing the value of the font-size property. The zooming
@@ skipping 100 matching lines @@
     case ULength:
         return CSS_PX;
     case UPercent:
         return CSS_UNKNOWN; // Cannot convert between numbers and percent.
     case UTime:
         return CSS_MS;
     case UAngle:
         return CSS_DEG;
     case UFrequency:
         return CSS_HZ;
-    case UViewportPercentageLength:
-        return CSS_UNKNOWN; // Cannot convert between numbers and relative lengths.
     case UResolution:
         return CSS_DPPX;
     default:
         return CSS_UNKNOWN;
     }
 }
 
 bool CSSPrimitiveValue::getDoubleValueInternal(UnitTypes requestedUnitType, double* result) const
 {
     if (!isValidCSSUnitTypeForDoubleConversion(static_cast<UnitTypes>(m_primitiveUnitType)) || !isValidCSSUnitTypeForDoubleConversion(requestedUnitType))
@@ skipping 385 matching lines @@
         return pairValue->hasVariableReference();
     if (Quad* quadValue = getQuadValue())
         return quadValue->hasVariableReference();
     if (Rect* rectValue = getRectValue())
         return rectValue->hasVariableReference();
     if (CSSBasicShape* shapeValue = getShapeValue())
         return shapeValue->hasVariableReference();
     return isVariableName();
 }
 
-Length CSSPrimitiveValue::viewportPercentageLength()
-{
-    ASSERT(isViewportPercentageLength());
-    Length viewportLength;
-    switch (m_primitiveUnitType) {
-    case CSS_VW:
-        viewportLength = Length(getDoubleValue(), ViewportPercentageWidth);
-        break;
-    case CSS_VH:
-        viewportLength = Length(getDoubleValue(), ViewportPercentageHeight);
-        break;
-    case CSS_VMIN:
-        viewportLength = Length(getDoubleValue(), ViewportPercentageMin);
-        break;
-    case CSS_VMAX:
-        viewportLength = Length(getDoubleValue(), ViewportPercentageMax);
-        break;
-    default:
-        break;
-    }
-    return viewportLength;
-}
-
 PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::cloneForCSSOM() const
 {
     RefPtr<CSSPrimitiveValue> result;
 
     switch (m_primitiveUnitType) {
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
     case CSS_COUNTER_NAME:
         result = CSSPrimitiveValue::create(m_value.string, static_cast<UnitTypes>(m_primitiveUnitType));
@@ skipping 137 matching lines @@
         return m_value.parserOperator == other.m_value.parserOperator;
     case CSS_CALC:
         return m_value.calc && other.m_value.calc && m_value.calc->equals(*other.m_value.calc);
     case CSS_SHAPE:
         return m_value.shape && other.m_value.shape && m_value.shape->equals(*other.m_value.shape);
     }
     return false;
 }
 
 } // namespace WebCore