Add function to trace stack using frame pointers.

base/debug/stack_trace_unittest.cc

 // Copyright (c) 2011 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 <stddef.h>
 
 #include <limits>
 #include <sstream>
 #include <string>
 
@@ skipping 220 matching lines @@
   EXPECT_EQ("00001", itoa_r_wrapper(1, 128, 10, 5));
   EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 0));
   EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 1));
   EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 2));
   EXPECT_EQ("688", itoa_r_wrapper(0x688, 128, 16, 3));
   EXPECT_EQ("0688", itoa_r_wrapper(0x688, 128, 16, 4));
   EXPECT_EQ("00688", itoa_r_wrapper(0x688, 128, 16, 5));
 }
 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
 
+#if HAVE_TRACE_STACK_FRAME_POINTERS
+
+TEST_F(StackTraceTest, TraceStackFramePointers) {

[Primiano Tucci (use gerrit), 2016/04/18 20:18:08]

I wouldn't base this test  on comparing unwinding via frame pointers with
unwinding via libunwind (or whatever).
They will very likely produce different stacks for arbitrary function calls
(inlining, & co).
I'd much rather do the following:
Create a sequence of 5 functions that call into each other. Make sure they get a
frame. Test that you see the 5 functions and that's it.

[Dmitry Skiba, 2016/04/20 16:32:56]

Done.

+  const void* fp_frames[10];
+  size_t fp_frame_count =
+      TraceStackFramePointers(fp_frames, arraysize(fp_frames), 0);
+
+  // We expect to fill the whole frame array
+  ASSERT_EQ(arraysize(fp_frames), fp_frame_count);
+
+  // Compare against StackTrace
+
+  StackTrace stack_trace;
+  size_t frame_count = 0;
+  const void* const* frames = stack_trace.Addresses(&frame_count);
+
+  // Find offsets into both frame arrays that have matching frames
+  size_t fp_frames_offset = 0;
+  size_t frames_offset = 0;
+  bool found_matching_frame = false;
+  for (;fp_frames_offset != fp_frame_count; ++fp_frames_offset) {
+    const void* frame = fp_frames[fp_frames_offset];
+    for (frames_offset = 0; frames_offset != frame_count; ++frames_offset) {
+      if (frames[frames_offset] == frame) {
+        found_matching_frame = true;
+        break;
+      }
+    }
+    if (found_matching_frame) {
+      break;
+    }
+  }
+
+  ASSERT_TRUE(found_matching_frame) <<
+      "StackTrace class and TraceStackFramePointers function produced " <<
+      "completely different traces.";
+
+  // fp_frames[0] points somewhere inside this function and differs from
+  // location reported by StackFrame (since invocations are on different
+  // lines). However fp_frames[1] points to the caller function, and should
+  // be in both frame arrays.
+  ASSERT_EQ(fp_frames_offset, 1u);
+
+  size_t check_depth = std::min(fp_frame_count - fp_frames_offset,
+                                frame_count - frames_offset);
+  for (size_t i = 0; i != check_depth; ++i) {
+    size_t fp_frame_index = i + fp_frames_offset;
+    size_t frame_index = i + frames_offset;
+    EXPECT_EQ(frames[frame_index], fp_frames[fp_frame_index]) <<
+        "Where frame_index = " << frame_index << ", " <<
+        "fp_frame_index = " << fp_frame_index;
+  }
+}
+
+#endif  // HAVE_TRACE_STACK_FRAME_POINTERS
+
 }  // namespace debug
 }  // namespace base