[tracing] Implement trace_event::AllocationContext

base/trace_event/memory_profiler_allocation_context_unittest.cc

 // Copyright 2015 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/trace_event/memory_profiler_allocation_context.h"
 #include "base/trace_event/trace_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 // Define all strings once, because the pseudo stack requires pointer equality,
 // and string interning is unreliable.
 const char kCupcake[] = "Cupcake";
 const char kDonut[] = "Donut";
 const char kEclair[] = "Eclair";
 const char kFroyo[] = "Froyo";
 const char kGingerbread[] = "Gingerbread";
 const char kHoneycomb[] = "Honeycomb";
+const char kIceCreamSandwich[] = "Ice Cream Sandwich";
+const char kJellyBean[] = "Jelly Bean";
+const char kKitKat[] = "KitKat";
 
-// Asserts that the fixed-size array |expected_stack| matches the pseudo
-// stack. Syntax note: |const StackFrame (&expected_stack)[N]| is the syntax
-// for "expected_stack is a reference to a const fixed-size array of StackFrame
-// of length N".
+// Returns a pointer past the end of the fixed-size array |array| of |T| of
+// length |N|, identical to C++11 |std::end|.
+template <typename T, int N>
+const T* End(const T(&array)[N]) {
+  return array + N;
+}
+
+// Asserts that the fixed-size array |expected_backtrace| matches the backtrace
+// in |AllocationContextTracker::GetContext|.
 template <size_t N>
-void AssertPseudoStackEquals(const StackFrame(&expected_stack)[N]) {
-  auto pseudo_stack = AllocationContextTracker::GetPseudoStackForTesting();
-  auto actual = pseudo_stack->top();
-  auto actual_bottom = pseudo_stack->bottom();
-  auto expected = expected_stack;
-  auto expected_bottom = expected_stack + N;
+void AssertBacktraceEquals(const StackFrame(&expected_backtrace)[N]) {
+  AllocationContext ctx = AllocationContextTracker::GetContext();
+
+  auto actual = ctx.backtrace.frames;
+  auto actual_bottom = End(ctx.backtrace.frames);
+  auto expected = expected_backtrace;
+  auto expected_bottom = End(expected_backtrace);
 
   // Note that this requires the pointers to be equal, this is not doing a deep
   // string comparison.
   for (; actual != actual_bottom && expected != expected_bottom;
        actual++, expected++)
     ASSERT_EQ(*expected, *actual);
 
   // Ensure that the height of the stacks is the same.
   ASSERT_EQ(actual, actual_bottom);
   ASSERT_EQ(expected, expected_bottom);
 }
 
-void AssertPseudoStackEmpty() {
-  auto pseudo_stack = AllocationContextTracker::GetPseudoStackForTesting();
-  ASSERT_EQ(pseudo_stack->top(), pseudo_stack->bottom());
+void AssertBacktraceEmpty() {
+  AllocationContext ctx = AllocationContextTracker::GetContext();
+
+  for (StackFrame frame : ctx.backtrace.frames)
+    ASSERT_EQ(nullptr, frame);
 }
 
 class AllocationContextTest : public testing::Test {
  public:
-  void EnableTracing() {
+  void SetUp() override {
     TraceConfig config("");
     TraceLog::GetInstance()->SetEnabled(config, TraceLog::RECORDING_MODE);
     AllocationContextTracker::SetCaptureEnabled(true);
   }
 
-  void DisableTracing() {
+  void TearDown() override {
     AllocationContextTracker::SetCaptureEnabled(false);
     TraceLog::GetInstance()->SetDisabled();
   }
 };
 
+// Check that |TRACE_EVENT| macros push and pop to the pseudo stack correctly.
+// Also check that |GetContext| fills the backtrace with null pointers when the
+// pseudo stack height is less than the capacity.
 TEST_F(AllocationContextTest, PseudoStackScopedTrace) {
   StackFrame c = kCupcake;
   StackFrame d = kDonut;
   StackFrame e = kEclair;
   StackFrame f = kFroyo;
 
-  EnableTracing();
-  AssertPseudoStackEmpty();
+  AssertBacktraceEmpty();
 
   {
     TRACE_EVENT0("Testing", kCupcake);
-    StackFrame frame_c[] = {c};
-    AssertPseudoStackEquals(frame_c);
+    StackFrame frame_c[] = {c, 0, 0, 0, 0, 0, 0, 0};
+    AssertBacktraceEquals(frame_c);
 
     {
       TRACE_EVENT0("Testing", kDonut);
-      StackFrame frame_dc[] = {d, c};
-      AssertPseudoStackEquals(frame_dc);
+      StackFrame frame_dc[] = {d, c, 0, 0, 0, 0, 0, 0};
+      AssertBacktraceEquals(frame_dc);
     }
 
-    AssertPseudoStackEquals(frame_c);
+    AssertBacktraceEquals(frame_c);
 
     {
       TRACE_EVENT0("Testing", kEclair);
-      StackFrame frame_ec[] = {e, c};
-      AssertPseudoStackEquals(frame_ec);
+      StackFrame frame_ec[] = {e, c, 0, 0, 0, 0, 0, 0};
+      AssertBacktraceEquals(frame_ec);
     }
 
-    AssertPseudoStackEquals(frame_c);
+    AssertBacktraceEquals(frame_c);
   }
 
-  AssertPseudoStackEmpty();
+  AssertBacktraceEmpty();
 
   {
     TRACE_EVENT0("Testing", kFroyo);
-    StackFrame frame_f[] = {f};
-    AssertPseudoStackEquals(frame_f);
+    StackFrame frame_f[] = {f, 0, 0, 0, 0, 0, 0, 0};
+    AssertBacktraceEquals(frame_f);
   }
 
-  AssertPseudoStackEmpty();
-  DisableTracing();
+  AssertBacktraceEmpty();
 }
 
+// Same as |PseudoStackScopedTrace|, but now test the |TRACE_EVENT_BEGIN| and
+// |TRACE_EVENT_END| macros.
 TEST_F(AllocationContextTest, PseudoStackBeginEndTrace) {
   StackFrame c = kCupcake;
   StackFrame d = kDonut;
   StackFrame e = kEclair;
   StackFrame f = kFroyo;
 
-  StackFrame frame_c[] = {c};
-  StackFrame frame_dc[] = {d, c};
-  StackFrame frame_ec[] = {e, c};
-  StackFrame frame_f[] = {f};
+  StackFrame frame_c[] = {c, 0, 0, 0, 0, 0, 0, 0};
+  StackFrame frame_dc[] = {d, c, 0, 0, 0, 0, 0, 0};
+  StackFrame frame_ec[] = {e, c, 0, 0, 0, 0, 0, 0};
+  StackFrame frame_f[] = {f, 0, 0, 0, 0, 0, 0, 0};
 
-  EnableTracing();
-  AssertPseudoStackEmpty();
+  AssertBacktraceEmpty();
 
   TRACE_EVENT_BEGIN0("Testing", kCupcake);
-  AssertPseudoStackEquals(frame_c);
+  AssertBacktraceEquals(frame_c);
 
   TRACE_EVENT_BEGIN0("Testing", kDonut);
-  AssertPseudoStackEquals(frame_dc);
+  AssertBacktraceEquals(frame_dc);
   TRACE_EVENT_END0("Testing", kDonut);
 
-  AssertPseudoStackEquals(frame_c);
+  AssertBacktraceEquals(frame_c);
 
   TRACE_EVENT_BEGIN0("Testing", kEclair);
-  AssertPseudoStackEquals(frame_ec);
+  AssertBacktraceEquals(frame_ec);
   TRACE_EVENT_END0("Testing", kEclair);
 
-  AssertPseudoStackEquals(frame_c);
+  AssertBacktraceEquals(frame_c);
   TRACE_EVENT_END0("Testing", kCupcake);
 
-  AssertPseudoStackEmpty();
+  AssertBacktraceEmpty();
 
   TRACE_EVENT_BEGIN0("Testing", kFroyo);
-  AssertPseudoStackEquals(frame_f);
+  AssertBacktraceEquals(frame_f);
   TRACE_EVENT_END0("Testing", kFroyo);
 
-  AssertPseudoStackEmpty();
-  DisableTracing();
+  AssertBacktraceEmpty();
 }
 
 TEST_F(AllocationContextTest, PseudoStackMixedTrace) {
   StackFrame c = kCupcake;
   StackFrame d = kDonut;
   StackFrame e = kEclair;
   StackFrame f = kFroyo;
 
-  StackFrame frame_c[] = {c};
-  StackFrame frame_dc[] = {d, c};
-  StackFrame frame_e[] = {e};
-  StackFrame frame_fe[] = {f, e};
+  StackFrame frame_c[] = {c, 0, 0, 0, 0, 0, 0, 0};
+  StackFrame frame_dc[] = {d, c, 0, 0, 0, 0, 0, 0};
+  StackFrame frame_e[] = {e, 0, 0, 0, 0, 0, 0, 0};
+  StackFrame frame_fe[] = {f, e, 0, 0, 0, 0, 0, 0};
 
-  EnableTracing();
-  AssertPseudoStackEmpty();
+  AssertBacktraceEmpty();
 
   TRACE_EVENT_BEGIN0("Testing", kCupcake);
-  AssertPseudoStackEquals(frame_c);
+  AssertBacktraceEquals(frame_c);
 
   {
     TRACE_EVENT0("Testing", kDonut);
-    AssertPseudoStackEquals(frame_dc);
+    AssertBacktraceEquals(frame_dc);
   }
 
-  AssertPseudoStackEquals(frame_c);
+  AssertBacktraceEquals(frame_c);
   TRACE_EVENT_END0("Testing", kCupcake);
-  AssertPseudoStackEmpty();
+  AssertBacktraceEmpty();
 
   {
     TRACE_EVENT0("Testing", kEclair);
-    AssertPseudoStackEquals(frame_e);
+    AssertBacktraceEquals(frame_e);
 
     TRACE_EVENT_BEGIN0("Testing", kFroyo);
-    AssertPseudoStackEquals(frame_fe);
+    AssertBacktraceEquals(frame_fe);
     TRACE_EVENT_END0("Testing", kFroyo);
-    AssertPseudoStackEquals(frame_e);
+    AssertBacktraceEquals(frame_e);
   }
 
-  AssertPseudoStackEmpty();
-  DisableTracing();
+  AssertBacktraceEmpty();
 }
 
-TEST_F(AllocationContextTest, PseudoStackEnableWithEventInScope) {
-  StackFrame h = kHoneycomb;
+TEST_F(AllocationContextTest, BacktraceTakesTop) {
+  TRACE_EVENT0("Testing", kCupcake);
+  TRACE_EVENT0("Testing", kDonut);
+  TRACE_EVENT0("Testing", kEclair);
+  TRACE_EVENT0("Testing", kFroyo);
+  TRACE_EVENT0("Testing", kGingerbread);
+  TRACE_EVENT0("Testing", kHoneycomb);
+  TRACE_EVENT0("Testing", kIceCreamSandwich);
+  TRACE_EVENT0("Testing", kJellyBean);
 
   {
-    TRACE_EVENT0("Testing", kGingerbread);
-    EnableTracing();
-    AssertPseudoStackEmpty();
+    TRACE_EVENT0("Testing", kKitKat);
+    AllocationContext ctx = AllocationContextTracker::GetContext();
 
-    {
-      TRACE_EVENT0("Testing", kHoneycomb);
-      StackFrame frame_h[] = {h};
-      AssertPseudoStackEquals(frame_h);
-    }
+    // The pseudo stack relies on pointer equality, not deep string comparisons.
+    ASSERT_EQ(kKitKat, ctx.backtrace.frames[0]);
+    ASSERT_EQ(kDonut, ctx.backtrace.frames[7]);
+  }
 
-    AssertPseudoStackEmpty();
-
-    // The pop at the end of this scope for the 'Gingerbread' frame must not
-    // cause a stack underflow.
+  {
+    AllocationContext ctx = AllocationContextTracker::GetContext();
+    ASSERT_EQ(kJellyBean, ctx.backtrace.frames[0]);
+    ASSERT_EQ(kCupcake, ctx.backtrace.frames[7]);
   }
-  AssertPseudoStackEmpty();
-  DisableTracing();
 }
 
 }  // namespace trace_event
 }  // namespace base