Unflakify SetJitCodeEventHandler test case.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 11671 matching lines @@
   }
 }
 
 
 static bool MatchPointers(void* key1, void* key2) {
   return key1 == key2;
 }
 
 
 TEST(SetJitCodeEventHandler) {
+  i::FLAG_stress_compaction = true;
   const char* script =
     "function bar() {"
     "  var sum = 0;"
     "  for (i = 0; i < 100; ++i)"
     "    sum = foo(i);"
     "  return sum;"
     "}"
     "function foo(i) { return i * i; };"
     "bar();";
 
   // Run this test in a new isolate to make sure we don't
   // have remnants of state from other code.
   v8::Isolate* isolate = v8::Isolate::New();
   isolate->Enter();
 
   {
+    v8::HandleScope scope;
     i::HashMap code(MatchPointers);
     code_map = &code;
 
     saw_bar = 0;
     move_events = 0;
 
-    i::FLAG_stress_compaction = true;
     V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, event_handler);
 
-    v8::HandleScope scope;
     // Generate new code objects sparsely distributed across several
     // different fragmented code-space pages.
     const int kIterations = 10;
     for (int i = 0; i < kIterations; ++i) {
       LocalContext env;
+      i::AlwaysAllocateScope always_allocate;
+      SimulateFullSpace(HEAP->code_space());
+      CompileRun(script);
 
-      v8::Handle<v8::Script> compiled_script;
-      {
-        i::AlwaysAllocateScope always_allocate;
-        SimulateFullSpace(HEAP->code_space());
-        compiled_script = v8_compile(script);
-      }
-      compiled_script->Run();
+      // Keep a strong reference to the code object in the handle scope.
+      i::Handle<i::Code> bar_code(i::Handle<i::JSFunction>::cast(
+          v8::Utils::OpenHandle(*env->Global()->Get(v8_str("bar"))))->code());
+      i::Handle<i::Code> foo_code(i::Handle<i::JSFunction>::cast(
+          v8::Utils::OpenHandle(*env->Global()->Get(v8_str("foo"))))->code());
 
       // Clear the compilation cache to get more wastage.
       ISOLATE->compilation_cache()->Clear();
     }
 
     // Force code movement.
     HEAP->CollectAllAvailableGarbage("TestSetJitCodeEventHandler");
 
+    V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, NULL);
+
     CHECK_LE(kIterations, saw_bar);
-    CHECK_NE(0, move_events);
+    CHECK_LT(0, move_events);
 
     code_map = NULL;
-    V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, NULL);
   }
 
   isolate->Exit();
   isolate->Dispose();
 
   // Do this in a new isolate.
   isolate = v8::Isolate::New();
   isolate->Enter();
 
   // Verify that we get callbacks for existing code objects when we
   // request enumeration of existing code.
   {
     v8::HandleScope scope;
     LocalContext env;
     CompileRun(script);
 
     // Now get code through initial iteration.
     i::HashMap code(MatchPointers);
     code_map = &code;
 
     V8::SetJitCodeEventHandler(v8::kJitCodeEventEnumExisting, event_handler);
     V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault, NULL);
 
-    code_map = NULL;
-
     // We expect that we got some events. Note that if we could get code removal
     // notifications, we could compare two collections, one created by listening
     // from the time of creation of an isolate, and the other by subscribing
     // with EnumExisting.
-    CHECK_NE(0, code.occupancy());
+    CHECK_LT(0, code.occupancy());
+
+    code_map = NULL;
   }
 
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 static int64_t cast(intptr_t x) { return static_cast<int64_t>(x); }
 
 
@@ skipping 6432 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32