Use v8::MicrotasksScope internally in V8RecursionScope.

third_party/WebKit/Source/bindings/core/v8/ScriptPromiseTest.cpp

 /*
  * Copyright (C) 2014 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 65 matching lines @@
         : m_scope(v8::Isolate::GetCurrent())
     {
     }
 
     ~ScriptPromiseTest()
     {
         // FIXME: We put this statement here to clear an exception from the isolate.
         createClosure(callback, v8::Undefined(m_scope.isolate()), m_scope.isolate());
 
         // Execute all pending microtasks
-        isolate()->RunMicrotasks();
+        v8::MicrotasksScope::PerformCheckpoint(isolate());
     }
 
     String toString(const ScriptValue& value)
     {
         return toCoreString(value.v8Value()->ToString(getScriptState()->context()).ToLocalChecked());
     }
 
     Vector<String> toStringArray(const ScriptValue& value)
     {
         NonThrowableExceptionState exceptionState;
@@ skipping 20 matching lines @@
 {
     Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     resolver.resolve(v8String(isolate(), "hello"));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ("hello", toString(onFulfilled));
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, resolveThen)
 {
     Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
     resolver.resolve(v8String(isolate(), "hello"));
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ("hello", toString(onFulfilled));
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, thenReject)
 {
     Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     resolver.reject(v8String(isolate(), "hello"));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("hello", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, rejectThen)
 {
     Resolver resolver(getScriptState());
     ScriptPromise promise = resolver.promise();
     ScriptValue onFulfilled, onRejected;
     resolver.reject(v8String(isolate(), "hello"));
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("hello", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, castPromise)
 {
     ScriptPromise promise = Resolver(getScriptState()).promise();
     ScriptPromise newPromise = ScriptPromise::cast(getScriptState(), promise.v8Value());
 
@@ skipping 16 matching lines @@
     EXPECT_NE(promise1.v8Value(), promise2.v8Value());
 
     ASSERT_TRUE(promise1.v8Value()->IsPromise());
     ASSERT_TRUE(promise2.v8Value()->IsPromise());
 
     EXPECT_TRUE(onFulfilled1.isEmpty());
     EXPECT_TRUE(onFulfilled2.isEmpty());
     EXPECT_TRUE(onRejected1.isEmpty());
     EXPECT_TRUE(onRejected2.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_EQ("hello", toString(onFulfilled1));
     EXPECT_EQ("hello", toString(onFulfilled2));
     EXPECT_TRUE(onRejected1.isEmpty());
     EXPECT_TRUE(onRejected2.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, reject)
 {
     ScriptValue onFulfilled, onRejected;
 
     ScriptValue value = ScriptValue(getScriptState(), v8String(isolate(), "hello"));
     ScriptPromise promise = ScriptPromise::reject(getScriptState(), ScriptValue(value));
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     ASSERT_TRUE(promise.v8Value()->IsPromise());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("hello", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, rejectWithExceptionState)
 {
     ScriptValue onFulfilled, onRejected;
     ScriptPromise promise = ScriptPromise::rejectWithDOMException(getScriptState(), DOMException::create(SyntaxError, "some syntax error"));
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     ASSERT_FALSE(promise.isEmpty());
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_EQ("SyntaxError: some syntax error", toString(onRejected));
 }
 
 TEST_F(ScriptPromiseTest, allWithEmptyPromises)
 {
     ScriptValue onFulfilled, onRejected;
 
     ScriptPromise promise = ScriptPromise::all(getScriptState(), Vector<ScriptPromise>());
     ASSERT_FALSE(promise.isEmpty());
 
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_FALSE(onFulfilled.isEmpty());
     EXPECT_TRUE(toStringArray(onFulfilled).isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, allWithResolvedPromises)
 {
     ScriptValue onFulfilled, onRejected;
 
     Vector<ScriptPromise> promises;
     promises.append(ScriptPromise::cast(getScriptState(), v8String(isolate(), "hello")));
     promises.append(ScriptPromise::cast(getScriptState(), v8String(isolate(), "world")));
 
     ScriptPromise promise = ScriptPromise::all(getScriptState(), promises);
     ASSERT_FALSE(promise.isEmpty());
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_FALSE(onFulfilled.isEmpty());
     Vector<String> values = toStringArray(onFulfilled);
     EXPECT_EQ(2u, values.size());
     EXPECT_EQ("hello", values[0]);
     EXPECT_EQ("world", values[1]);
     EXPECT_TRUE(onRejected.isEmpty());
 }
 
 TEST_F(ScriptPromiseTest, allWithRejectedPromise)
 {
     ScriptValue onFulfilled, onRejected;
 
     Vector<ScriptPromise> promises;
     promises.append(ScriptPromise::cast(getScriptState(), v8String(isolate(), "hello")));
     promises.append(ScriptPromise::reject(getScriptState(), v8String(isolate(), "world")));
 
     ScriptPromise promise = ScriptPromise::all(getScriptState(), promises);
     ASSERT_FALSE(promise.isEmpty());
     promise.then(Function::createFunction(getScriptState(), &onFulfilled), Function::createFunction(getScriptState(), &onRejected));
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_TRUE(onRejected.isEmpty());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
 
     EXPECT_TRUE(onFulfilled.isEmpty());
     EXPECT_FALSE(onRejected.isEmpty());
     EXPECT_EQ("world", toString(onRejected));
 }
 
 } // namespace
 
 } // namespace blink