Pass isolate to v8 integers factory functions

Source/bindings/v8/custom/V8PromiseCustom.cpp

 /*
  * 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
@@ skipping 229 matching lines @@
     v8::Local<v8::Array> results = environment->GetInternalField(V8PromiseCustom::PromiseEveryEnvironmentResultsIndex).As<v8::Array>();
 
     results->Set(index->Value(), result);
 
     v8::Local<v8::Integer> countdown = countdownWrapper->GetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex).As<v8::Integer>();
     ASSERT(countdown->Value() >= 1);
     if (countdown->Value() == 1) {
         V8PromiseCustom::resolveResolver(resolver, results, V8PromiseCustom::Synchronous, isolate);
         return;
     }
-    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(countdown->Value() - 1));
+    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(countdown->Value() - 1, isolate));
 }
 
 void promiseSomeRejectCallback(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     ASSERT(!args.Data().IsEmpty());
     v8::Local<v8::Object> environment = args.Data().As<v8::Object>();
     v8::Local<v8::Value> result = v8::Undefined(isolate);
     if (args.Length() > 0)
         result = args[0];
 
     v8::Local<v8::Object> resolver = environment->GetInternalField(V8PromiseCustom::PromiseEveryEnvironmentPromiseResolverIndex).As<v8::Object>();
     v8::Local<v8::Object> countdownWrapper = environment->GetInternalField(V8PromiseCustom::PromiseEveryEnvironmentCountdownIndex).As<v8::Object>();
     v8::Local<v8::Integer> index = environment->GetInternalField(V8PromiseCustom::PromiseEveryEnvironmentIndexIndex).As<v8::Integer>();
     v8::Local<v8::Array> results = environment->GetInternalField(V8PromiseCustom::PromiseEveryEnvironmentResultsIndex).As<v8::Array>();
 
     results->Set(index->Value(), result);
 
     v8::Local<v8::Integer> countdown = countdownWrapper->GetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex).As<v8::Integer>();
     ASSERT(countdown->Value() >= 1);
     if (countdown->Value() == 1) {
         V8PromiseCustom::rejectResolver(resolver, results, V8PromiseCustom::Synchronous, isolate);
         return;
     }
-    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(countdown->Value() - 1));
+    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(countdown->Value() - 1, isolate));
 }
 
 v8::Local<v8::Object> promiseEveryEnvironment(v8::Handle<v8::Object> resolver, v8::Handle<v8::Object> countdownWrapper, int index, v8::Handle<v8::Array> results, v8::Isolate* isolate)
 {
     v8::Local<v8::ObjectTemplate> objectTemplate = promiseEveryEnvironmentObjectTemplate(isolate);
     v8::Local<v8::Object> environment = objectTemplate->NewInstance();
 
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentPromiseResolverIndex, resolver);
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentCountdownIndex, countdownWrapper);
-    environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentIndexIndex, v8::Integer::New(index));
+    environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentIndexIndex, v8::Integer::New(index, isolate));
     environment->SetInternalField(V8PromiseCustom::PromiseEveryEnvironmentResultsIndex, results);
     return environment;
 }
 
 } // namespace
 
 void V8Promise::constructorCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8SetReturnValue(args, v8::Local<v8::Value>());
     v8::Isolate* isolate = args.GetIsolate();
@@ skipping 136 matching lines @@
     V8PromiseCustom::createPromise(args.Holder(), &promise, &resolver, isolate);
 
     if (!args.Length()) {
         V8PromiseCustom::resolveResolver(resolver, v8::Undefined(isolate), V8PromiseCustom::Asynchronous, isolate);
         v8SetReturnValue(args, promise);
         return;
     }
 
     v8::Local<v8::ObjectTemplate> objectTemplate = primitiveWrapperObjectTemplate(isolate);
     v8::Local<v8::Object> countdownWrapper = objectTemplate->NewInstance();
-    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(args.Length()));
+    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(args.Length(), isolate));
     v8::Local<v8::Array> results = v8::Array::New();
 
     v8::Local<v8::Function> rejectCallback = createClosure(promiseRejectCallback, resolver);
     for (int i = 0; i < args.Length(); ++i) {
         v8::Local<v8::Object> environment = promiseEveryEnvironment(resolver, countdownWrapper, i, results, isolate);
         v8::Local<v8::Function> fulfillCallback = v8::FunctionTemplate::New(promiseEveryFulfillCallback, environment)->GetFunction();
         v8::Local<v8::Object> eachPromise, eachResolver;
         V8PromiseCustom::createPromise(args.Holder(), &eachPromise, &eachResolver, isolate);
         V8PromiseCustom::resolveResolver(eachResolver, args[i], V8PromiseCustom::Asynchronous, isolate);
         V8PromiseCustom::append(eachPromise, fulfillCallback, rejectCallback, isolate);
     }
     v8SetReturnValue(args, promise);
 }
 
 void V8Promise::someMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
     v8::Isolate* isolate = args.GetIsolate();
     v8::Local<v8::Object> promise, resolver;
     V8PromiseCustom::createPromise(args.Holder(), &promise, &resolver, isolate);
 
     if (!args.Length()) {
         V8PromiseCustom::resolveResolver(resolver, v8::Undefined(isolate), V8PromiseCustom::Asynchronous, isolate);
         v8SetReturnValue(args, promise);
         return;
     }
 
     // Promise.some also uses PromiseEveryEnvironment.
     v8::Local<v8::ObjectTemplate> objectTemplate = primitiveWrapperObjectTemplate(isolate);
     v8::Local<v8::Object> countdownWrapper = objectTemplate->NewInstance();
-    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(args.Length()));
+    countdownWrapper->SetInternalField(V8PromiseCustom::PrimitiveWrapperPrimitiveIndex, v8::Integer::New(args.Length(), isolate));
     v8::Local<v8::Array> results = v8::Array::New();
 
     v8::Local<v8::Function> fulfillCallback = createClosure(promiseResolveCallback, resolver);
     for (int i = 0; i < args.Length(); ++i) {
         v8::Local<v8::Object> environment = promiseEveryEnvironment(resolver, countdownWrapper, i, results, isolate);
         v8::Local<v8::Object> eachPromise, eachResolver;
         v8::Local<v8::Function> rejectCallback = v8::FunctionTemplate::New(promiseSomeRejectCallback, environment)->GetFunction();
         V8PromiseCustom::createPromise(args.Holder(), &eachPromise, &eachResolver, isolate);
         V8PromiseCustom::resolveResolver(eachResolver, args[i], V8PromiseCustom::Asynchronous, isolate);
         V8PromiseCustom::append(eachPromise, fulfillCallback, rejectCallback, isolate);
     }
     v8SetReturnValue(args, promise);
 }
 
 //
 // -- V8PromiseCustom --
 void V8PromiseCustom::createPromise(v8::Handle<v8::Object> creationContext, v8::Local<v8::Object>* promise, v8::Local<v8::Object>* resolver, v8::Isolate* isolate)
 {
     v8::Local<v8::ObjectTemplate> internalTemplate = internalObjectTemplate(isolate);
     v8::Local<v8::Object> internal = internalTemplate->NewInstance();
     *promise = V8DOMWrapper::createWrapper(creationContext, &V8Promise::info, 0, isolate);
     *resolver = V8DOMWrapper::createWrapper(creationContext, &V8PromiseResolver::info, 0, isolate);
 
-    clearInternal(internal, V8PromiseCustom::Pending, v8::Undefined(isolate));
+    clearInternal(internal, V8PromiseCustom::Pending, v8::Undefined(isolate), isolate);
 
     (*promise)->SetInternalField(v8DOMWrapperObjectIndex, internal);
     (*resolver)->SetInternalField(v8DOMWrapperObjectIndex, internal);
 }
 
 void V8PromiseCustom::fulfillResolver(v8::Handle<v8::Object> resolver, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
 {
     if (isInternalDetached(resolver))
         return;
     v8::Local<v8::Object> internal = getInternal(resolver);
     ASSERT(getState(internal) == Pending || getState(internal) == PendingWithResolvedFlagSet);
     v8::Local<v8::Array> callbacks = internal->GetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex).As<v8::Array>();
-    clearInternal(internal, Fulfilled, result);
+    clearInternal(internal, Fulfilled, result, isolate);
     detachInternal(resolver, isolate);
 
     callCallbacks(callbacks, result, mode, isolate);
 }
 
 void V8PromiseCustom::resolveResolver(v8::Handle<v8::Object> resolver, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
 {
     ASSERT(!result.IsEmpty());
     v8::Local<v8::Value> then;
     if (result->IsObject()) {
@@ skipping 21 matching lines @@
     fulfillResolver(resolver, result, mode, isolate);
 }
 
 void V8PromiseCustom::rejectResolver(v8::Handle<v8::Object> resolver, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
 {
     if (isInternalDetached(resolver))
         return;
     v8::Local<v8::Object> internal = getInternal(resolver);
     ASSERT(getState(internal) == Pending || getState(internal) == PendingWithResolvedFlagSet);
     v8::Local<v8::Array> callbacks = internal->GetInternalField(V8PromiseCustom::InternalRejectCallbackIndex).As<v8::Array>();
-    clearInternal(internal, Rejected, result);
+    clearInternal(internal, Rejected, result, isolate);
     detachInternal(resolver, isolate);
 
     callCallbacks(callbacks, result, mode, isolate);
 }
 
 void V8PromiseCustom::append(v8::Handle<v8::Object> promise, v8::Handle<v8::Function> fulfillCallback, v8::Handle<v8::Function> rejectCallback, v8::Isolate* isolate)
 {
     // fulfillCallback and rejectCallback can be empty.
     v8::Local<v8::Object> internal = getInternal(promise);
 
@@ skipping 38 matching lines @@
     v8::Local<v8::Value> value = resolver->GetInternalField(v8DOMWrapperObjectIndex);
     ASSERT(!value.IsEmpty());
     return value->IsUndefined();
 }
 
 void V8PromiseCustom::detachInternal(v8::Handle<v8::Object> resolver, v8::Isolate* isolate)
 {
     resolver->SetInternalField(v8DOMWrapperObjectIndex, v8::Undefined(isolate));
 }
 
-void V8PromiseCustom::clearInternal(v8::Handle<v8::Object> internal, PromiseState state, v8::Handle<v8::Value> value)
+void V8PromiseCustom::clearInternal(v8::Handle<v8::Object> internal, PromiseState state, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
-    setState(internal, state);
+    setState(internal, state, isolate);
     internal->SetInternalField(V8PromiseCustom::InternalResultIndex, value);
     internal->SetInternalField(V8PromiseCustom::InternalFulfillCallbackIndex, v8::Array::New());
     internal->SetInternalField(V8PromiseCustom::InternalRejectCallbackIndex, v8::Array::New());
 }
 
 V8PromiseCustom::PromiseState V8PromiseCustom::getState(v8::Handle<v8::Object> internal)
 {
     v8::Handle<v8::Value> value = internal->GetInternalField(V8PromiseCustom::InternalStateIndex);
     bool ok = false;
     uint32_t number = toInt32(value, ok);
     ASSERT(ok && (number == Pending || number == Fulfilled || number == Rejected || number == PendingWithResolvedFlagSet));
     return static_cast<PromiseState>(number);
 }
 
-void V8PromiseCustom::setState(v8::Handle<v8::Object> internal, PromiseState state)
+void V8PromiseCustom::setState(v8::Handle<v8::Object> internal, PromiseState state, v8::Isolate* isolate)
 {
     ASSERT(state == Pending || state == Fulfilled || state == Rejected || state == PendingWithResolvedFlagSet);
-    internal->SetInternalField(V8PromiseCustom::InternalStateIndex, v8::Integer::New(state));
+    internal->SetInternalField(V8PromiseCustom::InternalStateIndex, v8::Integer::New(state, isolate));
 }
 
 void V8PromiseCustom::call(v8::Handle<v8::Function> function, v8::Handle<v8::Object> receiver, v8::Handle<v8::Value> result, SynchronousMode mode, v8::Isolate* isolate)
 {
     if (mode == Synchronous) {
         v8::Context::Scope scope(isolate->GetCurrentContext());
         // If an exception is thrown, catch it and do nothing.
         v8::TryCatch trycatch;
         v8::Handle<v8::Value> args[] = { result };
         V8ScriptRunner::callFunction(function, getScriptExecutionContext(), receiver, WTF_ARRAY_LENGTH(args), args, isolate);
     } else {
         ASSERT(mode == Asynchronous);
         postTask(function, receiver, result, isolate);
     }
 }
 
 } // namespace WebCore