Record Chrome trace events in tcmalloc heap profiles

base/debug/trace_memory_unittest.cc

Index: base/debug/trace_memory_unittest.cc
diff --git a/base/debug/trace_memory_unittest.cc b/base/debug/trace_memory_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2c25ec6607554c6853cfaed5988e3eaff38c9bc1
--- /dev/null
+++ b/base/debug/trace_memory_unittest.cc
@@ -0,0 +1,89 @@
+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/debug/trace_memory.h"
+
+#include "base/debug/trace_event_impl.h"
+#include "base/message_loop.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace debug {
+
+typedef testing::Test TraceMemoryTest;
+
+TEST_F(TraceMemoryTest, TraceMemoryTraceLogObserver) {
+  MessageLoop message_loop;
+
+  // Start with no observers of the TraceLog.
+  EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
+
+  // Creating an observer adds it to the TraceLog observer list.
+  scoped_ptr<TraceMemoryTraceLogObserver> observer(
+      new TraceMemoryTraceLogObserver(
+          message_loop.message_loop_proxy()));
+  EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest());
+  EXPECT_TRUE(TraceLog::GetInstance()->HasEnabledStateObserver(observer.get()));
+
+  // By default the observer isn't dumping memory profiles.
+  EXPECT_FALSE(observer->IsTimerRunningForTest());
+
+  // Simulate enabling tracing.
+  observer->OnTraceLogEnabled();
+  message_loop.RunUntilIdle();
+  EXPECT_TRUE(observer->IsTimerRunningForTest());
+
+  // Simulate disabling tracing.
+  observer->OnTraceLogDisabled();
+  message_loop.RunUntilIdle();
+  EXPECT_FALSE(observer->IsTimerRunningForTest());
+
+  // Deleting the observer removes it from the TraceLog observer list.
+  observer.reset();
+  EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
+}
+
+TEST_F(TraceMemoryTest, ScopedTraceMemory) {
+  // Start with an empty stack.
+  EXPECT_EQ(0, ScopedTraceMemory::GetStackIndexForTest());
+
+  {
+    // Push an item.
+    const char kScope1[] = "scope1";
+    ScopedTraceMemory scope1(kScope1);
+    EXPECT_EQ(1, ScopedTraceMemory::GetStackIndexForTest());
+    EXPECT_EQ(kScope1, ScopedTraceMemory::GetItemForTest(0));
+
+    {
+      // One more item.
+      const char kScope2[] = "scope2";
+      ScopedTraceMemory scope2(kScope2);
+      EXPECT_EQ(2, ScopedTraceMemory::GetStackIndexForTest());
+      EXPECT_EQ(kScope2, ScopedTraceMemory::GetItemForTest(1));
+    }
+
+    // Ended scope 2.
+    EXPECT_EQ(1, ScopedTraceMemory::GetStackIndexForTest());
+  }
+
+  // Ended scope 1.
+  EXPECT_EQ(0, ScopedTraceMemory::GetStackIndexForTest());
+}
+
+void TestDeepScopeNesting(int current, int depth) {
+  EXPECT_EQ(current, ScopedTraceMemory::GetStackIndexForTest());
+  const char kCategory[] = "foo";
+  ScopedTraceMemory scope(kCategory);
+  if (current < depth)
+    TestDeepScopeNesting(current + 1, depth);
+  EXPECT_EQ(current + 1, ScopedTraceMemory::GetStackIndexForTest());
+}
+
+TEST_F(TraceMemoryTest, DeepScopeNesting) {
+  // Ensure really deep scopes don't crash.
+  TestDeepScopeNesting(0, 100);
+}
+
+}  // namespace debug
+}  // namespace base