Add support for byte and octet Web IDL types to the bindings generator

Source/bindings/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 97 matching lines @@
     for (size_t i = 0; i < length; ++i)
         result.append(args[i]);
     return result;
 }
 
 PassRefPtr<NodeFilter> toNodeFilter(v8::Handle<v8::Value> callback)
 {
     return NodeFilter::create(V8NodeFilterCondition::create(callback));
 }
 
+static const int8_t kMaxInt8 = 127;
+static const int8_t kMinInt8 = -128;
+static const uint8_t kMaxUInt8 = 255;
 const int32_t kMaxInt32 = 0x7fffffff;
 const int32_t kMinInt32 = -kMaxInt32 - 1;
 const uint32_t kMaxUInt32 = 0xffffffff;
 const int64_t kJSMaxInteger = 0x20000000000000LL - 1; // 2^53 - 1, maximum integer exactly representable in ECMAScript.
 
 static double enforceRange(double x, double minimum, double maximum, bool& ok)
 {
     if (std::isnan(x) || std::isinf(x)) {
         ok = false;
         return 0;
     }
     x = trunc(x);
     if (x < minimum || x > maximum) {
         ok = false;
         return 0;
     }
     return x;
 }
 
+int8_t toInt8(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, bool& ok)
+{
+    ok = true;
+
+    // Fast case. The value is already a 32-bit integer - possibly in right range?
+    if (value->IsInt32()) {
+        int32_t result = value->Int32Value();
+        if (result >= kMinInt8 && result <= kMaxInt8)
+            return static_cast<int8_t>(result);
+        if (configuration == EnforceRange) {
+            ok = false;
+            return 0;
+        }
+        result %= 256; // 2^8.
+        return static_cast<int8_t>(result > kMaxInt8 ? result - 256 : result);
+    }
+
+    // Can the value be converted to a number?
+    v8::Local<v8::Number> numberObject = value->ToNumber();
+    if (numberObject.IsEmpty()) {
+        ok = false;
+        return 0;
+    }
+
+    if (configuration == EnforceRange)
+        return enforceRange(numberObject->Value(), kMinInt8, kMaxInt8, ok);
+
+    double numberValue = numberObject->Value();
+    if (std::isnan(numberValue) || std::isinf(numberValue) || !numberValue)
+        return 0;
+
+    numberValue = numberValue < 0 ? -floor(abs(numberValue)) : floor(abs(numberValue));
+    numberValue = fmod(numberValue, 256); // 2^8.
+
+    return static_cast<int8_t>(numberValue > kMaxInt8 ? numberValue - 256 : numberValue);
+}
+
+uint8_t toUInt8(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, bool& ok)
+{
+    ok = true;
+
+    // Fast case. The value is a 32-bit unsigned integer - possibly in right range?
+    if (value->IsUint32()) {

[haraken, 2013/06/13 14:45:30]

I'd remove this branch. The range that IsInt32() cannot cover but IsUint32() can
cover is just [2^31, 2^32). It wouldn't be worth adding a fast path for such
uncommon cases.

+        uint32_t result = value->Uint32Value();
+        if (result <= kMaxUInt8)
+            return static_cast<uint8_t>(result);
+        if (configuration == EnforceRange) {
+            ok = false;
+            return 0;
+        }
+        return static_cast<uint8_t>(result % 256); // 2^8.
+    }
+
+    // Fast case. The value is a 32-bit signed integer - possibly positive?
+    if (value->IsInt32()) {
+        int32_t result = value->Int32Value();
+        if (result >= 0 && result <= kMaxUInt8)
+            return static_cast<uint8_t>(result);
+        if (configuration == EnforceRange) {
+            ok = false;
+            return 0;
+        }
+        return static_cast<uint8_t>(result % 256); // 2^8.
+    }
+
+    // Can the value be converted to a number?
+    v8::Local<v8::Number> numberObject = value->ToNumber();
+    if (numberObject.IsEmpty()) {
+        ok = false;
+        return 0;
+    }
+
+    if (configuration == EnforceRange)
+        return enforceRange(numberObject->Value(), 0, kMaxUInt8, ok);
+
+    // Does the value convert to nan or to an infinity?
+    double numberValue = numberObject->Value();
+    if (std::isnan(numberValue) || std::isinf(numberValue) || !numberValue)
+        return 0;
+
+    numberValue = numberValue < 0 ? -floor(abs(numberValue)) : floor(abs(numberValue));
+    return static_cast<uint8_t>(fmod(numberValue, 256)); // 2^8.
+}
+
 int32_t toInt32(v8::Handle<v8::Value> value, IntegerConversionConfiguration configuration, bool& ok)
 {
     ok = true;
 
     // Fast case. The value is already a 32-bit integer.
     if (value->IsInt32())
         return value->Int32Value();
 
     // Can the value be converted to a number?
     v8::Local<v8::Number> numberObject = value->ToNumber();
@@ skipping 280 matching lines @@
     if (!DOMWrapperWorld::isolatedWorldsExist())
         return MainWorld;
     ASSERT(!v8::Context::GetEntered().IsEmpty());
     DOMWrapperWorld* isolatedWorld = DOMWrapperWorld::isolatedWorld(v8::Context::GetEntered());
     if (isolatedWorld)
         return IsolatedWorld;
     return MainWorld;
 }
 
 } // namespace WebCore