Do not run GC in ScriptPromisePropertyBase::destroyContext().

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 "config.h"
 #include "bindings/core/v8/ScriptPromiseProperty.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 113 matching lines @@
 public:
     ScriptPromisePropertyTestBase()
         : m_page(DummyPageHolder::create(IntSize(1, 1)))
     {
         v8::HandleScope handleScope(isolate());
         m_otherScriptState = ScriptStateForTesting::create(v8::Context::New(isolate()), DOMWrapperWorld::ensureIsolatedWorld(isolate(), 1, -1));
     }
 
     virtual ~ScriptPromisePropertyTestBase()
     {
-        ScriptPromisePropertyTestBase::destroyContext();
+        destroyContext();
     }
 
     Document& document() { return m_page->document(); }
     v8::Isolate* isolate() { return toIsolate(&document()); }
     ScriptState* mainScriptState() { return ScriptState::forMainWorld(document().frame()); }
     DOMWrapperWorld& mainWorld() { return mainScriptState()->world(); }
     ScriptState* otherScriptState() { return m_otherScriptState.get(); }
     DOMWrapperWorld& otherWorld() { return m_otherScriptState->world(); }
     ScriptState* currentScriptState() { return ScriptState::current(isolate()); }
 
-    virtual void destroyContext()
+    void destroyContext()
     {
         m_page.clear();
         if (m_otherScriptState) {
             m_otherScriptState->disposePerContextData();
             m_otherScriptState = nullptr;
         }
-        gc();
-        Heap::collectAllGarbage();
     }
 
     void gc() { V8GCController::collectGarbage(v8::Isolate::GetCurrent()); }
 
     v8::Local<v8::Function> notReached(ScriptState* scriptState) { return NotReached::createFunction(scriptState); }
     v8::Local<v8::Function> stub(ScriptState* scriptState, ScriptValue& value, size_t& callCount) { return StubFunction::createFunction(scriptState, value, callCount); }
 
     template <typename T>
     ScriptValue wrap(DOMWrapperWorld& world, const T& value)
     {
@@ skipping 17 matching lines @@
 
     ScriptPromisePropertyGarbageCollectedTest()
         : m_holder(new GarbageCollectedHolder(&document()))
     {
     }
 
     GarbageCollectedHolder* holder() { return m_holder; }
     Property* property() { return m_holder->property(); }
     ScriptPromise promise(DOMWrapperWorld& world) { return property()->promise(world); }
 
-    void destroyContext() override
-    {
-        m_holder = nullptr;
-        ScriptPromisePropertyTestBase::destroyContext();
-    }
-
 private:
     Persistent<GarbageCollectedHolder> m_holder;
 };
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Promise_IsStableObjectInMainWorld)
 {
     ScriptPromise v = property()->promise(DOMWrapperWorld::mainWorld());
     ScriptPromise w = property()->promise(DOMWrapperWorld::mainWorld());
     EXPECT_EQ(v, w);
     ASSERT_FALSE(v.isEmpty());
@@ skipping 148 matching lines @@
     isolate()->RunMicrotasks();
     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)
 {
-    Persistent<Property> property = this->property();
-    property->resolve(new GarbageCollectedScriptWrappable("value"));
-    EXPECT_EQ(Property::Resolved, property->state());
+    property()->resolve(new GarbageCollectedScriptWrappable("value"));
+    EXPECT_EQ(Property::Resolved, property()->state());
 
     destroyContext();
 
-    EXPECT_TRUE(property->promise(DOMWrapperWorld::mainWorld()).isEmpty());
+    EXPECT_TRUE(property()->promise(DOMWrapperWorld::mainWorld()).isEmpty());
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Resolve_DeadContext)
 {
-    Persistent<Property> property = this->property();
-
     {
         ScriptState::Scope scope(mainScriptState());
-        property->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), notReached(currentScriptState()));
+        property()->promise(DOMWrapperWorld::mainWorld()).then(notReached(currentScriptState()), notReached(currentScriptState()));
     }
 
     destroyContext();
-    EXPECT_TRUE(!property->executionContext() || property->executionContext()->activeDOMObjectsAreStopped());
+    EXPECT_TRUE(!property()->executionContext() || property()->executionContext()->activeDOMObjectsAreStopped());
 
-    property->resolve(new GarbageCollectedScriptWrappable("value"));
-    EXPECT_EQ(Property::Pending, property->state());
+    property()->resolve(new GarbageCollectedScriptWrappable("value"));
+    EXPECT_EQ(Property::Pending, property()->state());
 
     v8::Isolate::GetCurrent()->RunMicrotasks();
 }
 
 TEST_F(ScriptPromisePropertyGarbageCollectedTest, Reset)
 {
     ScriptPromise oldPromise, newPromise;
     ScriptValue oldActual, newActual;
     GarbageCollectedScriptWrappable* oldValue = new GarbageCollectedScriptWrappable("old");
     GarbageCollectedScriptWrappable* newValue = new GarbageCollectedScriptWrappable("new");
@@ skipping 149 matching lines @@
 {
     test(String("hello"), "hello", __FILE__, __LINE__);
 }
 
 TEST_F(ScriptPromisePropertyNonScriptWrappableResolutionTargetTest, ResolveWithInteger)
 {
     test(-1, "-1", __FILE__, __LINE__);
 }
 
 } // namespace