Add Length::isPercent and use it in tables.

third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 173 matching lines @@
         opposite = style.bottom();
         break;
     case CSSPropertyBottom:
         offset = style.bottom();
         opposite = style.top();
         break;
     default:
         return nullptr;
     }
 
-    if (offset.hasPercent() && layoutObject && layoutObject->isBox() && layoutObject->isPositioned()) {
+    if (offset.isPercentOrCalc() && layoutObject && layoutObject->isBox() && layoutObject->isPositioned()) {
         LayoutUnit containingBlockSize = (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
             toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent() :
             toLayoutBox(layoutObject)->containingBlockLogicalHeightForGetComputedStyle();
         return zoomAdjustedPixelValue(valueForLength(offset, containingBlockSize), style);
     }
 
     if (offset.isAuto() && layoutObject) {
         // If the property applies to a positioned element and the resolved value of the display
         // property is not none, the resolved value is the used value.
         if (layoutObject->isInFlowPositioned()) {
             // If e.g. left is auto and right is not auto, then left's computed value is negative right.
             // So we get the opposite length unit and see if it is auto.
             if (opposite.isAuto())
                 return CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Pixels);
 
-            if (opposite.hasPercent() || opposite.isCalculated()) {
+            if (opposite.isPercentOrCalc() || opposite.isCalculated()) {
                 if (layoutObject->isBox()) {
                     LayoutUnit containingBlockSize =
                         (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
                         toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent() :
                         toLayoutBox(layoutObject)->containingBlockLogicalHeightForGetComputedStyle();
                     return zoomAdjustedPixelValue(-floatValueForLength(opposite, containingBlockSize), style);
                 }
                 // FIXME:  fall back to auto for position:relative, display:inline
                 return CSSPrimitiveValue::createIdentifier(CSSValueAuto);
             }
@@ skipping 45 matching lines @@
 
 static CSSBorderImageSliceValue* valueForNinePieceImageSlice(const NinePieceImage& image)
 {
     // Create the slices.
     CSSPrimitiveValue* top = nullptr;
     CSSPrimitiveValue* right = nullptr;
     CSSPrimitiveValue* bottom = nullptr;
     CSSPrimitiveValue* left = nullptr;
 
     // TODO(alancutter): Make this code aware of calc lengths.
-    if (image.imageSlices().top().hasPercent())
+    if (image.imageSlices().top().isPercentOrCalc())
         top = CSSPrimitiveValue::create(image.imageSlices().top().value(), CSSPrimitiveValue::UnitType::Percentage);
     else
         top = CSSPrimitiveValue::create(image.imageSlices().top().value(), CSSPrimitiveValue::UnitType::Number);
 
     if (image.imageSlices().right() == image.imageSlices().top() && image.imageSlices().bottom() == image.imageSlices().top()
         && image.imageSlices().left() == image.imageSlices().top()) {
         right = top;
         bottom = top;
         left = top;
     } else {
-        if (image.imageSlices().right().hasPercent())
+        if (image.imageSlices().right().isPercentOrCalc())
             right = CSSPrimitiveValue::create(image.imageSlices().right().value(), CSSPrimitiveValue::UnitType::Percentage);
         else
             right = CSSPrimitiveValue::create(image.imageSlices().right().value(), CSSPrimitiveValue::UnitType::Number);
 
         if (image.imageSlices().bottom() == image.imageSlices().top() && image.imageSlices().right() == image.imageSlices().left()) {
             bottom = top;
             left = right;
         } else {
-            if (image.imageSlices().bottom().hasPercent())
+            if (image.imageSlices().bottom().isPercentOrCalc())
                 bottom = CSSPrimitiveValue::create(image.imageSlices().bottom().value(), CSSPrimitiveValue::UnitType::Percentage);
             else
                 bottom = CSSPrimitiveValue::create(image.imageSlices().bottom().value(), CSSPrimitiveValue::UnitType::Number);
 
             if (image.imageSlices().left() == image.imageSlices().right()) {
                 left = right;
             } else {
-                if (image.imageSlices().left().hasPercent())
+                if (image.imageSlices().left().isPercentOrCalc())
                     left = CSSPrimitiveValue::create(image.imageSlices().left().value(), CSSPrimitiveValue::UnitType::Percentage);
                 else
                     left = CSSPrimitiveValue::create(image.imageSlices().left().value(), CSSPrimitiveValue::UnitType::Number);
             }
         }
     }
 
     return CSSBorderImageSliceValue::create(CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad), image.fill());
 }
 
@@ skipping 95 matching lines @@
     return createBorderImageValue(imageValue, imageSlices, borderSlices, outset, repeat);
 }
 
 static CSSValue* valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
 {
     if (!reflection)
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
 
     CSSPrimitiveValue* offset = nullptr;
     // TODO(alancutter): Make this work correctly for calc lengths.
-    if (reflection->offset().hasPercent())
+    if (reflection->offset().isPercentOrCalc())
         offset = CSSPrimitiveValue::create(reflection->offset().percent(), CSSPrimitiveValue::UnitType::Percentage);
     else
         offset = zoomAdjustedPixelValue(reflection->offset().value(), style);
 
     CSSPrimitiveValue* direction = nullptr;
     switch (reflection->direction()) {
     case ReflectionBelow:
         direction = CSSPrimitiveValue::createIdentifier(CSSValueBelow);
         break;
     case ReflectionAbove:
@@ skipping 1644 matching lines @@
         Length marginTop = style.marginTop();
         if (marginTop.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginTop, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginTop(), style);
     }
     case CSSPropertyMarginRight: {
         Length marginRight = style.marginRight();
         if (marginRight.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginRight, style);
         float value;
-        if (marginRight.hasPercent()) {
+        if (marginRight.isPercentOrCalc()) {
             // LayoutBox gives a marginRight() that is the distance between the right-edge of the child box
             // and the right-edge of the containing box, when display == BLOCK. Let's calculate the absolute
             // value of the specified margin-right % instead of relying on LayoutBox's marginRight() value.
             value = minimumValueForLength(marginRight, toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent()).toFloat();
         } else {
             value = toLayoutBox(layoutObject)->marginRight().toFloat();
         }
         return zoomAdjustedPixelValue(value, style);
     }
     case CSSPropertyMarginBottom: {
@@ skipping 911 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink