Pass isolate to v8 integers factory functions

Source/bindings/v8/IDBBindingUtilities.cpp

 /*
  * Copyright (C) 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 56 matching lines @@
             return array;
         }
     }
 
     ASSERT_NOT_REACHED();
     return v8Undefined();
 }
 
 static const size_t maximumDepth = 2000;
 
-static PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value, Vector<v8::Handle<v8::Array> >& stack)
+static PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value, Vector<v8::Handle<v8::Array> >& stack, v8::Isolate* isolate)
 {
     if (value->IsNumber() && !std::isnan(value->NumberValue()))
         return IDBKey::createNumber(value->NumberValue());
     if (value->IsString())
         return IDBKey::createString(toWebCoreString(value));
     if (value->IsDate() && !std::isnan(value->NumberValue()))
         return IDBKey::createDate(value->NumberValue());
     if (value->IsArray()) {
         v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
 
         if (stack.contains(array))
             return 0;
         if (stack.size() >= maximumDepth)
             return 0;
         stack.append(array);
 
         IDBKey::KeyArray subkeys;
         uint32_t length = array->Length();
         for (uint32_t i = 0; i < length; ++i) {
-            v8::Local<v8::Value> item = array->Get(v8::Int32::New(i));
-            RefPtr<IDBKey> subkey = createIDBKeyFromValue(item, stack);
+            v8::Local<v8::Value> item = array->Get(v8::Int32::New(i, isolate));
+            RefPtr<IDBKey> subkey = createIDBKeyFromValue(item, stack, isolate);
             if (!subkey)
                 subkeys.append(IDBKey::createInvalid());
             else
                 subkeys.append(subkey);
         }
 
         stack.removeLast();
         return IDBKey::createArray(subkeys);
     }
     return 0;
 }
 
-PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value)
+static PassRefPtr<IDBKey> createIDBKeyFromValue(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     Vector<v8::Handle<v8::Array> > stack;
-    RefPtr<IDBKey> key = createIDBKeyFromValue(value, stack);
+    RefPtr<IDBKey> key = createIDBKeyFromValue(value, stack, isolate);
     if (key)
         return key;
     return IDBKey::createInvalid();
 }
 
 template<typename T>
 static bool getValueFrom(T indexOrName, v8::Handle<v8::Value>& v8Value)
 {
     v8::Local<v8::Object> object = v8Value->ToObject();
     if (!object->Has(indexOrName))
@@ skipping 85 matching lines @@
     IDBKeyPathParseError error;
     IDBParseKeyPath(keyPath, keyPathElements, error);
     ASSERT(error == IDBKeyPathParseErrorNone);
     ASSERT(v8::Context::InContext());
 
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::Value> v8Value(value.v8Value());
     v8::Handle<v8::Value> v8Key(getNthValueOnKeyPath(v8Value, keyPathElements, keyPathElements.size(), isolate));
     if (v8Key.IsEmpty())
         return 0;
-    return createIDBKeyFromValue(v8Key);
+    return createIDBKeyFromValue(v8Key, isolate);
 }
 
 PassRefPtr<IDBKey> createIDBKeyFromScriptValueAndKeyPath(DOMRequestState* state, const ScriptValue& value, const IDBKeyPath& keyPath)
 {
     IDB_TRACE("createIDBKeyFromScriptValueAndKeyPath");
     ASSERT(!keyPath.isNull());
     ASSERT(v8::Context::InContext());
 
 
     v8::Isolate* isolate = state ? state->context()->GetIsolate() : v8::Isolate::GetCurrent();
@@ skipping 92 matching lines @@
     v8::Handle<v8::Value> v8Value(idbKeyToV8Value(key.get(), state->context()->GetIsolate()));
     return ScriptValue(v8Value);
 }
 
 PassRefPtr<IDBKey> scriptValueToIDBKey(DOMRequestState* state, const ScriptValue& scriptValue)
 {
     ASSERT(v8::Context::InContext());
     v8::Isolate* isolate = state ? state->context()->GetIsolate() : v8::Isolate::GetCurrent();
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::Value> v8Value(scriptValue.v8Value());
-    return createIDBKeyFromValue(v8Value);
+    return createIDBKeyFromValue(v8Value, isolate);
 }
 
 PassRefPtr<IDBKeyRange> scriptValueToIDBKeyRange(DOMRequestState* state, const ScriptValue& scriptValue)
 {
     v8::Isolate* isolate = state ? state->context()->GetIsolate() : v8::Isolate::GetCurrent();
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::Value> value(scriptValue.v8Value());
     if (V8IDBKeyRange::HasInstance(value, isolate, worldType(isolate)))
         return V8IDBKeyRange::toNative(value.As<v8::Object>());
     return 0;
 }
 
 } // namespace WebCore