Release stack trace data after firing Error.stack accessor.

test/cctest/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
 #include "global-handles.h"
@@ skipping 2165 matching lines @@
   CHECK(ic_before->ic_state() == MEGAMORPHIC);
 
   // Fire context dispose notification.
   v8::V8::ContextDisposedNotification();
   SimulateIncrementalMarking();
   HEAP->CollectAllGarbage(Heap::kNoGCFlags);
 
   Code* ic_after = FindFirstIC(f->shared()->code(), Code::LOAD_IC);
   CHECK(ic_after->ic_state() == UNINITIALIZED);
 }
+
+
+class SourceResource: public v8::String::ExternalAsciiStringResource {
+ public:
+  explicit SourceResource(const char* data, int* counter)
+    : data_(data), length_(strlen(data)), counter_(counter) { }
+
+  virtual void Dispose() {
+    i::DeleteArray(data_);
+    if (counter_ != NULL) ++*counter_;
+  }
+
+  const char* data() const { return data_; }
+
+  size_t length() const { return length_; }
+
+ private:
+  const char* data_;
+  size_t length_;
+  int* counter_;
+};
+
+
+
+TEST(ReleaseStackTraceData) {
+  // Test that the data retained by the Error.stack accessor is released
+  // after the first time the accessor is fired.  We use external string
+  // to check whether the data is being released since the external string
+  // resource's callback is fired when the external string is GC'ed.
+  InitializeVM();
+  v8::HandleScope scope;
+  static const char* source = "var error = 1;       "
+                              "try {                "
+                              "  throw new Error(); "
+                              "} catch (e) {        "
+                              "  error = e;         "
+                              "}                    ";
+  int counter = 0;
+  SourceResource* resource = new SourceResource(i::StrDup(source), &counter);
+  {
+    v8::HandleScope scope;
+    v8::Handle<v8::String> source_string = v8::String::NewExternal(resource);
+    v8::Script::Compile(source_string)->Run();
+    CHECK(counter == 0);
+  }
+  HEAP->CollectAllAvailableGarbage();
+  CHECK(counter == 0);  // External source is being retained by the stack trace.
+
+  CompileRun("error.stack;");
+  HEAP->CollectAllAvailableGarbage();
+  CHECK(counter == 1);  // External source has been released.
+
+  delete resource;

[Vyacheslav Egorov (Google), 2012/08/28 16:43:43]

thanks for writing a test!

+}