[tracing] Fix JSON format for memory allocator dumps.

base/trace_event/memory_allocator_dump.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_allocator_dump.h"
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
@@ skipping 56 matching lines @@
   int value = -1;
   bool res = attributes_values_.GetInteger(name, &value);
   DCHECK(res) << "Attribute '" << name << "' not found";
   return value;
 }
 
 void MemoryAllocatorDump::AsValueInto(TracedValue* value) const {
   static const char kHexFmt[] = "%" PRIx64;
 
   value->BeginDictionary(GetAbsoluteName().c_str());
+  value->BeginDictionary("attrs");
 
-  value->SetString("physical_size_in_bytes",
-                   StringPrintf(kHexFmt, physical_size_in_bytes_));
-  value->SetString("allocated_objects_count",
-                   StringPrintf(kHexFmt, allocated_objects_count_));
-  value->SetString("allocated_objects_size_in_bytes",
+  // TODO(primiano): these hard-coded types are temporary to transition to the
+  // new generalized attribute format. This code will be refactored by May 2015.

[petrcermak, 2015/04/27 14:22:14]

nit: "by May 2015" is ambiguous. Do you mean "by the end of May 2015"?

[Primiano Tucci (use gerrit), 2015/04/27 15:03:18]

Done.

+  value->BeginDictionary("outer_size");
+  value->SetString("type", "scalar");
+  value->SetString("units", "bytes");
+  value->SetString("value", StringPrintf(kHexFmt, physical_size_in_bytes_));
+  value->EndDictionary();
+
+  value->BeginDictionary("inner_size");
+  value->SetString("type", "scalar");
+  value->SetString("units", "bytes");
+  value->SetString("value",
                    StringPrintf(kHexFmt, allocated_objects_size_in_bytes_));
+  value->EndDictionary();
+
+  value->BeginDictionary("objects_count");
+  value->SetString("type", "scalar");
+  value->SetString("units", "objects");
+  value->SetString("value", StringPrintf(kHexFmt, allocated_objects_count_));
+  value->EndDictionary();
 
   // Copy all the extra attributes.
-  value->BeginDictionary("args");
   for (DictionaryValue::Iterator it(attributes_values_); !it.IsAtEnd();
        it.Advance()) {
     const std::string& attr_name = it.key();
     const Value& attr_value = it.value();
     value->BeginDictionary(attr_name.c_str());
     value->SetValue("value", attr_value.DeepCopy());
 
     // TODO(primiano): the "type" should be dumped just once, not repeated on
     // on every event. The ability of doing so depends on crbug.com/466121.

[petrcermak, 2015/04/27 14:22:14]

We're doing this any more - types will be dumped each time.

[Primiano Tucci (use gerrit), 2015/04/27 15:03:18]

Done.

     const std::string& attr_type =
         GetAttributesTypeInfo().Get(allocator_name_, attr_name);
     DCHECK(!attr_type.empty());
-    value->SetString("type", attr_type);
+    value->SetString("type", "scalar");
+    value->SetString("units", attr_type);

[petrcermak, 2015/04/27 14:22:14]

Are you forcing all attributes to be scalars now? Or is this also temporarily
hard-coded?

[Primiano Tucci (use gerrit), 2015/04/27 15:03:18]

The latter, all this function is to be refactored.

 
     value->EndDictionary();  // "arg_name": { "type": "...", "value": "..." }
   }
-  value->EndDictionary();  // "args": { ... }
 
+  value->EndDictionary();  // "attrs": { ... }
   value->EndDictionary();  // "allocator_name/heap_subheap": { ... }
 }
 
 const MemoryAllocatorAttributesTypeInfo&
 MemoryAllocatorDump::GetAttributesTypeInfo() const {
   return process_memory_dump_->session_state()->allocators_attributes_type_info;
 }
 
 }  // namespace trace_event
 }  // namespace base