Assert that convertToLength succeeds instead of returning Length(Undefined)

Source/core/css/resolver/TransformBuilder.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 35 matching lines @@
 TransformBuilder::TransformBuilder()
 {
 }
 
 TransformBuilder::~TransformBuilder()
 {
 }
 
 static Length convertToFloatLength(CSSPrimitiveValue* primitiveValue, const CSSToLengthConversionData& conversionData)
 {
-    return primitiveValue ? primitiveValue->convertToLength<FixedConversion | PercentConversion>(conversionData) : Length(Undefined);
+    ASSERT(primitiveValue);
+    return primitiveValue->convertToLength<FixedConversion | PercentConversion>(conversionData);
 }
 
 static TransformOperation::OperationType getTransformOperationType(CSSTransformValue::TransformOperationType type)
 {
     switch (type) {
     case CSSTransformValue::ScaleTransformOperation: return TransformOperation::Scale;
     case CSSTransformValue::ScaleXTransformOperation: return TransformOperation::ScaleX;
     case CSSTransformValue::ScaleYTransformOperation: return TransformOperation::ScaleY;
     case CSSTransformValue::ScaleZTransformOperation: return TransformOperation::ScaleZ;
     case CSSTransformValue::Scale3DTransformOperation: return TransformOperation::Scale3D;
@@ skipping 106 matching lines @@
             else {
                 tx = convertToFloatLength(firstValue, conversionData);
                 if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
                     if (transformValue->length() > 1) {
                         CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
                         ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
-            if (tx.isUndefined() || ty.isUndefined())
-                return false;
-
             operations.operations().append(TranslateTransformOperation::create(tx, ty, Length(0, Fixed), getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::TranslateZTransformOperation:
         case CSSTransformValue::Translate3DTransformOperation: {
             Length tx = Length(0, Fixed);
             Length ty = Length(0, Fixed);
             Length tz = Length(0, Fixed);
             if (transformValue->operationType() == CSSTransformValue::TranslateZTransformOperation)
                 tz = convertToFloatLength(firstValue, conversionData);
             else if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
                 ty = convertToFloatLength(firstValue, conversionData);
             else {
                 tx = convertToFloatLength(firstValue, conversionData);
                 if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
                     if (transformValue->length() > 2) {
                         CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
                         tz = convertToFloatLength(thirdValue, conversionData);
                     }
                     if (transformValue->length() > 1) {
                         CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
                         ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
-            if (tx.isUndefined() || ty.isUndefined() || tz.isUndefined())
-                return false;
-
             operations.operations().append(TranslateTransformOperation::create(tx, ty, tz, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::RotateTransformOperation: {
             double angle = firstValue->computeDegrees();
             operations.operations().append(RotateTransformOperation::create(0, 0, 1, angle, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::RotateXTransformOperation:
         case CSSTransformValue::RotateYTransformOperation:
@@ skipping 79 matching lines @@
             operations.operations().append(Matrix3DTransformOperation::create(matrix));
             break;
         }
         case CSSTransformValue::PerspectiveTransformOperation: {
             Length p = Length(0, Fixed);
             if (firstValue->isLength())
                 p = convertToFloatLength(firstValue, conversionData);
             else {
                 // This is a quirk that should go away when 3d transforms are finalized.
                 double val = firstValue->getDoubleValue();
-                p = val >= 0 ? Length(clampToPositiveInteger(val), Fixed) : Length(Undefined);
+                if (val < 0)
+                    return false;
+                p = Length(clampToPositiveInteger(val), Fixed);
             }
 
-            if (p.isUndefined())
-                return false;
-
             operations.operations().append(PerspectiveTransformOperation::create(p));
             break;
         }
         case CSSTransformValue::UnknownTransformOperation:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     outOperations = operations;
     return true;
 }
 
 } // namespace WebCore