bindings: Use Maybe APIs in toXXX() functions

Source/bindings/core/v8/V8Binding.h

 /*
 * Copyright (C) 2009 Google Inc. All rights reserved.
 * Copyright (C) 2012 Ericsson AB. 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.
@@ skipping 418 matching lines @@
 // Convert a value to a 32-bit integer assuming the conversion cannot fail.
 int32_t toInt32(v8::Handle<v8::Value>);
 
 // Convert a value to a 32-bit unsigned integer. The conversion fails if the
 // value cannot be converted to a number or the range violated per WebIDL:
 // http://www.w3.org/TR/WebIDL/#es-unsigned-long
 uint32_t toUInt32Slow(v8::Handle<v8::Value>, IntegerConversionConfiguration, ExceptionState&);
 inline 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();
+    if (value->IsUint32()) {

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

Now this doesn't look 'fast case'. Should we remove inline version?

Note that V8 doesn't provide Cast() for Uint32, even when IsUint32() is true. We
need to use Unit32Value(context), which could fail. Same for Int32.

https://codereview.chromium.org/990943003/#msg3

[Jens Widell, 2015/03/11 10:56:37]

We might want to investigate the performance impact of this change as-is vs this
but uninlined. See https://codereview.chromium.org/947123002/#msg2 for some
micro-benchmarks and previous results.

But yeah, this code certainly seems to me like something we shouldn't be
inlining in lots of places.

It also seems unfortunate to me that V8 doesn't provide a fast-path for
accessing number values as int32, especially given that V8 sometimes actually
represents them directly as int32. It looks like the actual code path in
Int32Value(), in the IsNumber() case, is as "fast" as the corresponding code
path for Cast<Number> + Value().

Maybe the Number class could have accessors for int32/uint32, so that we could
do

  if (value->IsUint32())
    return value.As<v8::Number>()->Uint32Value();

?

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

This reminds me of the following comment on an issue:
https://code.google.com/p/chromium/issues/detail?id=446097#c7
which was fixed in the following CL:
https://codereview.chromium.org/873983003/

I'm not sure if it's possible that Uint32Value fails.  In other words, should V8
make some guarantee about IsUint32 and Uint32Value?

+        uint32_t result;
+        if (!getValueFromMaybe(value->Uint32Value(exceptionState.isolate()->GetCurrentContext()), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit unsigned integer.");
+            return 0;
+        }
+        return result;
+    }
 
     // Fast case. The value is a 32-bit signed integer with NormalConversion configuration.
-    if (value->IsInt32() && configuration == NormalConversion)
-        return value->Int32Value();
+    if (value->IsInt32() && configuration == NormalConversion) {
+        int32_t result;
+        if (!getValueFromMaybe(value->Int32Value(exceptionState.isolate()->GetCurrentContext()), result)) {
+            exceptionState.throwTypeError("Cannot convert to a 32 bit integer.");
+            return 0;
+        }
+        return result;
+    }
 
     return toUInt32Slow(value, configuration, exceptionState);
 }
 
 inline uint32_t toUInt32(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     return toUInt32(value, NormalConversion, exceptionState);
 }
 
 // Convert a value to a 32-bit unsigned integer assuming the conversion cannot fail.
@@ skipping 22 matching lines @@
 
 // Convert a value to a 64-bit unsigned integer assuming the conversion cannot fail.
 uint64_t toUInt64(v8::Handle<v8::Value>);
 
 // Convert a value to a double precision float, which might fail.
 double toDoubleSlow(v8::Handle<v8::Value>, ExceptionState&);
 
 inline double toDouble(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     if (value->IsNumber())
-        return value->NumberValue();
+        return value.As<v8::Number>()->Value();
     return toDoubleSlow(value, exceptionState);
 }
 
 // Convert a value to a double precision float, throwing on non-finite values.
 double toRestrictedDouble(v8::Handle<v8::Value>, ExceptionState&);
 
 // Convert a value to a single precision float, which might fail.
 inline float toFloat(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     return static_cast<float>(toDouble(value, exceptionState));
 }
 
 // Convert a value to a single precision float, throwing on non-finite values.
 float toRestrictedFloat(v8::Handle<v8::Value>, ExceptionState&);
 
 // Converts a value to a String, throwing if any code unit is outside 0-255.
 String toByteString(v8::Handle<v8::Value>, ExceptionState&);
 
 // Converts a value to a String, replacing unmatched UTF-16 surrogates with replacement characters.
 String toUSVString(v8::Handle<v8::Value>, ExceptionState&);
 
 inline v8::Handle<v8::Boolean> v8Boolean(bool value, v8::Isolate* isolate)
 {
     return value ? v8::True(isolate) : v8::False(isolate);
 }
 
 inline double toCoreDate(v8::Handle<v8::Value> object)
 {
     if (object->IsDate())
-        return v8::Handle<v8::Date>::Cast(object)->ValueOf();
+        return object.As<v8::Date>()->ValueOf();
     if (object->IsNumber())
-        return object->NumberValue();
+        return object.As<v8::Number>()->Value();
     return std::numeric_limits<double>::quiet_NaN();
 }
 
 inline v8::Handle<v8::Value> v8DateOrNaN(double value, v8::Isolate* isolate)
 {
     ASSERT(isolate);
     return v8::Date::New(isolate, std::isfinite(value) ? value : std::numeric_limits<double>::quiet_NaN());
 }
 
 // FIXME: Remove the special casing for NodeFilter and XPathNSResolver.
@@ skipping 493 matching lines @@
 
 // Callback functions used by generated code.
 void v8ConstructorAttributeGetterAsProperty(v8::Local<v8::String> propertyName, const v8::PropertyCallbackInfo<v8::Value>&);
 void v8ConstructorAttributeGetterAsAccessor(const v8::FunctionCallbackInfo<v8::Value>&);
 
 typedef void (*InstallTemplateFunction)(v8::Local<v8::FunctionTemplate>, v8::Isolate*);
 
 } // namespace blink
 
 #endif // V8Binding_h