Use v8::MicrotasksScope internally in V8RecursionScope.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "bindings/core/v8/ScriptPromiseProperty.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 263 matching lines @@
         ScriptState::Scope scope(otherScriptState());
         otherPromise.then(stub(currentScriptState(), otherActual, nOtherResolveCalls), notReached(currentScriptState()));
     }
 
     EXPECT_NE(promise, otherPromise);
 
     GarbageCollectedScriptWrappable* value = new GarbageCollectedScriptWrappable("value");
     getProperty()->resolve(value);
     EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(1u, nOtherResolveCalls);
     EXPECT_EQ(wrap(mainWorld(), value), actual);
     EXPECT_NE(actual, otherActual);
     EXPECT_EQ(wrap(otherWorld(), value), otherActual);
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, ResolveAndGetPromiseOnOtherWorld)
 {
     ScriptPromise promise = getProperty()->promise(DOMWrapperWorld::mainWorld());
     ScriptPromise otherPromise = getProperty()->promise(otherWorld());
     ScriptValue actual, otherActual;
     size_t nResolveCalls = 0;
     size_t nOtherResolveCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
         promise.then(stub(currentScriptState(), actual, nResolveCalls), notReached(currentScriptState()));
     }
 
     EXPECT_NE(promise, otherPromise);
     GarbageCollectedScriptWrappable* value = new GarbageCollectedScriptWrappable("value");
     getProperty()->resolve(value);
     EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(0u, nOtherResolveCalls);
 
     {
         ScriptState::Scope scope(otherScriptState());
         otherPromise.then(stub(currentScriptState(), otherActual, nOtherResolveCalls), notReached(currentScriptState()));
     }
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(1u, nOtherResolveCalls);
     EXPECT_EQ(wrap(mainWorld(), value), actual);
     EXPECT_NE(actual, otherActual);
     EXPECT_EQ(wrap(otherWorld(), value), otherActual);
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Reject_RejectsScriptPromise)
 {
     GarbageCollectedScriptWrappable* reason = new GarbageCollectedScriptWrappable("reason");
     getProperty()->reject(reason);
     EXPECT_EQ(Property::Rejected, getProperty()->getState());
 
     ScriptValue actual, otherActual;
     size_t nRejectCalls = 0;
     size_t nOtherRejectCalls = 0;
     {
         ScriptState::Scope scope(mainScriptState());
         getProperty()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), actual, nRejectCalls));
     }
 
     {
         ScriptState::Scope scope(otherScriptState());
         getProperty()->promise(otherWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), otherActual, nOtherRejectCalls));
     }
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nRejectCalls);
     EXPECT_EQ(wrap(mainWorld(), reason), actual);
     EXPECT_EQ(1u, nOtherRejectCalls);
     EXPECT_NE(actual, otherActual);
     EXPECT_EQ(wrap(otherWorld(), reason), otherActual);
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_DeadContext)
 {
     getProperty()->resolve(new GarbageCollectedScriptWrappable("value"));
@@ skipping 10 matching lines @@
         ScriptState::Scope scope(mainScriptState());
         getProperty()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), notReached(currentScriptState()));
     }
 
     destroyContext();
     EXPECT_TRUE(!getProperty()->getExecutionContext() || getProperty()->getExecutionContext()->activeDOMObjectsAreStopped());
 
     getProperty()->resolve(new GarbageCollectedScriptWrappable("value"));
     EXPECT_EQ(Property::Pending, getProperty()->getState());
 
-    v8::Isolate::GetCurrent()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(v8::Isolate::GetCurrent());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Reset)
 {
     ScriptPromise oldPromise, newPromise;
     ScriptValue oldActual, newActual;
     GarbageCollectedScriptWrappable* oldValue = new GarbageCollectedScriptWrappable("old");
     GarbageCollectedScriptWrappable* newValue = new GarbageCollectedScriptWrappable("new");
     size_t nOldResolveCalls = 0;
     size_t nNewRejectCalls = 0;
@@ skipping 10 matching lines @@
     {
         ScriptState::Scope scope(mainScriptState());
         newPromise = getProperty()->promise(mainWorld());
         newPromise.then(notReached(currentScriptState()), stub(currentScriptState(), newActual, nNewRejectCalls));
         getProperty()->reject(newValue);
     }
 
     EXPECT_EQ(0u, nOldResolveCalls);
     EXPECT_EQ(0u, nNewRejectCalls);
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nOldResolveCalls);
     EXPECT_EQ(1u, nNewRejectCalls);
     EXPECT_NE(oldPromise, newPromise);
     EXPECT_EQ(wrap(mainWorld(), oldValue), oldActual);
     EXPECT_EQ(wrap(mainWorld(), newValue), newActual);
     EXPECT_NE(oldActual, newActual);
 }
 
 // Tests that ScriptPromiseProperty works with a ref-counted holder.
 class ScriptPromisePropertyRefCountedTest : public ScriptPromisePropertyTestBase, public ::testing::Test {
@@ skipping 19 matching lines @@
 
     {
         ScriptState::Scope scope(mainScriptState());
         getProperty()->promise(DOMWrapperWorld::mainWorld()).then(stub(currentScriptState(), actual, nResolveCalls), notReached(currentScriptState()));
     }
 
     RefPtr<RefCountedScriptWrappable> value = RefCountedScriptWrappable::create("value");
     getProperty()->resolve(value.get());
     EXPECT_EQ(Property::Resolved, getProperty()->getState());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nResolveCalls);
     EXPECT_EQ(wrap(mainWorld(), value), actual);
 }
 
 TEST_F(ScriptPromisePropertyRefCountedTest, Reject)
 {
     ScriptValue actual;
     size_t nRejectCalls = 0;
 
     {
         ScriptState::Scope scope(mainScriptState());
         getProperty()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), stub(currentScriptState(), actual, nRejectCalls));
     }
 
     RefPtr<RefCountedScriptWrappable> reason = RefCountedScriptWrappable::create("reason");
     getProperty()->reject(reason);
     EXPECT_EQ(Property::Rejected, getProperty()->getState());
 
-    isolate()->RunMicrotasks();
+    v8::MicrotasksScope::PerformCheckpoint(isolate());
     EXPECT_EQ(1u, nRejectCalls);
     EXPECT_EQ(wrap(mainWorld(), reason), actual);
 }
 
 TEST_F(ScriptPromisePropertyRefCountedTest, ReSolveAndReset)
 {
     RefPtr<RefCountedScriptWrappable> value = RefCountedScriptWrappable::create("value");
 
     {
         ScriptState::Scope scope(mainScriptState());
@@ skipping 29 matching lines @@
         typedef ScriptPromiseProperty<Member<GarbageCollectedScriptWrappable>, T, ToV8UndefinedGenerator> Property;
         Property* property = new Property(&document(), new GarbageCollectedScriptWrappable("holder"), Property::Ready);
         size_t nResolveCalls = 0;
         ScriptValue actualValue;
         String actual;
         {
             ScriptState::Scope scope(mainScriptState());
             property->promise(DOMWrapperWorld::mainWorld()).then(stub(currentScriptState(), actualValue, nResolveCalls), notReached(currentScriptState()));
         }
         property->resolve(value);
-        isolate()->RunMicrotasks();
+        v8::MicrotasksScope::PerformCheckpoint(isolate());
         {
             ScriptState::Scope scope(mainScriptState());
             actual = toCoreString(actualValue.v8Value()->ToString(mainScriptState()->context()).ToLocalChecked());
         }
         if (expected != actual) {
             ADD_FAILURE_AT(file, line) << "toV8 returns an incorrect value.\n  Actual: " << actual.utf8().data() << "\nExpected: " << expected;
             return;
         }
     }
 };
 
 TEST_F(ScriptPromisePropertyNonScriptWrappableResolutionTargetTest, ResolveWithUndefined)
 {
     test(ToV8UndefinedGenerator(), "undefined", __FILE__, __LINE__);
 }
 
 TEST_F(ScriptPromisePropertyNonScriptWrappableResolutionTargetTest, ResolveWithString)
 {
     test(String("hello"), "hello", __FILE__, __LINE__);
 }
 
 TEST_F(ScriptPromisePropertyNonScriptWrappableResolutionTargetTest, ResolveWithInteger)
 {
     test(-1, "-1", __FILE__, __LINE__);
 }
 
 } // namespace