[tracing] Switch to new heap dump format.

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/json/string_escape.h"
 #include "base/strings/string_split.h"
-#include "base/strings/stringprintf.h"
+#include "base/trace_event/heap_profiler_string_deduplicator.h"
 #include "base/trace_event/memory_usage_estimator.h"
 #include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_memory_overhead.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 // If |type_name| is file name then extract directory name. Or if |type_name| is
 // category name, then disambiguate multple categories and remove
 // "disabled-by-default" prefix if present.
@@ skipping 28 matching lines @@
   const char kParentDirectory[] = "..";
   const size_t kParentDirectoryLength = 3; // '../' or '..\'.
   while (result.starts_with(kParentDirectory)) {
     result.remove_prefix(kParentDirectoryLength);
   }
   return result;
 }
 
 }  // namespace
 
-TypeNameDeduplicator::TypeNameDeduplicator() {
-  // A null pointer has type ID 0 ("unknown type");
-  type_ids_.insert(std::make_pair(nullptr, 0));
+TypeNameDeduplicator::TypeNameDeduplicator(
+    StringDeduplicator* string_deduplicator)
+    : string_deduplicator_(string_deduplicator) {
+  // Add implicit entry for id 0 (NULL type names).
+  Insert(nullptr);
 }
 
 TypeNameDeduplicator::~TypeNameDeduplicator() {}
 
 int TypeNameDeduplicator::Insert(const char* type_name) {
   auto result = type_ids_.insert(std::make_pair(type_name, 0));
   auto& elem = result.first;
   bool did_not_exist_before = result.second;
 
   if (did_not_exist_before) {
     // The type IDs are assigned sequentially and they are zero-based, so
     // |size() - 1| is the ID of the new element.
     elem->second = static_cast<int>(type_ids_.size() - 1);
+    new_type_ids_.push_back(&*result.first);
   }
 
   return elem->second;
 }
 
-void TypeNameDeduplicator::AppendAsTraceFormat(std::string* out) const {
-  out->append("{");  // Begin the type names dictionary.
+void TypeNameDeduplicator::SerializeIncrementally(TracedValue* traced_value) {
+  for (const auto* name_and_id : new_type_ids_) {
+    traced_value->BeginDictionary();
 
-  auto it = type_ids_.begin();
-  std::string buffer;
-
-  // 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);
+    traced_value->SetInteger("id", name_and_id->second);
 
     // TODO(ssid): crbug.com/594803 the type name is misused for file name in
     // some cases.
-    StringPiece type_info = ExtractCategoryFromTypeName(it->first);
+    StringPiece name = name_and_id->first
+                           ? ExtractCategoryFromTypeName(name_and_id->first)
+                           : "[unknown]";
+    int name_string_id = string_deduplicator_->Insert(name);
+    traced_value->SetInteger("name_sid", name_string_id);
 
-    // |EscapeJSONString| appends, it does not overwrite |buffer|.
-    bool put_in_quotes = true;
-    EscapeJSONString(type_info, put_in_quotes, &buffer);
-    out->append(buffer);
+    traced_value->EndDictionary();
   }
-
-  out->append("}");  // End the type names dictionary.
+  new_type_ids_.clear();
 }
 
 void TypeNameDeduplicator::EstimateTraceMemoryOverhead(
     TraceEventMemoryOverhead* overhead) {
-  size_t memory_usage = EstimateMemoryUsage(type_ids_);
+  size_t memory_usage =
+      EstimateMemoryUsage(type_ids_) + EstimateMemoryUsage(new_type_ids_);
   overhead->Add(TraceEventMemoryOverhead::kHeapProfilerTypeNameDeduplicator,
                 sizeof(TypeNameDeduplicator) + memory_usage);
 }
 
 }  // namespace trace_event
 }  // namespace base