Remove explicit bounds check from CSSValueList::item

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 82 matching lines @@
 
         if (!currValue->isTransformValue())
             continue;
 
         CSSTransformValue* transformValue = toCSSTransformValue(i.value());
         if (!transformValue->length())
             continue;
 
         bool haveNonPrimitiveValue = false;
         for (unsigned j = 0; j < transformValue->length(); ++j) {
-            if (!transformValue->itemWithoutBoundsCheck(j)->isPrimitiveValue()) {
+            if (!transformValue->item(j)->isPrimitiveValue()) {
                 haveNonPrimitiveValue = true;
                 break;
             }
         }
         if (haveNonPrimitiveValue)
             continue;
 
-        CSSPrimitiveValue* firstValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(0));
+        CSSPrimitiveValue* firstValue = toCSSPrimitiveValue(transformValue->item(0));
 
         switch (transformValue->operationType()) {
         case CSSTransformValue::ScaleTransformOperation:
         case CSSTransformValue::ScaleXTransformOperation:
         case CSSTransformValue::ScaleYTransformOperation: {
             double sx = 1.0;
             double sy = 1.0;
             if (transformValue->operationType() == CSSTransformValue::ScaleYTransformOperation)
                 sy = firstValue->getDoubleValue();
             else {
                 sx = firstValue->getDoubleValue();
                 if (transformValue->operationType() != CSSTransformValue::ScaleXTransformOperation) {
                     if (transformValue->length() > 1) {
-                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
+                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
                         sy = secondValue->getDoubleValue();
                     } else
                         sy = sx;
                 }
             }
             operations.operations().append(ScaleTransformOperation::create(sx, sy, 1.0, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::ScaleZTransformOperation:
         case CSSTransformValue::Scale3DTransformOperation: {
             double sx = 1.0;
             double sy = 1.0;
             double sz = 1.0;
             if (transformValue->operationType() == CSSTransformValue::ScaleZTransformOperation)
                 sz = firstValue->getDoubleValue();
             else if (transformValue->operationType() == CSSTransformValue::ScaleYTransformOperation)
                 sy = firstValue->getDoubleValue();
             else {
                 sx = firstValue->getDoubleValue();
                 if (transformValue->operationType() != CSSTransformValue::ScaleXTransformOperation) {
                     if (transformValue->length() > 2) {
-                        CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
+                        CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->item(2));
                         sz = thirdValue->getDoubleValue();
                     }
                     if (transformValue->length() > 1) {
-                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
+                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
                         sy = secondValue->getDoubleValue();
                     } else
                         sy = sx;
                 }
             }
             operations.operations().append(ScaleTransformOperation::create(sx, sy, sz, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::TranslateTransformOperation:
         case CSSTransformValue::TranslateXTransformOperation:
         case CSSTransformValue::TranslateYTransformOperation: {
             Length tx = Length(0, Fixed);
             Length ty = Length(0, Fixed);
             if (transformValue->operationType() == CSSTransformValue::TranslateYTransformOperation)
                 ty = convertToFloatLength(firstValue, conversionData);
             else {
                 tx = convertToFloatLength(firstValue, conversionData);
                 if (transformValue->operationType() != CSSTransformValue::TranslateXTransformOperation) {
                     if (transformValue->length() > 1) {
-                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
+                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
                         ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
             operations.operations().append(TranslateTransformOperation::create(tx, ty, 0, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::TranslateZTransformOperation:
         case CSSTransformValue::Translate3DTransformOperation: {
             Length tx = Length(0, Fixed);
             Length ty = Length(0, Fixed);
             double tz = 0;
             if (transformValue->operationType() == CSSTransformValue::TranslateZTransformOperation)
                 tz = firstValue->computeLength<double>(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));
+                        CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->item(2));
                         tz = thirdValue->computeLength<double>(conversionData);
                     }
                     if (transformValue->length() > 1) {
-                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
+                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
                         ty = convertToFloatLength(secondValue, conversionData);
                     }
                 }
             }
 
             operations.operations().append(TranslateTransformOperation::create(tx, ty, tz, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::RotateTransformOperation: {
             double angle = firstValue->computeDegrees();
@@ skipping 13 matching lines @@
             else if (transformValue->operationType() == CSSTransformValue::RotateYTransformOperation)
                 y = 1;
             else
                 z = 1;
             operations.operations().append(RotateTransformOperation::create(x, y, z, angle, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::Rotate3DTransformOperation: {
             if (transformValue->length() < 4)
                 break;
-            CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
-            CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2));
-            CSSPrimitiveValue* fourthValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3));
+            CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
+            CSSPrimitiveValue* thirdValue = toCSSPrimitiveValue(transformValue->item(2));
+            CSSPrimitiveValue* fourthValue = toCSSPrimitiveValue(transformValue->item(3));
             double x = firstValue->getDoubleValue();
             double y = secondValue->getDoubleValue();
             double z = thirdValue->getDoubleValue();
             double angle = fourthValue->computeDegrees();
             operations.operations().append(RotateTransformOperation::create(x, y, z, angle, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::SkewTransformOperation:
         case CSSTransformValue::SkewXTransformOperation:
         case CSSTransformValue::SkewYTransformOperation: {
             double angleX = 0;
             double angleY = 0;
             double angle = firstValue->computeDegrees();
             if (transformValue->operationType() == CSSTransformValue::SkewYTransformOperation)
                 angleY = angle;
             else {
                 angleX = angle;
                 if (transformValue->operationType() == CSSTransformValue::SkewTransformOperation) {
                     if (transformValue->length() > 1) {
-                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1));
+                        CSSPrimitiveValue* secondValue = toCSSPrimitiveValue(transformValue->item(1));
                         angleY = secondValue->computeDegrees();
                     }
                 }
             }
             operations.operations().append(SkewTransformOperation::create(angleX, angleY, getTransformOperationType(transformValue->operationType())));
             break;
         }
         case CSSTransformValue::MatrixTransformOperation: {
             if (transformValue->length() < 6)
                 break;
             double a = firstValue->getDoubleValue();
-            double b = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1))->getDoubleValue();
-            double c = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2))->getDoubleValue();
-            double d = toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3))->getDoubleValue();
-            double e = zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(4))->getDoubleValue();
-            double f = zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(5))->getDoubleValue();
+            double b = toCSSPrimitiveValue(transformValue->item(1))->getDoubleValue();
+            double c = toCSSPrimitiveValue(transformValue->item(2))->getDoubleValue();
+            double d = toCSSPrimitiveValue(transformValue->item(3))->getDoubleValue();
+            double e = zoomFactor * toCSSPrimitiveValue(transformValue->item(4))->getDoubleValue();
+            double f = zoomFactor * toCSSPrimitiveValue(transformValue->item(5))->getDoubleValue();
             operations.operations().append(MatrixTransformOperation::create(a, b, c, d, e, f));
             break;
         }
         case CSSTransformValue::Matrix3DTransformOperation: {
             if (transformValue->length() < 16)
                 break;
-            TransformationMatrix matrix(toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(0))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(1))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(2))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(3))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(4))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(5))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(6))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(7))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(8))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(9))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(10))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(11))->getDoubleValue(),
-                zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(12))->getDoubleValue(),
-                zoomFactor * toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(13))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(14))->getDoubleValue(),
-                toCSSPrimitiveValue(transformValue->itemWithoutBoundsCheck(15))->getDoubleValue());
+            TransformationMatrix matrix(toCSSPrimitiveValue(transformValue->item(0))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(1))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(2))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(3))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(4))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(5))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(6))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(7))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(8))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(9))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(10))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(11))->getDoubleValue(),
+                zoomFactor * toCSSPrimitiveValue(transformValue->item(12))->getDoubleValue(),
+                zoomFactor * toCSSPrimitiveValue(transformValue->item(13))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(14))->getDoubleValue(),
+                toCSSPrimitiveValue(transformValue->item(15))->getDoubleValue());
             operations.operations().append(Matrix3DTransformOperation::create(matrix));
             break;
         }
         case CSSTransformValue::PerspectiveTransformOperation: {
             double p;
             if (firstValue->isLength())
                 p = firstValue->computeLength<double>(conversionData);
             else {
                 // This is a quirk that should go away when 3d transforms are finalized.
                 double val = firstValue->getDoubleValue();
                 if (val < 0)
                     return false;
                 p = clampToPositiveInteger(val);
             }
 
             operations.operations().append(PerspectiveTransformOperation::create(p));
             break;
         }
         case CSSTransformValue::UnknownTransformOperation:
             ASSERT_NOT_REACHED();
             break;
         }
     }
 
     outOperations = operations;
     return true;
 }
 
 } // namespace WebCore