[tracing] Add method to create "weak" global dumps

base/trace_event/process_memory_dump_unittest.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/process_memory_dump.h"
 
 #include <stddef.h>
 
 #include "base/memory/aligned_memory.h"
 #include "base/process/process_metrics.h"
@@ skipping 12 matching lines @@
 
   pmd1->process_totals()->set_resident_set_bytes(42);
   pmd1->set_has_process_totals();
 
   pmd1->process_mmaps()->AddVMRegion(ProcessMemoryMaps::VMRegion());
   pmd1->set_has_process_mmaps();
 
   pmd1->AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
                          MemoryAllocatorDumpGuid(4242));
 
-  MemoryAllocatorDumpGuid shared_mad_guid(1);
-  pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid);
+  MemoryAllocatorDumpGuid shared_mad_guid1(1);
+  MemoryAllocatorDumpGuid shared_mad_guid2(2);
+  pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
+  pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid2);
 
   pmd1->Clear();
   ASSERT_TRUE(pmd1->allocator_dumps().empty());
   ASSERT_TRUE(pmd1->allocator_dumps_edges().empty());
   ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad1"));
   ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad2"));
   ASSERT_FALSE(pmd1->has_process_totals());
   ASSERT_FALSE(pmd1->has_process_mmaps());
   ASSERT_TRUE(pmd1->process_mmaps()->vm_regions().empty());
-  ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid));
+  ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
+  ASSERT_EQ(nullptr, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
 
   // Check that calling AsValueInto() doesn't cause a crash.
   scoped_refptr<TracedValue> traced_value(new TracedValue());
   pmd1->AsValueInto(traced_value.get());
 
   // Check that the pmd can be reused and behaves as expected.
   auto mad1 = pmd1->CreateAllocatorDump("mad1");
   auto mad3 = pmd1->CreateAllocatorDump("mad3");
-  auto shared_mad = pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid);
-  ASSERT_EQ(3u, pmd1->allocator_dumps().size());
+  auto shared_mad1 = pmd1->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
+  auto shared_mad2 =
+      pmd1->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
+  ASSERT_EQ(4u, pmd1->allocator_dumps().size());
   ASSERT_EQ(mad1, pmd1->GetAllocatorDump("mad1"));
   ASSERT_EQ(nullptr, pmd1->GetAllocatorDump("mad2"));
   ASSERT_EQ(mad3, pmd1->GetAllocatorDump("mad3"));
-  ASSERT_EQ(shared_mad, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid));
+  ASSERT_EQ(shared_mad1, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
+  ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
+  ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
+  ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad2->flags());
 
   traced_value = new TracedValue();
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
 
 TEST(ProcessMemoryDumpTest, TakeAllDumpsFrom) {
   scoped_refptr<TracedValue> traced_value(new TracedValue());
 
   scoped_ptr<ProcessMemoryDump> pmd1(new ProcessMemoryDump(nullptr));
   auto mad1_1 = pmd1->CreateAllocatorDump("pmd1/mad1");
   auto mad1_2 = pmd1->CreateAllocatorDump("pmd1/mad2");
   pmd1->AddOwnershipEdge(mad1_1->guid(), mad1_2->guid());
 
   scoped_ptr<ProcessMemoryDump> pmd2(new ProcessMemoryDump(nullptr));
   auto mad2_1 = pmd2->CreateAllocatorDump("pmd2/mad1");
   auto mad2_2 = pmd2->CreateAllocatorDump("pmd2/mad2");
   pmd1->AddOwnershipEdge(mad2_1->guid(), mad2_2->guid());
 
-  MemoryAllocatorDumpGuid shared_mad_guid(1);
-  auto shared_mad = pmd2->CreateSharedGlobalAllocatorDump(shared_mad_guid);
+  MemoryAllocatorDumpGuid shared_mad_guid1(1);
+  MemoryAllocatorDumpGuid shared_mad_guid2(2);
+  auto shared_mad1 = pmd2->CreateSharedGlobalAllocatorDump(shared_mad_guid1);
+  auto shared_mad2 =
+      pmd2->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid2);
 
   pmd1->TakeAllDumpsFrom(pmd2.get());
 
   // Make sure that pmd2 is empty but still usable after it has been emptied.
   ASSERT_TRUE(pmd2->allocator_dumps().empty());
   ASSERT_TRUE(pmd2->allocator_dumps_edges().empty());
   pmd2->CreateAllocatorDump("pmd2/this_mad_stays_with_pmd2");
   ASSERT_EQ(1u, pmd2->allocator_dumps().size());
   ASSERT_EQ(1u, pmd2->allocator_dumps().count("pmd2/this_mad_stays_with_pmd2"));
   pmd2->AddOwnershipEdge(MemoryAllocatorDumpGuid(42),
                          MemoryAllocatorDumpGuid(4242));
 
   // Check that calling AsValueInto() doesn't cause a crash.
   pmd2->AsValueInto(traced_value.get());
 
   // Free the |pmd2| to check that the memory ownership of the two MAD(s)
   // has been transferred to |pmd1|.
   pmd2.reset();
 
   // Now check that |pmd1| has been effectively merged.
-  ASSERT_EQ(5u, pmd1->allocator_dumps().size());
+  ASSERT_EQ(6u, pmd1->allocator_dumps().size());
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad1"));
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad2"));
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd2/mad1"));
   ASSERT_EQ(1u, pmd1->allocator_dumps().count("pmd1/mad2"));
   ASSERT_EQ(2u, pmd1->allocator_dumps_edges().size());
-  ASSERT_EQ(shared_mad, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid));
+  ASSERT_EQ(shared_mad1, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid1));
+  ASSERT_EQ(shared_mad2, pmd1->GetSharedGlobalAllocatorDump(shared_mad_guid2));
+  ASSERT_TRUE(MemoryAllocatorDump::Flags::WEAK & shared_mad2->flags());
 
   // Check that calling AsValueInto() doesn't cause a crash.
   traced_value = new TracedValue();
   pmd1->AsValueInto(traced_value.get());
 
   pmd1.reset();
 }
 
 TEST(ProcessMemoryDumpTest, Suballocations) {
   scoped_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump(nullptr));
@@ skipping 32 matching lines @@
   ASSERT_TRUE(found_edge[0]);
   ASSERT_TRUE(found_edge[1]);
 
   // Check that calling AsValueInto() doesn't cause a crash.
   scoped_refptr<TracedValue> traced_value(new TracedValue());
   pmd->AsValueInto(traced_value.get());
 
   pmd.reset();
 }
 
+TEST(ProcessMemoryDumpTest, GlobalAllocatorDumpTest) {
+  scoped_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump(nullptr));
+  MemoryAllocatorDumpGuid shared_mad_guid(1);
+  auto shared_mad1 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
+  ASSERT_EQ(shared_mad_guid, shared_mad1->guid());
+  ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
+
+  auto shared_mad2 = pmd->GetSharedGlobalAllocatorDump(shared_mad_guid);
+  ASSERT_EQ(shared_mad1, shared_mad2);
+  ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
+
+  auto shared_mad3 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
+  ASSERT_EQ(shared_mad1, shared_mad3);
+  ASSERT_EQ(MemoryAllocatorDump::Flags::WEAK, shared_mad1->flags());
+
+  auto shared_mad4 = pmd->CreateSharedGlobalAllocatorDump(shared_mad_guid);
+  ASSERT_EQ(shared_mad1, shared_mad4);
+  ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
+
+  auto shared_mad5 = pmd->CreateWeakSharedGlobalAllocatorDump(shared_mad_guid);
+  ASSERT_EQ(shared_mad1, shared_mad5);
+  ASSERT_EQ(MemoryAllocatorDump::Flags::DEFAULT, shared_mad1->flags());
+}
+
 #if defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 TEST(ProcessMemoryDumpTest, CountResidentBytes) {
   const size_t page_size = base::GetPageSize();
 
   // Allocate few page of dirty memory and check if it is resident.
   const size_t size1 = 5 * page_size;
   scoped_ptr<char, base::AlignedFreeDeleter> memory1(
       static_cast<char*>(base::AlignedAlloc(size1, page_size)));
   memset(memory1.get(), 0, size1);
   size_t res1 = ProcessMemoryDump::CountResidentBytes(memory1.get(), size1);
   ASSERT_EQ(res1, size1);
 
   // Allocate a large memory segment (>32Mib).
   const size_t kVeryLargeMemorySize = 34 * 1024 * 1024;
   scoped_ptr<char, base::AlignedFreeDeleter> memory2(
       static_cast<char*>(base::AlignedAlloc(kVeryLargeMemorySize, page_size)));
   memset(memory2.get(), 0, kVeryLargeMemorySize);
   size_t res2 = ProcessMemoryDump::CountResidentBytes(memory2.get(),
                                                       kVeryLargeMemorySize);
   ASSERT_EQ(res2, kVeryLargeMemorySize);
 }
 #endif  // defined(COUNT_RESIDENT_BYTES_SUPPORTED)
 
 }  // namespace trace_event
 }  // namespace base