Have handleMaxRecursionDepthExceeded() take an isolate in argument

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 118 matching lines @@
         ASSERT(context->isWorkerGlobalScope());
         state = scriptStateFromWorkerGlobalScope(toWorkerGlobalScope(context));
     }
     ASSERT(state);
 
     v8::Isolate* isolate = state->isolate();
     v8::HandleScope handleScope(isolate);
     v8::Handle<v8::Context> v8Context = state->context();
     v8::Context::Scope scope(v8Context);
     v8::Handle<v8::Value> args[] = { m_result.newLocal(isolate) };
-    V8ScriptRunner::callFunction(m_callback.newLocal(isolate), context, m_receiver.newLocal(isolate), WTF_ARRAY_LENGTH(args), args);
+    V8ScriptRunner::callFunction(m_callback.newLocal(isolate), context, m_receiver.newLocal(isolate), WTF_ARRAY_LENGTH(args), args, isolate);
 };
 
 v8::Handle<v8::Value> postTask(v8::Handle<v8::Function> callback, v8::Handle<v8::Object> receiver, v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     ScriptExecutionContext* scriptExecutionContext = getScriptExecutionContext();
     ASSERT(scriptExecutionContext && scriptExecutionContext->isContextThread());
     scriptExecutionContext->postTask(adoptPtr(new PromiseTask(callback, receiver, value)));
     return v8::Undefined(isolate);
 }
 
 void wrapperCallback(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> promise = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseIndex).As<v8::Object>();
     v8::Local<v8::Object> resolver = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentPromiseResolverIndex).As<v8::Object>();
     v8::Local<v8::Function> callback = environment->GetInternalField(V8PromiseCustom::WrapperCallbackEnvironmentCallbackIndex).As<v8::Function>();
 
     v8::Local<v8::Value> argv[] = {
         result,
     };
     v8::TryCatch trycatch;
-    result = V8ScriptRunner::callFunction(callback, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv);
+    result = V8ScriptRunner::callFunction(callback, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv, isolate);
     if (result.IsEmpty()) {
         V8PromiseCustom::rejectResolver(resolver, trycatch.Exception(), V8PromiseCustom::Synchronous, isolate);
         return;
     }
     V8PromiseCustom::resolveResolver(resolver, result, V8PromiseCustom::Synchronous, isolate);
 }
 
 v8::Local<v8::Object> wrapperCallbackEnvironment(v8::Handle<v8::Object> promise, v8::Handle<v8::Object> resolver, v8::Handle<v8::Function> callback, v8::Isolate* isolate)
 {
     v8::Local<v8::ObjectTemplate> objectTemplate = wrapperCallbackEnvironmentObjectTemplate(isolate);
@@ skipping 119 matching lines @@
         throwTypeError("Promise constructor takes a function argument", isolate);
         return;
     }
     v8::Local<v8::Function> init = args[0].As<v8::Function>();
     v8::Local<v8::Object> promise, resolver;
     V8PromiseCustom::createPromise(args.Holder(), &promise, &resolver, isolate);
     v8::Handle<v8::Value> argv[] = {
         resolver,
     };
     v8::TryCatch trycatch;
-    if (V8ScriptRunner::callFunction(init, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv).IsEmpty()) {
+    if (V8ScriptRunner::callFunction(init, getScriptExecutionContext(), promise, WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty()) {
         // An exception is thrown. Reject the promise if its resolved flag is unset.
         if (!V8PromiseCustom::isInternalDetached(resolver) && V8PromiseCustom::getState(V8PromiseCustom::getInternal(resolver)) == V8PromiseCustom::Pending)
             V8PromiseCustom::rejectResolver(resolver, trycatch.Exception(), V8PromiseCustom::Asynchronous, isolate);
     }
     v8SetReturnValue(args, promise);
     return;
 }
 
 void V8Promise::thenMethodCustom(const v8::FunctionCallbackInfo<v8::Value>& args)
 {
@@ skipping 208 matching lines @@
         }
     }
 
     if (!then.IsEmpty() && then->IsFunction()) {
         ASSERT(result->IsObject());
         v8::TryCatch trycatch;
         v8::Handle<v8::Value> argv[] = {
             createClosure(promiseResolveCallback, resolver),
             createClosure(promiseRejectCallback, resolver),
         };
-        if (V8ScriptRunner::callFunction(then.As<v8::Function>(), getScriptExecutionContext(), result.As<v8::Object>(), WTF_ARRAY_LENGTH(argv), argv).IsEmpty())
+        if (V8ScriptRunner::callFunction(then.As<v8::Function>(), getScriptExecutionContext(), result.As<v8::Object>(), WTF_ARRAY_LENGTH(argv), argv, isolate).IsEmpty())
             rejectResolver(resolver, trycatch.Exception(), mode, isolate);
         return;
     }
 
     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))
@@ skipping 83 matching lines @@
     internal->SetInternalField(V8PromiseCustom::InternalStateIndex, v8::Integer::New(state));
 }
 
 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);
+        V8ScriptRunner::callFunction(function, getScriptExecutionContext(), receiver, WTF_ARRAY_LENGTH(args), args, isolate);
     } else {
         ASSERT(mode == Asynchronous);
         postTask(function, receiver, result, isolate);
     }
 }
 
 } // namespace WebCore