Convert serialized values to ints if they are whole and less than 53 bits.

Source/bindings/dart/DartUtilities.cpp

 // Copyright 2011, 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 32 matching lines @@
 #include "core/dom/Document.h"
 #include "core/html/canvas/DataView.h"
 #include "core/inspector/ScriptArguments.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/FrameLoader.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/Frame.h"
 #include "core/platform/network/ResourceRequest.h"
 #include "core/platform/sql/SQLValue.h"
 
+#include <math.h>
+
 #include <wtf/ArrayBufferView.h>
 #include <wtf/Float32Array.h>
 #include <wtf/Float64Array.h>
 #include <wtf/Int16Array.h>
 #include <wtf/Int32Array.h>
 #include <wtf/Int8Array.h>
 #include <wtf/RefCounted.h>
 #include <wtf/Uint16Array.h>
 #include <wtf/Uint32Array.h>
 #include <wtf/Uint8Array.h>
@@ skipping 211 matching lines @@
         return 0;
     if (value < 0) {
         exception = Dart_NewStringFromCString("value out of range");
         return 0;
     }
     return value;
 }
 
 Dart_Handle DartUtilities::numberToDart(double value)
 {
-    int intValue = static_cast<int>(value);
-    if (value == intValue)
+    int64_t intValue = static_cast<int64_t>(value);
+    // JS can store integer values that are no greater than 2^53.
+    if (value == intValue && abs(intValue) <= pow(2, 53))

[sra1, 2013/10/17 21:40:31]

I would avoid calling pow and define a constant
kMaxExactDouble = 9007199254740991;  // 2^53-1

2^53 is the first integer that has who mathematical integers folded onto it,
hence the -1 above.  (Math.pow(2,53) == Math.pow(2,53)+1  in the chrome
console).

First compare the range because that avoids problems with infinites and NaN
values.

if (value >= -kMaxExactDouble || value <= kMaxExactDouble) {
  // now see if there is a fraction part
}

[Emily Fortuna, 2013/10/17 22:42:51]

Gotcha. Sorry I was going off of this:
http://ecma262-5.com/ELS5_HTML.htm#Section_8.5 "Note that all the positive and
negative integers whose magnitude is no greater than 253 are representable in
the Number type"

         return intToDart(intValue);
     return doubleToDart(value);
 }
 
 ScriptValue DartUtilities::dartToScriptValue(Dart_Handle object, Dart_Handle& exception)
 {
     return ScriptValue(V8Converter::toV8(object, exception));
 }
 
 Dart_Handle DartUtilities::scriptValueToDart(const ScriptValue& value)
@@ skipping 803 matching lines @@
     Dart_PersistentHandle library = domData->htmlLibrary();
     ASSERT(!Dart_IsError(library));
 
     Dart_Handle utilsClass = Dart_GetType(library, Dart_NewStringFromCString("_Utils"), 0, 0);
     ASSERT(!Dart_IsError(utilsClass));
 
     return Dart_Invoke(utilsClass, Dart_NewStringFromCString(methodName), argCount, args);
 }
 
 }