In V8Binding.cpp, throw all exceptions via ExceptionState& argument

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 184 matching lines @@
             return static_cast<T>(result);
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the '" + String(typeName) + "' value range.");
             return 0;
         }
         result %= LimitsTrait::numberOfValues;
         return static_cast<T>(result > LimitsTrait::maxValue ? result - LimitsTrait::numberOfValues : result);
     }
 
     // Can the value be converted to a number?
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
+
     if (numberObject.IsEmpty()) {

[Jens Widell, 2014/09/09 15:06:38]

Question: Can this be true? It would be if value->ToNumber() threw an exception,
but then we won't reach this line.

[haraken, 2014/09/10 01:09:23]

You're right. This should be ASSERT(!numberObject.IsEmpty()).

[Jens Widell, 2014/09/10 05:33:57]

Done.

         exceptionState.throwTypeError("Not convertible to a number value (of type '" + String(typeName) + "'.");

[haraken, 2014/09/10 01:09:23]

Do we want to put this message into the exceptionState?

[Jens Widell, 2014/09/10 04:42:27]

Don't know if I understand what you mean. Elaborate?

[haraken, 2014/09/10 04:49:49]

Sorry for not being clear.

There are two ways to throw the exception:

if (block.HasCaught()) {
    exceptionState.rethrowV8Exception(block.Exception());
    return 0;
}

or:

if (block.HasCaught()) {
    exceptionState.throwTypeError("Not convertible to a number value (of type '"
+ String(typeName) + "'.");
    return 0;
}

I thought that the latter would be more developer-friendly.

         return 0;
     }
 
     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)
         return 0;
 
@@ skipping 14 matching lines @@
         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;
         }
         return static_cast<T>(result);
     }
 
     // Can the value be converted to a number?
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
+
     if (numberObject.IsEmpty()) {
         exceptionState.throwTypeError("Not convertible to a number value (of type '" + String(typeName) + "'.");
         return 0;
     }
 
     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();
@@ skipping 51 matching lines @@
     return toUInt16(value, NormalConversion, exceptionState);
 }
 
 int32_t toInt32(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, ExceptionState& exceptionState)
 {
     // Fast case. The value is already a 32-bit integer.
     if (value->IsInt32())
         return value->Int32Value();
 
     // Can the value be converted to a number?
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
+
     if (numberObject.IsEmpty()) {
         exceptionState.throwTypeError("Not convertible to a number value (of type 'long'.)");
         return 0;
     }
 
     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))
         return 0;
 
     if (configuration == Clamp)
         return clampTo<int32_t>(numberObject->Value());
 
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(int32_t, result, numberObject->Int32Value(), exceptionState, 0);

[Jens Widell, 2014/09/09 15:06:38]

I assumed here that since numberObject is a number already (was returned by
ToNumber()), Int32Value() can't actually throw an exception.

-    return result;
+    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;
         }
         return result;
     }
 
     // Can the value be converted to a number?
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
+
     if (numberObject.IsEmpty()) {
         exceptionState.throwTypeError("Not convertible to a number value (of type 'unsigned long'.)");
         return 0;
     }
 
     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))
         return 0;
 
     if (configuration == Clamp)
         return clampTo<uint32_t>(numberObject->Value());
 
-    TONATIVE_DEFAULT(uint32_t, result, numberObject->Uint32Value(), 0);
-    return result;
+    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)
 {
     // Fast case. The value is a 32-bit integer.
     if (value->IsInt32())
         return value->Int32Value();
 
     // Can the value be converted to a number?
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
+
     if (numberObject.IsEmpty()) {
         exceptionState.throwTypeError("Not convertible to a number value (of type 'long long'.)");
         return 0;
     }
 
     double x = numberObject->Value();
 
     if (configuration == EnforceRange)
         return enforceRange(x, -kJSMaxInteger, kJSMaxInteger, "long long", exceptionState);
 
@@ skipping 25 matching lines @@
         if (result >= 0)
             return result;
         if (configuration == EnforceRange) {
             exceptionState.throwTypeError("Value is outside the 'unsigned long long' value range.");
             return 0;
         }
         return result;
     }
 
     // Can the value be converted to a number?
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
+
     if (numberObject.IsEmpty()) {
         exceptionState.throwTypeError("Not convertible to a number value (of type 'unsigned long long'.)");
         return 0;
     }
 
     double x = numberObject->Value();
 
     if (configuration == EnforceRange)
         return enforceRange(x, 0, kJSMaxInteger, "unsigned long long", exceptionState);
 
     // Does the value convert to nan or to an infinity?
     if (std::isnan(x) || std::isinf(x))
         return 0;
 
     // NaNs and +/-Infinity should be 0, otherwise modulo 2^64.
     unsigned long long integer;
     doubleToInteger(x, 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)
 {
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::Number>, numberObject, value->ToNumber(), exceptionState, 0);
+    v8::TryCatch block;
+    v8::Local<v8::Number> numberObject(value->ToNumber());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return 0;
+    }
     return numberObject->NumberValue();
 }
 
 String toByteString(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     // Handle null default value.
     if (value.IsEmpty())
         return String();
 
     // From the Web IDL spec: http://heycam.github.io/webidl/#es-ByteString
     if (value.IsEmpty())
         return String();
 
     // 1. Let x be ToString(v)
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::String>, stringObject, value->ToString(), exceptionState, String());
+    v8::TryCatch block;
+    v8::Local<v8::String> stringObject(value->ToString());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        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();
     }
 
     // 3. Return an IDL ByteString value whose length is the length of x, and where the
     // value of each element is the value of the corresponding element of x.
@@ skipping 103 matching lines @@
     ASSERT(u.length() == string.length());
     return u.toString();
 }
 
 String toScalarValueString(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     // From the Encoding standard (with a TODO to move to Web IDL):
     // http://encoding.spec.whatwg.org/#type-scalarvaluestring
     if (value.IsEmpty())
         return String();
-    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::String>, stringObject, value->ToString(), exceptionState, String());
+
+    v8::TryCatch block;
+    v8::Local<v8::String> stringObject(value->ToString());
+    if (block.HasCaught()) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return String();
+    }
 
     // ScalarValueString 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);
     return replaceUnmatchedSurrogates(x);
 }
 
 PassRefPtrWillBeRawPtr<XPathNSResolver> toXPathNSResolver(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
@@ skipping 301 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