Revert of Evacuate ComputedStyle references from the CSS*Value hierarchy

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 69 matching lines @@
 
 inline static CSSPrimitiveValue* zoomAdjustedNumberValue(double value, const ComputedStyle& style)
 {
     return CSSPrimitiveValue::create(value / style.effectiveZoom(), CSSPrimitiveValue::UnitType::Number);
 }
 
 static CSSPrimitiveValue* zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
 {
     if (length.isFixed())
         return zoomAdjustedPixelValue(length.value(), style);
-    return CSSPrimitiveValue::create(length, style.effectiveZoom());
+    return CSSPrimitiveValue::create(length, style);
 }
 
 static CSSPrimitiveValue* pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
 {
     const Length& length = unzoomedLength.length();
     if (length.isFixed())
         return CSSPrimitiveValue::create(length.value(), CSSPrimitiveValue::UnitType::Pixels);
-    return CSSPrimitiveValue::create(length, style.effectiveZoom());
+    return CSSPrimitiveValue::create(length, style);
 }
 
 static CSSValueList* createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
 {
     CSSValueList* positionList = CSSValueList::createSpaceSeparated();
     if (layer.isBackgroundXOriginSet()) {
         ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
         positionList->append(*CSSPrimitiveValue::create(layer.backgroundXOrigin()));
     }
     positionList->append(*zoomAdjustedPixelValueForLength(layer.xPosition(), style));
@@ skipping 197 matching lines @@
                     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());
 }
 
-static CSSPrimitiveValue* valueForBorderImageLength(const BorderImageLength& borderImageLength, const ComputedStyle& style)
-{
-    if (borderImageLength.isNumber())
-        return CSSPrimitiveValue::create(borderImageLength.number(), CSSPrimitiveValue::UnitType::Number);
-    return CSSPrimitiveValue::create(borderImageLength.length(), style.effectiveZoom());
-}
-
 static CSSQuadValue* valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
 {
     // Create the slices.
     CSSPrimitiveValue* top = nullptr;
     CSSPrimitiveValue* right = nullptr;
     CSSPrimitiveValue* bottom = nullptr;
     CSSPrimitiveValue* left = nullptr;
 
-    top = valueForBorderImageLength(box.top(), style);
+    if (box.top().isNumber())
+        top = CSSPrimitiveValue::create(box.top().number(), CSSPrimitiveValue::UnitType::Number);
+    else
+        top = CSSPrimitiveValue::create(box.top().length(), style);
 
     if (box.right() == box.top() && box.bottom() == box.top() && box.left() == box.top()) {
         right = top;
         bottom = top;
         left = top;
     } else {
-        right = valueForBorderImageLength(box.right(), style);
+        if (box.right().isNumber())
+            right = CSSPrimitiveValue::create(box.right().number(), CSSPrimitiveValue::UnitType::Number);
+        else
+            right = CSSPrimitiveValue::create(box.right().length(), style);
 
         if (box.bottom() == box.top() && box.right() == box.left()) {
             bottom = top;
             left = right;
         } else {
-            bottom = valueForBorderImageLength(box.bottom(), style);
+            if (box.bottom().isNumber())
+                bottom = CSSPrimitiveValue::create(box.bottom().number(), CSSPrimitiveValue::UnitType::Number);
+            else
+                bottom = CSSPrimitiveValue::create(box.bottom().length(), style);
 
-            if (box.left() == box.right())
+            if (box.left() == box.right()) {
                 left = right;
-            else
-                left = valueForBorderImageLength(box.left(), style);
+            } else {
+                if (box.left().isNumber())
+                    left = CSSPrimitiveValue::create(box.left().number(), CSSPrimitiveValue::UnitType::Number);
+                else
+                    left = CSSPrimitiveValue::create(box.left().length(), style);
+            }
         }
     }
+
     return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad);
 }
 
 static CSSValueID valueForRepeatRule(int rule)
 {
     switch (rule) {
     case RepeatImageRule:
         return CSSValueRepeat;
     case RoundImageRule:
         return CSSValueRound;
@@ skipping 2283 matching lines @@
         return valueForCounterDirectives(style, propertyID);
     case CSSPropertyClipPath:
         if (ClipPathOperation* operation = style.clipPath()) {
             if (operation->type() == ClipPathOperation::SHAPE)
                 return valueForBasicShape(style, toShapeClipPathOperation(operation)->basicShape());
             if (operation->type() == ClipPathOperation::REFERENCE)
                 return CSSURIValue::create(toReferenceClipPathOperation(operation)->url());
         }
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyShapeMargin:
-        return CSSPrimitiveValue::create(style.shapeMargin(), style.effectiveZoom());
+        return CSSPrimitiveValue::create(style.shapeMargin(), style);
     case CSSPropertyShapeImageThreshold:
         return CSSPrimitiveValue::create(style.shapeImageThreshold(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyShapeOutside:
         return valueForShape(style, style.shapeOutside());
     case CSSPropertyFilter:
         return valueForFilter(style, style.filter());
     case CSSPropertyBackdropFilter:
         return valueForFilter(style, style.backdropFilter());
     case CSSPropertyMixBlendMode:
         return CSSPrimitiveValue::create(style.blendMode());
@@ skipping 343 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 } // namespace blink