Remove GC prologue and epilogue callbacks.

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/dart_api_impl.h"
 #include "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
@@ skipping 1213 matching lines @@
     EXPECT_EQ(expected[i], utf8_encoded_reversed[i]);
   }
 }
 
 // Helper class to ensure new gen GC is triggered without any side effects.
 // The normal call to CollectGarbage(Heap::kNew) could potentially trigger
 // an old gen collection if there is a promotion failure and this could
 // perturb the test.
 class GCTestHelper : public AllStatic {
  public:
-  static void CollectNewSpace(Heap::ApiCallbacks api_callbacks) {
-    bool invoke_api_callbacks = (api_callbacks == Heap::kInvokeApiCallbacks);
-    Isolate::Current()->heap()->new_space()->Scavenge(invoke_api_callbacks);
+  static void CollectNewSpace() {
+    Isolate::Current()->heap()->new_space()->Scavenge();
   }
 
   static void WaitForGCTasks() {
     Thread* thread = Thread::Current();
     PageSpace* old_space = thread->isolate()->heap()->old_space();
     MonitorLocker ml(old_space->tasks_lock());
     while (old_space->tasks() > 0) {
       ml.WaitWithSafepointCheck(thread);
     }
   }
@@ skipping 1431 matching lines @@
 
     // Create a weak ref to the old space object.
     weak_old_ref = Dart_NewWeakPersistentHandle(old_ref, NULL, 0,
                                                 WeakPersistentHandleCallback);
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
 
     {
       TransitionNativeToVM transition(thread);
       // Garbage collect new space.
-      GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+      GCTestHelper::CollectNewSpace();
     }
 
     // Nothing should be invalidated or cleared.
     EXPECT_VALID(new_ref);
     EXPECT(!Dart_IsNull(new_ref));
     EXPECT_VALID(old_ref);
     EXPECT(!Dart_IsNull(old_ref));
 
     EXPECT_VALID(AsHandle(weak_new_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
@@ skipping 23 matching lines @@
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
     EXPECT(Dart_IdentityEquals(old_ref, AsHandle(weak_old_ref)));
 
     // Delete local (strong) references.
     Dart_ExitScope();
   }
 
   {
     TransitionNativeToVM transition(thread);
     // Garbage collect new space again.
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    GCTestHelper::CollectNewSpace();
     GCTestHelper::WaitForGCTasks();
   }
 
   {
     Dart_EnterScope();
     // Weak ref to new space object should now be cleared.
     EXPECT(weak_new_ref == NULL);
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
     Dart_ExitScope();
@@ skipping 58 matching lines @@
     weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     EXPECT_VALID(AsHandle(weak_ref));
     EXPECT(peer == 0);
     Dart_ExitScope();
   }
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(peer == 0);
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    GCTestHelper::CollectNewSpace();
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 42);
   }
 }
 
 TEST_CASE(DartAPI_WeakPersistentHandleNoCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
     weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     Dart_ExitScope();
   }
   // A finalizer is not invoked on a deleted handle.  Therefore, the
   // peer value should not change after the referent is collected.
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak_ref);
   EXPECT(peer == 0);
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(peer == 0);
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    GCTestHelper::CollectNewSpace();
     GCTestHelper::WaitForGCTasks();
     EXPECT(peer == 0);
   }
 }
 
 VM_UNIT_TEST_CASE(DartAPI_WeakPersistentHandlesCallbackShutdown) {
   TestCase::CreateTestIsolate();
   Dart_EnterScope();
   Dart_Handle ref = Dart_True();
   int peer = 1234;
@@ skipping 31 matching lines @@
                                          NopCallback);
     EXPECT_VALID(AsHandle(strong_ref));
     Dart_ExitScope();
   }
   {
     TransitionNativeToVM transition(thread);
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
     EXPECT(heap->ExternalInWords(Heap::kNew) ==
            (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
     // Collect weakly referenced string, and promote strongly referenced string.
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    GCTestHelper::CollectNewSpace();
+    GCTestHelper::CollectNewSpace();
     GCTestHelper::WaitForGCTasks();
     EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
     EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak2ExternalSize / kWordSize);
   }
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   Dart_DeleteWeakPersistentHandle(isolate, weak2);
   Dart_DeletePersistentHandle(strong_ref);
   {
     TransitionNativeToVM transition(thread);
@@ skipping 170 matching lines @@
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
     EXPECT_VALID(AsHandle(weak2));
     EXPECT_VALID(AsHandle(weak3));
     Dart_ExitScope();
   }
 
   {
     TransitionNativeToVM transition(thread);
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    GCTestHelper::CollectNewSpace();
   }
 
   {
     Dart_EnterScope();
     // New space collection should not affect old space objects
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     Dart_ExitScope();
@@ skipping 57 matching lines @@
   {
     Dart_EnterScope();
     // Old space collection should not affect old space objects.
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     Dart_ExitScope();
   }
 }
 
-static int global_prologue_callback_status;
-
-static void PrologueCallbackTimes2() {
-  global_prologue_callback_status *= 2;
-}
-
-static void PrologueCallbackTimes3() {
-  global_prologue_callback_status *= 3;
-}
-
-static int global_epilogue_callback_status;
-
-static void EpilogueCallbackNOP() {}
-
-static void EpilogueCallbackTimes4() {
-  global_epilogue_callback_status *= 4;
-}
-
-static void EpilogueCallbackTimes5() {
-  global_epilogue_callback_status *= 5;
-}
-
-TEST_CASE(DartAPI_SetGarbageCollectionCallbacks) {
-  // GC callback addition testing.
-
-  // Add GC callbacks.
-  EXPECT_VALID(
-      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4));
-
-  // Add the same callbacks again.  This is an error.
-  EXPECT(Dart_IsError(
-      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4)));
-
-  // Add another callback. This is an error.
-  EXPECT(Dart_IsError(
-      Dart_SetGcCallbacks(&PrologueCallbackTimes3, &EpilogueCallbackTimes5)));
-
-  // GC callback removal testing.
-
-  // Remove GC callbacks.
-  EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
-
-  // Remove GC callbacks whennone exist.  This is an error.
-  EXPECT(Dart_IsError(Dart_SetGcCallbacks(NULL, NULL)));
-
-  EXPECT_VALID(
-      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4));
-  EXPECT(Dart_IsError(Dart_SetGcCallbacks(&PrologueCallbackTimes2, NULL)));
-  EXPECT(Dart_IsError(Dart_SetGcCallbacks(NULL, &EpilogueCallbackTimes4)));
-}
-
-TEST_CASE(DartAPI_SingleGarbageCollectionCallback) {
-  // Add a prologue callback.
-  EXPECT_VALID(
-      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackNOP));
-
-  {
-    TransitionNativeToVM transition(thread);
-
-    // Garbage collect new space ignoring callbacks.  This should not
-    // invoke the prologue callback.  No status values should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-    EXPECT_EQ(3, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-
-    // Garbage collect new space invoking callbacks.  This should
-    // invoke the prologue callback.  No status values should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
-    EXPECT_EQ(6, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-
-    // Garbage collect old space ignoring callbacks.  This should invoke
-    // the prologue callback.  The prologue status value should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    Isolate::Current()->heap()->CollectGarbage(
-        Heap::kOld, Heap::kIgnoreApiCallbacks, Heap::kGCTestCase);
-    EXPECT_EQ(3, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-
-    // Garbage collect old space.  This should invoke the prologue
-    // callback.  The prologue status value should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-    EXPECT_EQ(6, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-
-    // Garbage collect old space again.  Callbacks are persistent so the
-    // prologue status value should change again.
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-    EXPECT_EQ(12, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-  }
-
-  // Add an epilogue callback.
-  EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
-  EXPECT_VALID(
-      Dart_SetGcCallbacks(&PrologueCallbackTimes2, &EpilogueCallbackTimes4));
-
-  {
-    TransitionNativeToVM transition(thread);
-    // Garbage collect new space.  This should not invoke the prologue
-    // or the epilogue callback.  No status values should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-    EXPECT_EQ(3, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-
-    // Garbage collect new space.  This should invoke the prologue and
-    // the epilogue callback.  The prologue and epilogue status values
-    // should change.
-    GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
-    EXPECT_EQ(6, global_prologue_callback_status);
-    EXPECT_EQ(28, global_epilogue_callback_status);
-
-    // Garbage collect old space.  This should invoke the prologue and
-    // the epilogue callbacks.  The prologue and epilogue status values
-    // should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-    EXPECT_EQ(6, global_prologue_callback_status);
-    EXPECT_EQ(28, global_epilogue_callback_status);
-
-    // Garbage collect old space again without invoking callbacks.
-    // Nothing should change.
-    Isolate::Current()->heap()->CollectGarbage(
-        Heap::kOld, Heap::kIgnoreApiCallbacks, Heap::kGCTestCase);
-    EXPECT_EQ(6, global_prologue_callback_status);
-    EXPECT_EQ(28, global_epilogue_callback_status);
-
-    // Garbage collect old space again.  Callbacks are persistent so the
-    // prologue and epilogue status values should change again.
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-    EXPECT_EQ(12, global_prologue_callback_status);
-    EXPECT_EQ(112, global_epilogue_callback_status);
-  }
-
-  // Remove the prologue and epilogue callbacks
-  EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
-
-  {
-    TransitionNativeToVM transition(thread);
-    // Garbage collect old space.  No callbacks should be invoked.  No
-    // status values should change.
-    global_prologue_callback_status = 3;
-    global_epilogue_callback_status = 7;
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-    EXPECT_EQ(3, global_prologue_callback_status);
-    EXPECT_EQ(7, global_epilogue_callback_status);
-  }
-}
-
 // Unit test for creating multiple scopes and local handles within them.
 // Ensure that the local handles get all cleaned out when exiting the
 // scope.
 VM_UNIT_TEST_CASE(DartAPI_LocalHandles) {
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   EXPECT(isolate != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_Handle handles[300];
@@ skipping 5848 matching lines @@
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
   result = Dart_Invoke(lib, NewString("foozoo"), 0, NULL);
   EXPECT(Dart_IsError(result));
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart