[bindings] Make sure v8::Isolate is being passed to toXXX() conversion routines as argument.

Source/bindings/scripts/v8_types.py

 # Copyright (C) 2013 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
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 450 matching lines @@
 def set_component_dirs(new_component_dirs):
     component_dir.update(new_component_dirs)
 
 
 ################################################################################
 # V8 -> C++
 ################################################################################
 
 V8_VALUE_TO_CPP_VALUE = {
     # Basic
-    'Date': 'toCoreDate({v8_value})',
+    'Date': 'toCoreDate({isolate}, {v8_value})',
     'DOMString': '{v8_value}',
-    'ByteString': 'toByteString({arguments})',
-    'USVString': 'toUSVString({arguments})',
+    'ByteString': 'toByteString({isolate}, {arguments})',
+    'USVString': 'toUSVString({isolate}, {arguments})',
     'boolean': '{v8_value}->BooleanValue()',
-    'float': 'toRestrictedFloat({arguments})',
-    'unrestricted float': 'toFloat({arguments})',
-    'double': 'toRestrictedDouble({arguments})',
-    'unrestricted double': 'toDouble({arguments})',
-    'byte': 'toInt8({arguments})',
-    'octet': 'toUInt8({arguments})',
-    'short': 'toInt16({arguments})',
-    'unsigned short': 'toUInt16({arguments})',
-    'long': 'toInt32({arguments})',
-    'unsigned long': 'toUInt32({arguments})',
-    'long long': 'toInt64({arguments})',
-    'unsigned long long': 'toUInt64({arguments})',
+    'float': 'toRestrictedFloat({isolate}, {arguments})',
+    'unrestricted float': 'toFloat({isolate}, {arguments})',
+    'double': 'toRestrictedDouble({isolate}, {arguments})',
+    'unrestricted double': 'toDouble({isolate}, {arguments})',
+    'byte': 'toInt8({isolate}, {arguments})',
+    'octet': 'toUInt8({isolate}, {arguments})',
+    'short': 'toInt16({isolate}, {arguments})',
+    'unsigned short': 'toUInt16({isolate}, {arguments})',
+    'long': 'toInt32({isolate}, {arguments})',
+    'unsigned long': 'toUInt32({isolate}, {arguments})',
+    'long long': 'toInt64({isolate}, {arguments})',
+    'unsigned long long': 'toUInt64({isolate}, {arguments})',
     # Interface types
     'Dictionary': 'Dictionary({v8_value}, {isolate}, exceptionState)',
     'EventTarget': 'toEventTarget({isolate}, {v8_value})',
     'NodeFilter': 'toNodeFilter({v8_value}, info.Holder(), ScriptState::current({isolate}))',
     'Promise': 'ScriptPromise::cast(ScriptState::current({isolate}), {v8_value})',
     'SerializedScriptValue': 'SerializedScriptValueFactory::instance().create({v8_value}, 0, 0, exceptionState, {isolate})',
     'ScriptValue': 'ScriptValue(ScriptState::current({isolate}), {v8_value})',
     'Window': 'toDOMWindow({isolate}, {v8_value})',
     'XPathNSResolver': 'toXPathNSResolver({isolate}, {v8_value})',
 }
@@ skipping 44 matching lines @@
     base_idl_type = idl_type.as_union_type.name if idl_type.is_union_type else idl_type.base_type
 
     if 'EnforceRange' in extended_attributes:
         arguments = ', '.join([v8_value, 'EnforceRange', 'exceptionState'])
     elif 'Clamp' in extended_attributes:
         arguments = ', '.join([v8_value, 'Clamp', 'exceptionState'])
     elif idl_type.v8_conversion_needs_exception_state:
         arguments = ', '.join([v8_value, 'exceptionState'])
     else:
         arguments = v8_value
-
     if base_idl_type in V8_VALUE_TO_CPP_VALUE:
         cpp_expression_format = V8_VALUE_TO_CPP_VALUE[base_idl_type]
     elif idl_type.is_array_buffer_or_view:
         cpp_expression_format = (
             '{v8_value}->Is{idl_type}() ? '
             'V8{idl_type}::toImpl(v8::Local<v8::{idl_type}>::Cast({v8_value})) : 0')
     elif idl_type.use_output_parameter_for_result:
         if idl_type.includes_nullable_type:
             base_idl_type = idl_type.cpp_type + 'OrNull'
         cpp_expression_format = 'V8{idl_type}::toImpl({isolate}, {v8_value}, {variable_name}, exceptionState)'
@@ skipping 404 matching lines @@
     number_of_nullable_member_types_union)
 
 
 def includes_nullable_type_union(idl_type):
     # http://heycam.github.io/webidl/#dfn-includes-a-nullable-type
     return idl_type.number_of_nullable_member_types == 1
 
 IdlTypeBase.includes_nullable_type = False
 IdlNullableType.includes_nullable_type = True
 IdlUnionType.includes_nullable_type = property(includes_nullable_type_union)