Use conversion helpers in V8Binding.cpp for [Clamp] method arguments

Source/bindings/core/v8/V8Binding.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 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 179 matching lines @@
 
     // Fast case. The value is already a 32-bit integer in the right range.
     if (value->IsInt32()) {
         int32_t result = value->Int32Value();
         if (result >= LimitsTrait::minValue && result <= LimitsTrait::maxValue)
             return static_cast<T>(result);
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the '" + String(typeName) + "' value range.");
             return 0;
         }
+        if (configuration == Clamp)
+            return clampTo<T>(result);
         result %= LimitsTrait::numberOfValues;
         return static_cast<T>(result > LimitsTrait::maxValue ? result - LimitsTrait::numberOfValues : result);
     }
 
     // Can the value be converted to a number?
     v8::TryCatch block;
     v8::Local<v8::Number> numberObject(value->ToNumber());
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), LimitsTrait::minValue, LimitsTrait::maxValue, typeName, exceptionState);
 
     double numberValue = numberObject->Value();
-    if (std::isnan(numberValue) || std::isinf(numberValue) || !numberValue)
+    if (std::isnan(numberValue) || !numberValue)
+        return 0;
+
+    if (configuration == Clamp)
+        return clampTo<T>(numberValue);
+
+    if (std::isinf(numberValue))
         return 0;
 
     numberValue = numberValue < 0 ? -floor(fabs(numberValue)) : floor(fabs(numberValue));
     numberValue = fmod(numberValue, LimitsTrait::numberOfValues);
 
     return static_cast<T>(numberValue > LimitsTrait::maxValue ? numberValue - LimitsTrait::numberOfValues : numberValue);
 }
 
 template <typename T>
 static inline T toSmallerUInt(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, const char* typeName, ExceptionState& exceptionState)
 {
     typedef IntTypeLimits<T> LimitsTrait;
 
     // Fast case. The value is a 32-bit signed integer - possibly positive?
     if (value->IsInt32()) {
         int32_t result = value->Int32Value();
         if (result >= 0 && result <= LimitsTrait::maxValue)
             return static_cast<T>(result);
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the '" + String(typeName) + "' value range.");
             return 0;
         }
+        if (configuration == Clamp)
+            return clampTo<T>(result);
         return static_cast<T>(result);
     }
 
     // Can the value be converted to a number?
     v8::TryCatch block;
     v8::Local<v8::Number> numberObject(value->ToNumber());
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), 0, LimitsTrait::maxValue, typeName, exceptionState);
 
-    // Does the value convert to nan or to an infinity?
     double numberValue = numberObject->Value();
-    if (std::isnan(numberValue) || std::isinf(numberValue) || !numberValue)
+
+    if (std::isnan(numberValue) || !numberValue)
         return 0;
 
     if (configuration == Clamp)
-        return clampTo<T>(numberObject->Value());
+        return clampTo<T>(numberValue);
+
+    if (std::isinf(numberValue))
+        return 0;
 
     numberValue = numberValue < 0 ? -floor(fabs(numberValue)) : floor(fabs(numberValue));
     return static_cast<T>(fmod(numberValue, LimitsTrait::numberOfValues));
 }
 
 int8_t toInt8(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerInt<int8_t>(value, configuration, "byte", exceptionState);
 }
 
@@ skipping 48 matching lines @@
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), kMinInt32, kMaxInt32, "long", exceptionState);
 
-    // Does the value convert to nan or to an infinity?
     double numberValue = numberObject->Value();
-    if (std::isnan(numberValue) || std::isinf(numberValue))
+
+    if (std::isnan(numberValue))
         return 0;
 
     if (configuration == Clamp)
-        return clampTo<int32_t>(numberObject->Value());
+        return clampTo<int32_t>(numberValue);
+
+    if (std::isinf(numberValue))
+        return 0;
 
     return numberObject->Int32Value();
 }
 
 int32_t toInt32(v8::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toInt32(value, NormalConversion, exceptionState);
 }
 
 uint32_t toUInt32(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     // Fast case. The value is already a 32-bit unsigned integer.
     if (value->IsUint32())
         return value->Uint32Value();
 
     // Fast case. The value is a 32-bit signed integer - possibly positive?
     if (value->IsInt32()) {
         int32_t result = value->Int32Value();
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long' value range.");
             return 0;
         }
+        if (configuration == Clamp)
+            return clampTo<uint32_t>(result);
         return result;
     }
 
     // Can the value be converted to a number?
     v8::TryCatch block;
     v8::Local<v8::Number> numberObject(value->ToNumber());
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), 0, kMaxUInt32, "unsigned long", exceptionState);
 
-    // Does the value convert to nan or to an infinity?
     double numberValue = numberObject->Value();
-    if (std::isnan(numberValue) || std::isinf(numberValue))
+
+    if (std::isnan(numberValue))
         return 0;
 
     if (configuration == Clamp)
-        return clampTo<uint32_t>(numberObject->Value());
+        return clampTo<uint32_t>(numberValue);
+
+    if (std::isinf(numberValue))
+        return 0;
 
     return numberObject->Uint32Value();
 }
 
 uint32_t toUInt32(v8::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toUInt32(value, NormalConversion, exceptionState);
 }
 
 int64_t toInt64(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
+    // Clamping not supported for int64_t/long long int. See Source/wtf/MathExtras.h.
+    ASSERT(configuration != Clamp);
+
     // Fast case. The value is a 32-bit integer.
     if (value->IsInt32())
         return value->Int32Value();
 
     // Can the value be converted to a number?
     v8::TryCatch block;
     v8::Local<v8::Number> numberObject(value->ToNumber());
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
-    double x = numberObject->Value();
+    double numberValue = numberObject->Value();
 
     if (configuration == EnforceRange)
-        return enforceRange(x, -kJSMaxInteger, kJSMaxInteger, "long long", exceptionState);
+        return enforceRange(numberValue, -kJSMaxInteger, kJSMaxInteger, "long long", exceptionState);
 
-    // Does the value convert to nan or to an infinity?
-    if (std::isnan(x) || std::isinf(x))
+    if (std::isnan(numberValue) || std::isinf(numberValue))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
-    doubleToInteger(x, integer);
+    doubleToInteger(numberValue, integer);
     return integer;
 }
 
 int64_t toInt64(v8::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toInt64(value, NormalConversion, exceptionState);
 }
 
 uint64_t toUInt64(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     // Fast case. The value is a 32-bit unsigned integer.
     if (value->IsUint32())
         return value->Uint32Value();
 
     // Fast case. The value is a 32-bit integer.
     if (value->IsInt32()) {
         int32_t result = value->Int32Value();
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long long' value range.");
             return 0;
         }
+        if (configuration == Clamp)
+            return clampTo<uint64_t>(result);
         return result;
     }
 
     // Can the value be converted to a number?
     v8::TryCatch block;
     v8::Local<v8::Number> numberObject(value->ToNumber());
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
-    double x = numberObject->Value();
+    double numberValue = numberObject->Value();
 
     if (configuration == EnforceRange)
-        return enforceRange(x, 0, kJSMaxInteger, "unsigned long long", exceptionState);
+        return enforceRange(numberValue, 0, kJSMaxInteger, "unsigned long long", exceptionState);
 
-    // Does the value convert to nan or to an infinity?
-    if (std::isnan(x) || std::isinf(x))
+    if (std::isnan(numberValue))
+        return 0;
+
+    if (configuration == Clamp)
+        return clampTo<uint64_t>(numberValue);
+
+    if (std::isinf(numberValue))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
-    doubleToInteger(x, integer);
+    doubleToInteger(numberValue, integer);
     return integer;
 }
 
 uint64_t toUInt64(v8::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toUInt64(value, NormalConversion, exceptionState);
 }
 
 float toFloat(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
@@ skipping 478 matching lines @@
 
 v8::Local<v8::Value> v8IteratorResult(v8::Isolate* isolate, v8::Handle<v8::Value> value)
 {
     v8::Local<v8::Object> result = v8::Object::New(isolate);
     result->Set(v8String(isolate, "value"), value);
     result->Set(v8String(isolate, "done"), v8Boolean(false, isolate));
     return result;
 }
 
 } // namespace blink