[tracing] Adding task information to heap profiler

base/trace_event/heap_profiler_type_name_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_type_name_deduplicator.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <string>
 #include <utility>
 
+#include "base/files/file_path.h"
 #include "base/json/string_escape.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
 
 namespace base {
 namespace trace_event {
 
+namespace {
+
+// Extract directory name from task context if |type_name| was task context.
+// Otherwise, return |type_name|.
+StringPiece ExtractDirNameFromTaskContext(const char* type_name) {
+  StringPiece result = type_name;

[Primiano Tucci (use gerrit), 2016/03/31 15:37:16]

StringPiece result(type_name);

no need to disturb the StringPiece copy-ctor :)

[ssid, 2016/04/01 04:34:54]

Done.

+  size_t last_seperator = result.find_last_of(FilePath::kSeparators);
+
+  // If |type_name| was a not a file path, the seperator will not be found, so
+  // the whole type name is returned.
+  if (last_seperator == StringPiece::npos)
+    return result;
+
+  // Remove the file name from the path.
+  result.remove_suffix(result.length() - last_seperator);
+
+  // Remove the parent directory references - '..'.
+  while (result.starts_with(FilePath::kParentDirectory)) {
+    size_t parent_seperator = result.find_first_of(FilePath::kSeparators);
+    DCHECK_NE(StringPiece::npos, parent_seperator);
+    result.remove_prefix(parent_seperator + 1);

[Primiano Tucci (use gerrit), 2016/03/31 15:37:16]

I think here is fine to assume that .. is always followed by a 1-char separator
(either \ or /) so I'd just remove_prefix(kParentDirectory.length + 2) and keep
it simple

[ssid, 2016/04/01 04:34:54]

Done.

+  }
+  return result;
+}
+
+}  // namespace
+
 TypeNameDeduplicator::TypeNameDeduplicator() {
   // A null pointer has type ID 0 ("unknown type");
   type_ids_.insert(std::make_pair(nullptr, 0));
 }
 
 TypeNameDeduplicator::~TypeNameDeduplicator() {}
 
 int TypeNameDeduplicator::Insert(const char* type_name) {
   auto result = type_ids_.insert(std::make_pair(type_name, 0));
   auto& elem = result.first;
@@ skipping 17 matching lines @@
   // Write the first entry manually; the null pointer must not be dereferenced.
   // (The first entry is the null pointer because a |std::map| is ordered.)
   it++;
   out->append("\"0\":\"[unknown]\"");
 
   for (; it != type_ids_.end(); it++) {
     // Type IDs in the trace are strings, write them as stringified keys of
     // a dictionary.
     SStringPrintf(&buffer, ",\"%d\":", it->second);
 
+    // TODO(ssid): crbug.com/594803 the type name is misused for category name.
+    StringPiece type_info = ExtractDirNameFromTaskContext(it->first);
+
     // |EscapeJSONString| appends, it does not overwrite |buffer|.
     bool put_in_quotes = true;
-    EscapeJSONString(it->first, put_in_quotes, &buffer);
+    EscapeJSONString(type_info, put_in_quotes, &buffer);
     out->append(buffer);
   }
 
   out->append("}");  // End the type names dictionary.
 }
 
 void TypeNameDeduplicator::EstimateTraceMemoryOverhead(
     TraceEventMemoryOverhead* overhead) {
   // The size here is only an estimate; it fails to take into account the size
   // of the tree nodes for the map, but as an estimate this should be fine.
   size_t map_size = type_ids_.size() * sizeof(std::pair<const char*, int>);
 
   overhead->Add("TypeNameDeduplicator",
                 sizeof(TypeNameDeduplicator) + map_size);
 }
 
 }  // namespace trace_event
 }  // namespace base