bindings: Use Maybe APIs in toXXX() functions

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 159 matching lines @@
 struct IntTypeLimits<uint16_t> {
     static const unsigned short maxValue = 65535;
     static const unsigned numberOfValues = 65536; // 2^16
 };
 
 template <typename T>
 static inline T toSmallerInt(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, const char* typeName, ExceptionState& exceptionState)
 {
     typedef IntTypeLimits<T> LimitsTrait;
 
+    v8::Isolate* isolate = exceptionState.isolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     // Fast case. The value is already a 32-bit integer in the right range.
     if (value->IsInt32()) {
-        int32_t result = value->Int32Value();
+        int32_t result;

[bashi, 2015/03/11 10:30:37]

As seen below, there are some code which look almost the same (but slightly
different). I'm not sure we should factor out them as helper functions/macros.

+        if (!getValueFromMaybe(value->Int32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
         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);
     }
 
     v8::Local<v8::Number> numberObject;
     if (value->IsNumber()) {
         numberObject = value.As<v8::Number>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
         // Can the value be converted to a number?
         v8::TryCatch block(isolate);
-        numberObject = value->ToNumber(isolate);
-        if (block.HasCaught()) {
-            exceptionState.rethrowV8Exception(block.Exception());
+        if (!value->ToNumber(context).ToLocal(&numberObject)) {

[Yuki, 2015/03/11 13:11:53]

It looks to me that either of ToNumber or ToLocal should throw an exception if
it fails.  So |block.HasCaught()| should be always true.

I'd recommend to check it with V8 team.  I think V8 should define APIs in that
way.

+            if (block.HasCaught())
+                exceptionState.rethrowV8Exception(block.Exception());
+            else
+                exceptionState.throwTypeError("Cannot convert to a number.");
             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) || !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;
 
+    v8::Isolate* isolate = exceptionState.isolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     // Fast case. The value is a 32-bit signed integer - possibly positive?
     if (value->IsInt32()) {
         int32_t result = value->Int32Value();
+        if (!getValueFromMaybe(value->Int32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
         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);
     }
 
     v8::Local<v8::Number> numberObject;
     if (value->IsNumber()) {
         numberObject = value.As<v8::Number>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
         // Can the value be converted to a number?
         v8::TryCatch block(isolate);
-        numberObject = value->ToNumber(isolate);
-        if (block.HasCaught()) {
-            exceptionState.rethrowV8Exception(block.Exception());
+        if (!value->ToNumber(context).ToLocal(&numberObject)) {
+            if (block.HasCaught())
+                exceptionState.rethrowV8Exception(block.Exception());
+            else
+                exceptionState.throwTypeError("Cannot convert to a number.");
             return 0;
         }
     }
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), 0, LimitsTrait::maxValue, typeName, exceptionState);
 
     double numberValue = numberObject->Value();
 
@@ skipping 49 matching lines @@
 }
 
 uint16_t toUInt16(v8::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toUInt16(value, NormalConversion, exceptionState);
 }
 
 int32_t toInt32(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
+    v8::Isolate* isolate = exceptionState.isolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     // Fast case. The value is already a 32-bit integer.
-    if (value->IsInt32())
-        return value->Int32Value();
+    if (value->IsInt32()) {
+        int32_t result;
+        if (!getValueFromMaybe(value->Int32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
+        return result;
+    }
 
     v8::Local<v8::Number> numberObject;
     if (value->IsNumber()) {
         numberObject = value.As<v8::Number>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
         // Can the value be converted to a number?
         v8::TryCatch block(isolate);
-        numberObject = value->ToNumber(isolate);
-        if (block.HasCaught()) {
-            exceptionState.rethrowV8Exception(block.Exception());
+        if (!value->ToNumber(context).ToLocal(&numberObject)) {
+            if (block.HasCaught())
+                exceptionState.rethrowV8Exception(block.Exception());
+            else
+                exceptionState.throwTypeError("Cannot convert to a number.");
             return 0;
         }
     }
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), kMinInt32, kMaxInt32, "long", exceptionState);
 
     double numberValue = numberObject->Value();
 
     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 result;
+    if (!getValueFromMaybe(numberObject->Int32Value(context), result)) {
+        exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+        return 0;
+    }
+    return result;
 }
 
 int32_t toInt32(v8::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toInt32(value, NormalConversion, exceptionState);
 }
 
 uint32_t toUInt32Slow(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsUint32());
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     if (value->IsInt32()) {
         ASSERT(configuration != NormalConversion);
-        int32_t result = value->Int32Value();
+        int32_t result;
+        if (!getValueFromMaybe(value->Int32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long' value range.");
             return 0;
         }
         ASSERT(configuration == Clamp);
         return clampTo<uint32_t>(result);
     }
 
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
     // 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());
+    v8::Local<v8::Number> numberObject;
+    if (!value->ToNumber(context).ToLocal(&numberObject)) {
+        if (block.HasCaught())
+            exceptionState.rethrowV8Exception(block.Exception());
+        else
+            exceptionState.throwTypeError("Cannot convert to a number.");
         return 0;
     }
     ASSERT(!numberObject.IsEmpty());
 
     if (configuration == EnforceRange)
         return enforceRange(numberObject->Value(), 0, kMaxUInt32, "unsigned long", exceptionState);
 
     double numberValue = numberObject->Value();
 
     if (std::isnan(numberValue))
         return 0;
 
     if (configuration == Clamp)
         return clampTo<uint32_t>(numberValue);
 
     if (std::isinf(numberValue))
         return 0;
 
-    return numberObject->Uint32Value();
+    uint32_t result;
+    if (!getValueFromMaybe(numberObject->Uint32Value(context), result)) {
+        exceptionState.throwTypeError("Cannot convert to a 32 bit unsigned integer.");
+        return 0;
+    }
+    return result;
 }
 
 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);
 
+    v8::Isolate* isolate = exceptionState.isolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
     // Fast case. The value is a 32-bit integer.
-    if (value->IsInt32())
-        return value->Int32Value();
+    if (value->IsInt32()) {
+        int32_t result;
+        if (!getValueFromMaybe(value->Int32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
+        return result;
+    }
 
     v8::Local<v8::Number> numberObject;
     if (value->IsNumber()) {
         numberObject = value.As<v8::Number>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
         // Can the value be converted to a number?
         v8::TryCatch block(isolate);
-        numberObject = value->ToNumber(isolate);
-        if (block.HasCaught()) {
-            exceptionState.rethrowV8Exception(block.Exception());
+        if (!value->ToNumber(context).ToLocal(&numberObject)) {
+            if (block.HasCaught())
+                exceptionState.rethrowV8Exception(block.Exception());
+            else
+                exceptionState.throwTypeError("Cannot convert to a number.");
             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::Handle<v8::Value> value)
 {
     NonThrowableExceptionState exceptionState;
     return toInt64(value, NormalConversion, exceptionState);
 }
 
 uint64_t toUInt64(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
     // Fast case. The value is a 32-bit unsigned integer.
-    if (value->IsUint32())
-        return value->Uint32Value();
+    if (value->IsUint32()) {
+        uint32_t result;
+        if (!getValueFromMaybe(value->Uint32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit unsigned integer.");
+            return 0;
+        }
+        return result;
+    }
 
     // Fast case. The value is a 32-bit integer.
     if (value->IsInt32()) {
-        int32_t result = value->Int32Value();
+        int32_t result;
+        if (!getValueFromMaybe(value->Int32Value(context), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
         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;
     }
 
     v8::Local<v8::Number> numberObject;
     if (value->IsNumber()) {
         numberObject = value.As<v8::Number>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
         // Can the value be converted to a number?
         v8::TryCatch block(isolate);
-        numberObject = value->ToNumber(isolate);
-        if (block.HasCaught()) {
-            exceptionState.rethrowV8Exception(block.Exception());
+        if (!value->ToNumber(context).ToLocal(&numberObject)) {
+            if (block.HasCaught())
+                exceptionState.rethrowV8Exception(block.Exception());
+            else
+                exceptionState.throwTypeError("Cannot convert to a number.");
             return 0;
         }
     }
     ASSERT(!numberObject.IsEmpty());
 
     double numberValue = numberObject->Value();
 
     if (configuration == EnforceRange)
         return enforceRange(numberValue, 0, kJSMaxInteger, "unsigned long long", exceptionState);
 
@@ skipping 26 matching lines @@
     if (!std::isfinite(numberValue)) {
         exceptionState.throwTypeError("The provided float value is non-finite.");
         return 0;
     }
     return numberValue;
 }
 
 double toDoubleSlow(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     ASSERT(!value->IsNumber());
-    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    v8::Isolate* isolate = exceptionState.isolate();
     v8::TryCatch block(isolate);
-    double doubleValue = value->NumberValue();
-    if (block.HasCaught()) {
-        exceptionState.rethrowV8Exception(block.Exception());
+    double doubleValue;
+    if (!getValueFromMaybe(value->NumberValue(isolate->GetCurrentContext()), doubleValue)) {
+        if (block.HasCaught())
+            exceptionState.rethrowV8Exception(block.Exception());
+        else
+            exceptionState.throwTypeError("Cannot convert to a number.");
         return 0;
     }
     return doubleValue;
 }
 
 double toRestrictedDouble(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     double numberValue = toDouble(value, exceptionState);
     if (exceptionState.hadException())
         return 0;
@@ skipping 12 matching lines @@
 
     // From the Web IDL spec: http://heycam.github.io/webidl/#es-ByteString
     if (value.IsEmpty())
         return String();
 
     // 1. Let x be ToString(v)
     v8::Local<v8::String> stringObject;
     if (value->IsString()) {
         stringObject = value.As<v8::String>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
+        v8::Isolate* isolate = exceptionState.isolate();
         v8::TryCatch block(isolate);
         stringObject = value->ToString(isolate);
-        if (block.HasCaught()) {
-            exceptionState.rethrowV8Exception(block.Exception());
+        if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&stringObject)) {
+            if (block.HasCaught())
+                exceptionState.rethrowV8Exception(block.Exception());
+            else
+                exceptionState.throwTypeError("Cannot convert to a string.");
             return String();
         }
     }
 
     String x = toCoreString(stringObject);
 
     // 2. If the value of any element of x is greater than 255, then throw a TypeError.
     if (!x.containsOnlyLatin1()) {
         exceptionState.throwTypeError("Value is not a valid ByteString.");
         return String();
@@ skipping 111 matching lines @@
 String toUSVString(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     // http://heycam.github.io/webidl/#es-USVString
     if (value.IsEmpty())
         return String();
 
     v8::Local<v8::String> stringObject;
     if (value->IsString()) {
         stringObject = value.As<v8::String>();
     } else {
-        v8::Isolate* isolate = v8::Isolate::GetCurrent();
+        v8::Isolate* isolate = exceptionState.isolate();
         v8::TryCatch block(isolate);
         stringObject = value->ToString(isolate);
+        if (!value->ToString(isolate->GetCurrentContext()).ToLocal(&stringObject)) {
+            exceptionState.throwTypeError("Cannot convert to a string.");
+            return String();
+        }
         if (block.HasCaught()) {
             exceptionState.rethrowV8Exception(block.Exception());
             return String();
         }
     }
 
     // USVString is identical to DOMString except that "convert a
     // DOMString to a sequence of Unicode characters" is used subsequently
     // when converting to an IDL value
     String x = toCoreString(stringObject);
@@ skipping 335 matching lines @@
 {
     v8ConstructorAttributeGetter(info);
 }
 
 void v8ConstructorAttributeGetterAsAccessor(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8ConstructorAttributeGetter(info);
 }
 
 } // namespace blink