Fix IdleNotification to correctly free objects.

test/cctest/test-api.cc

 // Copyright 2011 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 13377 matching lines @@
   bool rv = false;
   for (int i = 0; i < 100; i++) {
     rv = v8::V8::IdleNotification();
     if (rv)
       break;
   }
   CHECK(rv == true);
 }
 
 
+class Point {
+ public:
+    static int counter;
+
+    Point(int x, int y) : x_(x), y_(y) { ++counter; }
+    ~Point() { --counter; }
+
+ private:
+    int x_, y_;
+};
+
+int Point::counter = 0;
+
+static void weakPointCallback(Persistent<Value> object, void* parameter) {
+    Point* point = static_cast<Point*>(parameter);
+    delete point;
+
+    object.Dispose();
+    object.Clear();
+
+    V8::AdjustAmountOfExternalAllocatedMemory(-static_cast<int>(sizeof(Point)));
+}
+
+static Handle<Value> makeWeakPoint(const Arguments& args) {
+    CHECK(args.IsConstructCall());
+
+    Local<Object> self = args.This();
+    CHECK_EQ(1, self->InternalFieldCount());
+
+    Point *point = new Point(10, 20);
+    self->SetPointerInInternalField(0, point);
+    V8::AdjustAmountOfExternalAllocatedMemory(static_cast<int>(sizeof(Point)));
+
+    Persistent<Object> weak_self = Persistent<Object>::New(self);
+    weak_self.MakeWeak(point, weakPointCallback);
+
+    return weak_self;
+}
+
+// Test that idle notification correctly force garbage collection.
+THREADED_TEST(IdleNotificationForceGC) {
+  HandleScope scope;
+  LocalContext context;
+
+  Local<FunctionTemplate> fun_templ =
+      FunctionTemplate::New(makeWeakPoint);
+  Handle<ObjectTemplate> point_templ = fun_templ->InstanceTemplate();
+  point_templ->SetInternalFieldCount(1);
+
+  context->Global()->Set(String::New("Point"), fun_templ->GetFunction());
+
+  for (int i = 1000; i < 800000; i += 50000) {
+    context->Global()->Set(String::New("counter"), v8::Int32::New(i));
+
+    {
+      HandleScope scope;
+      CompileRun("for (i = 0; i < counter; ++i) { new Point(); }");
+    }
+
+    while (!V8::IdleNotification()) { }
+
+    CHECK_EQ(0, Point::counter);
+  }
+}
+
+
 static uint32_t* stack_limit;
 
 static v8::Handle<Value> GetStackLimitCallback(const v8::Arguments& args) {
   stack_limit = reinterpret_cast<uint32_t*>(
       i::Isolate::Current()->stack_guard()->real_climit());
   return v8::Undefined();
 }
 
 
 // Uses the address of a local variable to determine the stack top now.
@@ skipping 2116 matching lines @@
   CHECK(i->Equals(CompileRun("'abcbd'.replace(/b/g,func)[3]")));
 
   // TODO(1547): Make the following also return "i".
   // Calling with environment record as base.
   TestReceiver(o, context->Global(), "func()");
   // Calling with no base.
   TestReceiver(o, context->Global(), "(1,func)()");
 
   foreign_context.Dispose();
 }