Introduce a way to grab heap stats.

test/cctest/test-heap-profiler.cc

Index: test/cctest/test-heap-profiler.cc
diff --git a/test/cctest/test-heap-profiler.cc b/test/cctest/test-heap-profiler.cc
index 3f5e07d5b3dc48db1595625e4a434d1bee5b8e39..c909034130b20baeaee3857bf4703f02c6c8d111 100644
--- a/test/cctest/test-heap-profiler.cc
+++ b/test/cctest/test-heap-profiler.cc
@@ -557,9 +557,14 @@ class TestJSONStream : public v8::OutputStream {
     memcpy(chunk.start(), buffer, chars_written);
     return kContinue;
   }
+  virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int chars_written) {
+    ASSERT(false);
+    return kAbort;
+  }
   void WriteTo(i::Vector<char> dest) { buffer_.WriteTo(dest); }
   int eos_signaled() { return eos_signaled_; }
   int size() { return buffer_.size(); }
+
  private:
   i::Collector<char> buffer_;
   int eos_signaled_;
@@ -691,6 +696,77 @@ TEST(HeapSnapshotJSONSerializationAborting) {
   CHECK_EQ(0, stream.eos_signaled());
 }
 
+class TestStatsStream : public v8::OutputStream {
+ public:
+  TestStatsStream() : eos_signaled_(0), numbers_written_(0) {}
+  virtual ~TestStatsStream() {}
+  virtual void EndOfStream() { ++eos_signaled_; }
+  virtual WriteResult WriteAsciiChunk(char* buffer, int chars_written) {
+    ASSERT(false);
+    return kAbort;
+  }
+  virtual WriteResult WriteUint32Chunk(uint32_t* buffer, int numbers_written) {
+    entries_count_ = 0;
+    for (int i = 1; i < numbers_written; i += 2)
+      entries_count_ += buffer[i];
+    numbers_written_ += numbers_written;
+    return kContinue;
+  }
+  int eos_signaled() { return eos_signaled_; }
+  int numbers_written() { return numbers_written_; }
+  uint32_t entries_count() const { return entries_count_; }
+ private:
+  int eos_signaled_;
+  int numbers_written_;
+  uint32_t entries_count_;
+};
+
+
+TEST(HeapSnapshotObjectsStats) {
+  v8::HandleScope scope;
+  LocalContext env;
+
+  v8::HeapProfiler::StartHeapObjectsTracking();
+
+  for (int i = 0; i < 5; ++i) {
+    HEAP->CollectAllGarbage(i::Heap::kNoGCFlags);
+  }
+
+  {
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(2, stream.numbers_written());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+
+  { // No data expected in update because nothing happened.
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(0, stream.numbers_written());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+
+  v8::Persistent<v8::String> p_string =

[mnaganov (inactive), 2012/04/11 14:35:40]

This handle can be local, you have a HandleScope at the function level, so the
string will be kept alive until you return.

+      v8::Persistent<v8::String>::New(v8_str("string"));
+
+  { // Single chunk of data expected in update.
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(2, stream.numbers_written());
+    CHECK_EQ(1, stream.entries_count());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+
+  { // No data expected in update because nothing happened.
+    TestStatsStream stream;
+    v8::HeapProfiler::PushHeapObjectsStats(&stream);
+    CHECK_EQ(0, stream.numbers_written());
+    CHECK_EQ(1, stream.eos_signaled());
+  }
+

[mnaganov (inactive), 2012/04/11 14:35:40]

I think, you should also test stats update on object deletion.

+  v8::HeapProfiler::StopHeapObjectsTracking();
+}
+
 
 static void CheckChildrenIds(const v8::HeapSnapshot* snapshot,
                              const v8::HeapGraphNode* node,