[bindings] Pass NormalConversion to to[U]Int{8/16/32/64}(...) in v8_types.py and reduce conversion …

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 263 matching lines @@
 
     numberValue = numberValue < 0 ? -floor(fabs(numberValue)) : floor(fabs(numberValue));
     return static_cast<T>(fmod(numberValue, LimitsTrait::numberOfValues));
 }
 
 int8_t toInt8(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerInt<int8_t>(isolate, value, configuration, "byte", exceptionState);
 }
 
-int8_t toInt8(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toInt8(isolate, value, NormalConversion, exceptionState);
-}
-
 uint8_t toUInt8(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerUInt<uint8_t>(isolate, value, configuration, "octet", exceptionState);
 }
 
-uint8_t toUInt8(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toUInt8(isolate, value, NormalConversion, exceptionState);
-}
-
 int16_t toInt16(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerInt<int16_t>(isolate, value, configuration, "short", exceptionState);
 }
 
-int16_t toInt16(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toInt16(isolate, value, NormalConversion, exceptionState);
-}
-
 uint16_t toUInt16(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     return toSmallerUInt<uint16_t>(isolate, value, configuration, "unsigned short", exceptionState);
 }
 
-uint16_t toUInt16(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toUInt16(isolate, value, NormalConversion, exceptionState);
-}
-
 int32_t toInt32Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsInt32());
     // Can the value be converted to a number?
     v8::TryCatch block(isolate);
     v8::Local<v8::Number> numberObject = value->ToNumber(isolate);
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
 
     ASSERT(!numberObject.IsEmpty());
 
     double numberValue = numberObject->Value();
     if (configuration == EnforceRange)
         return enforceRange(numberValue, kMinInt32, kMaxInt32, "long", exceptionState);
 
     if (std::isnan(numberValue))
         return 0;
 
     if (configuration == Clamp)
         return clampTo<int32_t>(numberValue);
 
     if (std::isinf(numberValue))
         return 0;
 
     return numberObject->Int32Value();
 }
 
-int32_t toInt32(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toInt32(isolate, value, NormalConversion, exceptionState);
-}
-
 uint32_t toUInt32Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsUint32());
     if (value->IsInt32()) {
         ASSERT(configuration != NormalConversion);
         int32_t result = value->Int32Value();
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long' value range.");
@@ skipping 22 matching lines @@
 
     if (configuration == Clamp)
         return clampTo<uint32_t>(numberValue);
 
     if (std::isinf(numberValue))
         return 0;
 
     return numberObject->Uint32Value();
 }
 
-uint32_t toUInt32(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toUInt32(isolate, value, NormalConversion, exceptionState);
-}
-
 int64_t toInt64Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsInt32());
 
     v8::Local<v8::Number> numberObject;
     // Can the value be converted to a number?
     v8::TryCatch block(isolate);
     numberObject = value->ToNumber(isolate);
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
     ASSERT(!numberObject.IsEmpty());
 
     double numberValue = numberObject->Value();
 
     if (configuration == EnforceRange)
         return enforceRange(numberValue, -kJSMaxInteger, kJSMaxInteger, "long long", exceptionState);
 
     if (std::isnan(numberValue) || std::isinf(numberValue))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
     doubleToInteger(numberValue, integer);
     return integer;
 }
 
-int64_t toInt64(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toInt64(isolate, value, NormalConversion, exceptionState);
-}
-
 uint64_t toUInt64Slow(v8::Isolate* isolate, v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsUint32());
     if (value->IsInt32()) {
         ASSERT(configuration != NormalConversion);
         int32_t result = value->Int32Value();
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long long' value range.");
@@ skipping 26 matching lines @@
 
     if (std::isinf(numberValue))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
     doubleToInteger(numberValue, integer);
     return integer;
 }
 
-uint64_t toUInt64(v8::Isolate* isolate, v8::Handle<v8::Value> value)
-{
-    NonThrowableExceptionState exceptionState;
-    return toUInt64(isolate, value, NormalConversion, exceptionState);
-}
-
 float toRestrictedFloat(v8::Isolate* isolate, v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     float numberValue = toFloat(isolate, value, exceptionState);
     if (exceptionState.hadException())
         return 0;
     if (!std::isfinite(numberValue)) {
         exceptionState.throwTypeError("The provided float value is non-finite.");
         return 0;
     }
     return numberValue;
@@ skipping 523 matching lines @@
 {
     v8ConstructorAttributeGetter(info);
 }
 
 void v8ConstructorAttributeGetterAsAccessor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8ConstructorAttributeGetter(info);
 }
 
 } // namespace blink