IDL: Add toRestricted{Float,Double}() helpers to V8Binding.h

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 501 matching lines @@
 {
     NonThrowableExceptionState exceptionState;
     return toUInt64(value, NormalConversion, exceptionState);
 }
 
 float toFloat(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     return static_cast<float>(toDouble(value, exceptionState));
 }
 
+float toRestrictedFloat(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+{
+    float numberValue = toFloat(value, exceptionState);
+    if (exceptionState.hadException())
+        return 0;
+    if (!std::isfinite(numberValue)) {
+        exceptionState.throwTypeError("The provided float value is non-finite.");

[a.suchit2, 2015/02/20 15:03:12]

Why are we not throwing NotSupportedError from here based on specification
www.w3.org/TR/2dcontext/

Many of the canvas API should throw NotSupportedError in the case of
infinite/Nan. Because control never goes to our code for throwing these
exceptions based on specifications.

[Jens Widell, 2015/02/20 15:16:46]

We're throwing TypeError here because that's what WebIDL says to do, and WebIDL
is the specification this code primarily implements.

The specification you link to is probably simply wrong. (And also probably
obsolete: don't read /TR/ specifications!) The description of the API in
http://html.spec.whatwg.org/ does not say to throw NotSupportedError (except in
a non-normative section, which in turn is probably simply a bug). The
specification you link also says

  "Interfaces are defined in terms of Web IDL."

which is incompatible with requiring that a different type of exception should
be throw in error conditions also covered by Web IDL.

[a.suchit2, 2015/02/21 09:35:26]

Thanks Jens

+        return 0;
+    }
+    return numberValue;
+}
+
 double toDouble(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     if (value->IsNumber())
         return value->NumberValue();
 
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     v8::TryCatch block(isolate);
     v8::Local<v8::Number> numberObject(value->ToNumber(isolate));
     if (block.HasCaught()) {
         exceptionState.rethrowV8Exception(block.Exception());
         return 0;
     }
     return numberObject->NumberValue();
 }
 
+double toRestrictedDouble(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+{
+    double numberValue = toDouble(value, exceptionState);
+    if (exceptionState.hadException())
+        return 0;
+    if (!std::isfinite(numberValue)) {
+        exceptionState.throwTypeError("The provided double value is non-finite.");

[a.suchit2, 2015/02/20 15:03:12]

same as above.

+        return 0;
+    }
+    return 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();
 
@@ skipping 459 matching lines @@
 PassRefPtr<TraceEvent::ConvertableToTraceFormat> devToolsTraceEventData(v8::Isolate* isolate, ExecutionContext* context, v8::Handle<v8::Function> function)
 {
     int scriptId = 0;
     String resourceName;
     int lineNumber = 1;
     GetDevToolsFunctionInfo(function, isolate, scriptId, resourceName, lineNumber);
     return InspectorFunctionCallEvent::data(context, scriptId, resourceName, lineNumber);
 }
 
 } // namespace blink