[svg2] Make SVGLength wrap a CSSPrimitiveValue

Source/core/svg/SVGLengthTearOff.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 #include "core/svg/SVGLengthTearOff.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/svg/SVGElement.h"
 
 namespace blink {
 
 namespace {
 
-inline SVGLengthType toSVGLengthType(unsigned short type)
-{
-    ASSERT(type >= LengthTypeUnknown && type <= LengthTypePC);
-    return static_cast<SVGLengthType>(type);
-}
-
 inline bool canResolveRelativeUnits(const SVGElement* contextElement)
 {
     return contextElement && contextElement->inDocument();
 }
 
+inline CSSPrimitiveValue::UnitType toCSSUnitType(unsigned short type)
+{
+    ASSERT(type >= CSSPrimitiveValue::CSS_UNKNOWN && type <= CSSPrimitiveValue::CSS_PC);
+    return static_cast<CSSPrimitiveValue::UnitType>(type);
+}
+
+inline SVGLengthType toSVGLengthType(CSSPrimitiveValue::UnitType type)
+{
+    switch (type) {
+    case CSSPrimitiveValue::UnitType::CSS_UNKNOWN:
+        return LengthTypeUnknown;
+    case CSSPrimitiveValue::UnitType::CSS_NUMBER:
+        return LengthTypeNumber;
+    case CSSPrimitiveValue::UnitType::CSS_PERCENTAGE:
+        return LengthTypePercentage;
+    case CSSPrimitiveValue::UnitType::CSS_EMS:
+        return LengthTypeEMS;
+    case CSSPrimitiveValue::UnitType::CSS_EXS:
+        return LengthTypeEXS;
+    case CSSPrimitiveValue::UnitType::CSS_PX:
+        return LengthTypePX;
+    case CSSPrimitiveValue::UnitType::CSS_CM:
+        return LengthTypeCM;
+    case CSSPrimitiveValue::UnitType::CSS_MM:
+        return LengthTypeMM;
+    case CSSPrimitiveValue::UnitType::CSS_IN:
+        return LengthTypeIN;
+    case CSSPrimitiveValue::UnitType::CSS_PT:
+        return LengthTypePT;
+    case CSSPrimitiveValue::UnitType::CSS_PC:
+        return LengthTypePC;
+    default:
+        return LengthTypeUnknown;
+    }
+}
 } // namespace
 
 SVGLengthType SVGLengthTearOff::unitType()
 {
-    return hasExposedLengthUnit() ? target()->unitType() : LengthTypeUnknown;
+    return hasExposedLengthUnit() ? toSVGLengthType(target()->primitiveType()) : LengthTypeUnknown;
 }
 
 SVGLengthMode SVGLengthTearOff::unitMode()
 {
     return target()->unitMode();
 }
 
 float SVGLengthTearOff::value(ExceptionState& exceptionState)
 {
     if (target()->isRelative() && !canResolveRelativeUnits(contextElement())) {
@@ skipping 63 matching lines @@
     commitChange();
 }
 
 void SVGLengthTearOff::newValueSpecifiedUnits(unsigned short unitType, float valueInSpecifiedUnits, ExceptionState& exceptionState)
 {
     if (isImmutable()) {
         exceptionState.throwDOMException(NoModificationAllowedError, "The object is read-only.");
         return;
     }
 
-    if (unitType == LengthTypeUnknown || unitType > LengthTypePC) {
+    if (unitType == CSSPrimitiveValue::CSS_UNKNOWN || unitType > CSSPrimitiveValue::CSS_PC) {

[fs, 2015/06/02 18:20:08]

This is a bit theoretical perhaps, but this should really compare the "DOM
exposed" values (like before.) It just happens that they are the same I suppose.
Could we add a helper isValidLengthUnit and use here, below and in the assert in
toCSSUnitType? Just in case the CSS types change in the future (and to discern
one from the other.)

[Erik Dahlström, 2015/06/03 14:51:30]

The unknown unit is a "valid" unit, however one is not allowed to convert or
create new such values. I've added a helper function.

Or did you mean that it should more carefully check each possible unit to ensure
that the ordering doesn't change?

[fs, 2015/06/03 15:15:10]

More to check against what is considered the "external" type, so essentially
symmetry with the toSVGLengthType(...) in SVGLengthTearOff::unitType().

So in the new helper it'd just be:

return type != LengthTypeUnknown && type <= LengthTypePC;

         exceptionState.throwDOMException(NotSupportedError, "Cannot set value with unknown or invalid units (" + String::number(unitType) + ").");
         return;
     }
 
-    target()->newValueSpecifiedUnits(toSVGLengthType(unitType), valueInSpecifiedUnits);
+    target()->newValueSpecifiedUnits(toCSSUnitType(unitType), valueInSpecifiedUnits);
     commitChange();
 }
 
 void SVGLengthTearOff::convertToSpecifiedUnits(unsigned short unitType, ExceptionState& exceptionState)
 {
     if (isImmutable()) {
         exceptionState.throwDOMException(NoModificationAllowedError, "The object is read-only.");
         return;
     }
 
-    if (unitType == LengthTypeUnknown || unitType > LengthTypePC) {
+    if (unitType == CSSPrimitiveValue::CSS_UNKNOWN || unitType > CSSPrimitiveValue::CSS_PC) {
         exceptionState.throwDOMException(NotSupportedError, "Cannot convert to unknown or invalid units (" + String::number(unitType) + ").");
         return;
     }
 
-    if ((target()->isRelative() || SVGLength::isRelativeUnit(toSVGLengthType(unitType)))
+    if ((target()->isRelative() || SVGLength::isRelativeUnit(toCSSUnitType(unitType)))
         && !canResolveRelativeUnits(contextElement())) {
         exceptionState.throwDOMException(NotSupportedError, "Could not resolve relative length.");
         return;
     }
 
     SVGLengthContext lengthContext(contextElement());
-    target()->convertToSpecifiedUnits(toSVGLengthType(unitType), lengthContext);
+    target()->convertToSpecifiedUnits(toCSSUnitType(unitType), lengthContext);
     commitChange();
 }
 
 SVGLengthTearOff::SVGLengthTearOff(PassRefPtrWillBeRawPtr<SVGLength> target, SVGElement* contextElement, PropertyIsAnimValType propertyIsAnimVal, const QualifiedName& attributeName)
     : SVGPropertyTearOff<SVGLength>(target, contextElement, propertyIsAnimVal, attributeName)
 {
 }
 
 }