[tracing] Add native allocation tracing mode.

base/trace_event/heap_profiler_stack_frame_deduplicator.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/heap_profiler_stack_frame_deduplicator.h"
 
+#include <inttypes.h>
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
 
 namespace base {
 namespace trace_event {
 
 StackFrameDeduplicator::FrameNode::FrameNode(StackFrame frame,
                                              int parent_frame_index)
     : frame(frame), parent_frame_index(parent_frame_index) {}
 StackFrameDeduplicator::FrameNode::FrameNode(const FrameNode& other) = default;
 StackFrameDeduplicator::FrameNode::~FrameNode() {}
 
 StackFrameDeduplicator::StackFrameDeduplicator() {}
 StackFrameDeduplicator::~StackFrameDeduplicator() {}
 
 int StackFrameDeduplicator::Insert(const StackFrame* beginFrame,
                                    const StackFrame* endFrame) {
   int frame_index = -1;
   std::map<StackFrame, int>* nodes = &roots_;
 
   // Loop through the frames, early out when a frame is null.
-  for (const StackFrame* it = beginFrame; it != endFrame && *it; it++) {
+  for (const StackFrame* it = beginFrame;
+       it != endFrame && !it->empty();
+       it++) {
     StackFrame frame = *it;
 
     auto node = nodes->find(frame);
     if (node == nodes->end()) {
       // There is no tree node for this frame yet, create it. The parent node
       // is the node associated with the previous frame.
       FrameNode frame_node(frame, frame_index);
 
       // The new frame node will be appended, so its index is the current size
       // of the vector.
@@ skipping 26 matching lines @@
 
   while (frame_node != it_end) {
     // The |stackFrames| format is a dictionary, not an array, so the
     // keys are stringified indices. Write the index manually, then use
     // |TracedValue| to format the object. This is to avoid building the
     // entire dictionary as a |TracedValue| in memory.
     SStringPrintf(&stringify_buffer, "\"%d\":", i);
     out->append(stringify_buffer);
 
     std::unique_ptr<TracedValue> frame_node_value(new TracedValue);
-    frame_node_value->SetString("name", frame_node->frame);
+    const StackFrame& frame = frame_node->frame;
+    switch (frame.type) {
+      case StackFrame::TYPE_SYMBOL:
+        frame_node_value->SetString(
+            "name", static_cast<const char*>(frame.value));
+        break;
+      case StackFrame::TYPE_THREAD_NAME:
+        SStringPrintf(&stringify_buffer,
+                      "[Thread: %s]",
+                      static_cast<const char*>(frame.value));
+        frame_node_value->SetString("name", stringify_buffer);
+        break;
+      case StackFrame::TYPE_PC:
+        SStringPrintf(&stringify_buffer,
+                      "pc:%" PRIxPTR,
+                      reinterpret_cast<uintptr_t>(frame.value));
+        frame_node_value->SetString("name", stringify_buffer);
+        break;
+    }
     if (frame_node->parent_frame_index >= 0) {
       SStringPrintf(&stringify_buffer, "%d", frame_node->parent_frame_index);
       frame_node_value->SetString("parent", stringify_buffer);
     }
     frame_node_value->AppendAsTraceFormat(out);
 
     i++;
     frame_node++;
 
     if (frame_node != it_end)
@@ skipping 15 matching lines @@
   for (const FrameNode& node : frames_)
     maps_size += node.children.size() * sizeof(std::pair<StackFrame, int>);
 
   overhead->Add("StackFrameDeduplicator",
                 sizeof(StackFrameDeduplicator) + maps_size + frames_allocated,
                 sizeof(StackFrameDeduplicator) + maps_size + frames_resident);
 }
 
 }  // namespace trace_event
 }  // namespace base