base/trace_event/heap_profiler_heap_dump_writer_unittest.cc - bauxite - Git at Google

 // 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 <stdlib.h>
 #include <string>

 #include "base/json/json_reader.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/trace_event/heap_profiler_allocation_context.h"
 #include "base/trace_event/heap_profiler_heap_dump_writer.h"
 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
 #include "base/trace_event/heap_profiler_type_name_deduplicator.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace {

 // Define all strings once, because the deduplicator requires pointer equality,
 // and string interning is unreliable.
 const char kBrowserMain[] = "BrowserMain";
 const char kRendererMain[] = "RendererMain";
 const char kCreateWidget[] = "CreateWidget";
 const char kInitialize[] = "Initialize";

 const char kInt[] = "int";
 const char kBool[] = "bool";
 const char kString[] = "string";

 }  // namespace

 namespace base {
 namespace trace_event {

 // Asserts that an integer stored in the json as a string has the correct value.
 void AssertIntEq(const DictionaryValue* entry,
                  const char* key,
                  int expected_value) {
   std::string str;
   ASSERT_TRUE(entry->GetString(key, &str));
   ASSERT_EQ(expected_value, atoi(str.c_str()));
 }

 scoped_ptr<Value> DumpAndReadBack(HeapDumpWriter* writer) {
   scoped_refptr<TracedValue> traced_value = writer->WriteHeapDump();
   std::string json;
   traced_value->AppendAsTraceFormat(&json);
   return JSONReader::Read(json);
 }

 TEST(HeapDumpWriterTest, BacktraceTypeNameTable) {
   auto sf_deduplicator = make_scoped_refptr(new StackFrameDeduplicator);
   auto tn_deduplicator = make_scoped_refptr(new TypeNameDeduplicator);
   HeapDumpWriter writer(sf_deduplicator.get(), tn_deduplicator.get());

   AllocationContext ctx = AllocationContext::Empty();
   ctx.backtrace.frames[0] = kBrowserMain;
   ctx.backtrace.frames[1] = kCreateWidget;
   ctx.type_name = kInt;

   // 10 bytes with context { type: int, bt: [BrowserMain, CreateWidget] }.
   writer.InsertAllocation(ctx, 2);
   writer.InsertAllocation(ctx, 3);
   writer.InsertAllocation(ctx, 5);

   ctx.type_name = kBool;

   // 18 bytes with context { type: bool, bt: [BrowserMain, CreateWidget] }.
   writer.InsertAllocation(ctx, 7);
   writer.InsertAllocation(ctx, 11);

   ctx.backtrace.frames[0] = kRendererMain;
   ctx.backtrace.frames[1] = kInitialize;

   // 30 bytes with context { type: bool, bt: [RendererMain, Initialize] }.
   writer.InsertAllocation(ctx, 13);
   writer.InsertAllocation(ctx, 17);

   ctx.type_name = kString;

   // 19 bytes with context { type: string, bt: [RendererMain, Initialize] }.
   writer.InsertAllocation(ctx, 19);

   // At this point the heap looks like this:
   //
   // |        | CrWidget <- BrMain | Init <- RenMain | Sum |
   // +--------+--------------------+-----------------+-----+
   // | int    |                 10 |               0 |  10 |
   // | bool   |                 18 |              30 |  48 |
   // | string |                  0 |              19 |  19 |
   // +--------+--------------------+-----------------+-----+
   // | Sum    |                 28 |              49 |  77 |

   scoped_ptr<Value> heap_dump = DumpAndReadBack(&writer);

   // The json heap dump should at least include this:
   // {
   //   "entries": [
   //     { "size": "4d" },                                    // 77 = 0x4d.
   //     { "size": "31", "bt": "id_of(Init <- RenMain)" },    // 49 = 0x31.
   //     { "size": "1c", "bt": "id_of(CrWidget <- BrMain)" }, // 28 = 0x1c.
   //     { "size": "30", "type": "id_of(bool)" },             // 48 = 0x30.
   //     { "size": "13", "type": "id_of(string)" },           // 19 = 0x13.
   //     { "size": "a", "type": "id_of(int)" }                // 10 = 0xa.
   //   ]
   // }

   // Get the indices of the backtraces and types by adding them again to the
   // deduplicator. Because they were added before, the same number is returned.
   int bt_renderer_main_initialize =
       sf_deduplicator->Insert({{kRendererMain, kInitialize}});
   int bt_browser_main_create_widget =
       sf_deduplicator->Insert({{kBrowserMain, kCreateWidget}});
   int type_id_int = tn_deduplicator->Insert(kInt);
   int type_id_bool = tn_deduplicator->Insert(kBool);
   int type_id_string = tn_deduplicator->Insert(kString);

   const DictionaryValue* dictionary;
   ASSERT_TRUE(heap_dump->GetAsDictionary(&dictionary));

   const ListValue* entries;
   ASSERT_TRUE(dictionary->GetList("entries", &entries));

   // Keep counters to verify that every entry is present exactly once.
   int x4d_seen = 0;
   int x31_seen = 0;
   int x1c_seen = 0;
   int x30_seen = 0;
   int x13_seen = 0;
   int xa_seen = 0;

   for (const Value* entry_as_value : *entries) {
     const DictionaryValue* entry;
     ASSERT_TRUE(entry_as_value->GetAsDictionary(&entry));

     // The "size" field, not to be confused with |entry->size()| which is the
     // number of elements in the dictionary.
     std::string size;
     ASSERT_TRUE(entry->GetString("size", &size));

     if (size == "4d") {
       // Total size, should not include any other field.
       ASSERT_EQ(1u, entry->size());  // Dictionary must have one element.
       x4d_seen++;
     } else if (size == "31") {
       // Entry for backtrace "Initialize <- RendererMain".
       ASSERT_EQ(2u, entry->size());  // Dictionary must have two elements.
       AssertIntEq(entry, "bt", bt_renderer_main_initialize);
       x31_seen++;
     } else if (size == "1c") {
       // Entry for backtrace "CreateWidget <- BrowserMain".
       ASSERT_EQ(2u, entry->size());  // Dictionary must have two elements.
       AssertIntEq(entry, "bt", bt_browser_main_create_widget);
       x1c_seen++;
     } else if (size == "30") {
       // Entry for type bool.
       ASSERT_EQ(2u, entry->size());  // Dictionary must have two elements.
       AssertIntEq(entry, "type", type_id_bool);
       x30_seen++;
     } else if (size == "13") {
       // Entry for type string.
       ASSERT_EQ(2u, entry->size());  // Dictionary must have two elements.
       AssertIntEq(entry, "type", type_id_string);
       x13_seen++;
     } else if (size == "a") {
       // Entry for type int.
       ASSERT_EQ(2u, entry->size());  // Dictionary must have two elements.
       AssertIntEq(entry, "type", type_id_int);
       xa_seen++;
     }
   }

   ASSERT_EQ(1, x4d_seen);
   ASSERT_EQ(1, x31_seen);
   ASSERT_EQ(1, x1c_seen);
   ASSERT_EQ(1, x30_seen);
   ASSERT_EQ(1, x13_seen);
   ASSERT_EQ(1, xa_seen);
 }

 // Test that the entry for the empty backtrace ends up in the json with the
 // "bt" field set to the empty string. Also test that an entry for "unknown
 // type" (nullptr type name) does not dereference the null pointer when writing
 // the type names, and that the type ID is 0.
 TEST(HeapDumpWriterTest, EmptyBacktraceIndexIsEmptyString) {
   auto sf_deduplicator = make_scoped_refptr(new StackFrameDeduplicator);
   auto tn_deduplicator = make_scoped_refptr(new TypeNameDeduplicator);
   HeapDumpWriter writer(sf_deduplicator.get(), tn_deduplicator.get());

   // A context with empty backtrace and unknown type (nullptr).
   AllocationContext ctx = AllocationContext::Empty();

   writer.InsertAllocation(ctx, 1);

   scoped_ptr<Value> heap_dump = DumpAndReadBack(&writer);

   const DictionaryValue* dictionary;
   ASSERT_TRUE(heap_dump->GetAsDictionary(&dictionary));

   const ListValue* entries;
   ASSERT_TRUE(dictionary->GetList("entries", &entries));

   int empty_backtrace_seen = 0;
   int unknown_type_seen = 0;

   for (const Value* entry_as_value : *entries) {
     const DictionaryValue* entry;
     ASSERT_TRUE(entry_as_value->GetAsDictionary(&entry));

     // Note that |entry->size()| is the number of elements in the dictionary.
     if (entry->HasKey("bt") && entry->size() == 2) {
       std::string backtrace;
       ASSERT_TRUE(entry->GetString("bt", &backtrace));
       ASSERT_EQ("", backtrace);
       empty_backtrace_seen++;
     }

     if (entry->HasKey("type") && entry->size() == 2) {
       std::string type_id;
       ASSERT_TRUE(entry->GetString("type", &type_id));
       ASSERT_EQ("0", type_id);
       unknown_type_seen++;
     }
   }

   ASSERT_EQ(1, unknown_type_seen);
   ASSERT_EQ(1, empty_backtrace_seen);
 }

 }  // namespace trace_event
 }  // namespace base
	// 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 <stdlib.h>
	#include <string>

	#include "base/json/json_reader.h"
	#include "base/memory/ref_counted.h"
	#include "base/memory/scoped_ptr.h"
	#include "base/trace_event/heap_profiler_allocation_context.h"
	#include "base/trace_event/heap_profiler_heap_dump_writer.h"
	#include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
	#include "base/trace_event/heap_profiler_type_name_deduplicator.h"
	#include "base/trace_event/trace_event_argument.h"
	#include "base/values.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace {

	// Define all strings once, because the deduplicator requires pointer equality,
	// and string interning is unreliable.
	const char kBrowserMain[] = "BrowserMain";
	const char kRendererMain[] = "RendererMain";
	const char kCreateWidget[] = "CreateWidget";
	const char kInitialize[] = "Initialize";

	const char kInt[] = "int";
	const char kBool[] = "bool";
	const char kString[] = "string";

	} // namespace

	namespace base {
	namespace trace_event {

	// Asserts that an integer stored in the json as a string has the correct value.
	void AssertIntEq(const DictionaryValue* entry,
	const char* key,
	int expected_value) {
	std::string str;
	ASSERT_TRUE(entry->GetString(key, &str));
	ASSERT_EQ(expected_value, atoi(str.c_str()));
	}

	scoped_ptr<Value> DumpAndReadBack(HeapDumpWriter* writer) {
	scoped_refptr<TracedValue> traced_value = writer->WriteHeapDump();
	std::string json;
	traced_value->AppendAsTraceFormat(&json);
	return JSONReader::Read(json);
	}

	TEST(HeapDumpWriterTest, BacktraceTypeNameTable) {
	auto sf_deduplicator = make_scoped_refptr(new StackFrameDeduplicator);
	auto tn_deduplicator = make_scoped_refptr(new TypeNameDeduplicator);
	HeapDumpWriter writer(sf_deduplicator.get(), tn_deduplicator.get());

	AllocationContext ctx = AllocationContext::Empty();
	ctx.backtrace.frames[0] = kBrowserMain;
	ctx.backtrace.frames[1] = kCreateWidget;
	ctx.type_name = kInt;

	// 10 bytes with context { type: int, bt: [BrowserMain, CreateWidget] }.
	writer.InsertAllocation(ctx, 2);
	writer.InsertAllocation(ctx, 3);
	writer.InsertAllocation(ctx, 5);

	ctx.type_name = kBool;

	// 18 bytes with context { type: bool, bt: [BrowserMain, CreateWidget] }.
	writer.InsertAllocation(ctx, 7);
	writer.InsertAllocation(ctx, 11);

	ctx.backtrace.frames[0] = kRendererMain;
	ctx.backtrace.frames[1] = kInitialize;

	// 30 bytes with context { type: bool, bt: [RendererMain, Initialize] }.
	writer.InsertAllocation(ctx, 13);
	writer.InsertAllocation(ctx, 17);

	ctx.type_name = kString;

	// 19 bytes with context { type: string, bt: [RendererMain, Initialize] }.
	writer.InsertAllocation(ctx, 19);

	// At this point the heap looks like this:
	//
	// \| \| CrWidget <- BrMain \| Init <- RenMain \| Sum \|
	// +--------+--------------------+-----------------+-----+
	// \| int \| 10 \| 0 \| 10 \|
	// \| bool \| 18 \| 30 \| 48 \|
	// \| string \| 0 \| 19 \| 19 \|
	// +--------+--------------------+-----------------+-----+
	// \| Sum \| 28 \| 49 \| 77 \|

	scoped_ptr<Value> heap_dump = DumpAndReadBack(&writer);

	// The json heap dump should at least include this:
	// {
	// "entries": [
	// { "size": "4d" }, // 77 = 0x4d.
	// { "size": "31", "bt": "id_of(Init <- RenMain)" }, // 49 = 0x31.
	// { "size": "1c", "bt": "id_of(CrWidget <- BrMain)" }, // 28 = 0x1c.
	// { "size": "30", "type": "id_of(bool)" }, // 48 = 0x30.
	// { "size": "13", "type": "id_of(string)" }, // 19 = 0x13.
	// { "size": "a", "type": "id_of(int)" } // 10 = 0xa.
	// ]
	// }

	// Get the indices of the backtraces and types by adding them again to the
	// deduplicator. Because they were added before, the same number is returned.
	int bt_renderer_main_initialize =
	sf_deduplicator->Insert({{kRendererMain, kInitialize}});
	int bt_browser_main_create_widget =
	sf_deduplicator->Insert({{kBrowserMain, kCreateWidget}});
	int type_id_int = tn_deduplicator->Insert(kInt);
	int type_id_bool = tn_deduplicator->Insert(kBool);
	int type_id_string = tn_deduplicator->Insert(kString);

	const DictionaryValue* dictionary;
	ASSERT_TRUE(heap_dump->GetAsDictionary(&dictionary));

	const ListValue* entries;
	ASSERT_TRUE(dictionary->GetList("entries", &entries));

	// Keep counters to verify that every entry is present exactly once.
	int x4d_seen = 0;
	int x31_seen = 0;
	int x1c_seen = 0;
	int x30_seen = 0;
	int x13_seen = 0;
	int xa_seen = 0;

	for (const Value* entry_as_value : *entries) {
	const DictionaryValue* entry;
	ASSERT_TRUE(entry_as_value->GetAsDictionary(&entry));

	// The "size" field, not to be confused with \|entry->size()\| which is the
	// number of elements in the dictionary.
	std::string size;
	ASSERT_TRUE(entry->GetString("size", &size));

	if (size == "4d") {
	// Total size, should not include any other field.
	ASSERT_EQ(1u, entry->size()); // Dictionary must have one element.
	x4d_seen++;
	} else if (size == "31") {
	// Entry for backtrace "Initialize <- RendererMain".
	ASSERT_EQ(2u, entry->size()); // Dictionary must have two elements.
	AssertIntEq(entry, "bt", bt_renderer_main_initialize);
	x31_seen++;
	} else if (size == "1c") {
	// Entry for backtrace "CreateWidget <- BrowserMain".
	ASSERT_EQ(2u, entry->size()); // Dictionary must have two elements.
	AssertIntEq(entry, "bt", bt_browser_main_create_widget);
	x1c_seen++;
	} else if (size == "30") {
	// Entry for type bool.
	ASSERT_EQ(2u, entry->size()); // Dictionary must have two elements.
	AssertIntEq(entry, "type", type_id_bool);
	x30_seen++;
	} else if (size == "13") {
	// Entry for type string.
	ASSERT_EQ(2u, entry->size()); // Dictionary must have two elements.
	AssertIntEq(entry, "type", type_id_string);
	x13_seen++;
	} else if (size == "a") {
	// Entry for type int.
	ASSERT_EQ(2u, entry->size()); // Dictionary must have two elements.
	AssertIntEq(entry, "type", type_id_int);
	xa_seen++;
	}
	}

	ASSERT_EQ(1, x4d_seen);
	ASSERT_EQ(1, x31_seen);
	ASSERT_EQ(1, x1c_seen);
	ASSERT_EQ(1, x30_seen);
	ASSERT_EQ(1, x13_seen);
	ASSERT_EQ(1, xa_seen);
	}

	// Test that the entry for the empty backtrace ends up in the json with the
	// "bt" field set to the empty string. Also test that an entry for "unknown
	// type" (nullptr type name) does not dereference the null pointer when writing
	// the type names, and that the type ID is 0.
	TEST(HeapDumpWriterTest, EmptyBacktraceIndexIsEmptyString) {
	auto sf_deduplicator = make_scoped_refptr(new StackFrameDeduplicator);
	auto tn_deduplicator = make_scoped_refptr(new TypeNameDeduplicator);
	HeapDumpWriter writer(sf_deduplicator.get(), tn_deduplicator.get());

	// A context with empty backtrace and unknown type (nullptr).
	AllocationContext ctx = AllocationContext::Empty();

	writer.InsertAllocation(ctx, 1);

	scoped_ptr<Value> heap_dump = DumpAndReadBack(&writer);

	const DictionaryValue* dictionary;
	ASSERT_TRUE(heap_dump->GetAsDictionary(&dictionary));

	const ListValue* entries;
	ASSERT_TRUE(dictionary->GetList("entries", &entries));

	int empty_backtrace_seen = 0;
	int unknown_type_seen = 0;

	for (const Value* entry_as_value : *entries) {
	const DictionaryValue* entry;
	ASSERT_TRUE(entry_as_value->GetAsDictionary(&entry));

	// Note that \|entry->size()\| is the number of elements in the dictionary.
	if (entry->HasKey("bt") && entry->size() == 2) {
	std::string backtrace;
	ASSERT_TRUE(entry->GetString("bt", &backtrace));
	ASSERT_EQ("", backtrace);
	empty_backtrace_seen++;
	}

	if (entry->HasKey("type") && entry->size() == 2) {
	std::string type_id;
	ASSERT_TRUE(entry->GetString("type", &type_id));
	ASSERT_EQ("0", type_id);
	unknown_type_seen++;
	}
	}

	ASSERT_EQ(1, unknown_type_seen);
	ASSERT_EQ(1, empty_backtrace_seen);
	}

	} // namespace trace_event
	} // namespace base