[memory-infra] Add API to ProcessMemoryDump to create ownership edges for base::SharedMemory

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/memory/ptr_util.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/process/process_metrics.h"
 #include "base/trace_event/memory_allocator_dump_guid.h"
 #include "base/trace_event/memory_infra_background_whitelist.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "base/unguessable_token.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 const MemoryDumpArgs kDetailedDumpArgs = {MemoryDumpLevelOfDetail::DETAILED};
 const char* const kTestDumpNameWhitelist[] = {
     "Whitelisted/TestName", "Whitelisted/TestName_0x?",
@@ skipping 268 matching lines @@
 
   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());
 }
 
+TEST(ProcessMemoryDumpTest, OldSharedMemoryOwnershipTest) {
+  std::unique_ptr<ProcessMemoryDump> pmd(
+      new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
+  const ProcessMemoryDump::AllocatorDumpEdgesMap& edges =
+      pmd->allocator_dumps_edges_for_testing();
+
+  auto* shm_dump1 = pmd->CreateAllocatorDump("shared_mem/seg1");
+
+  auto* client_dump1 = pmd->CreateAllocatorDump("discardable/segment1");
+  MemoryAllocatorDumpGuid client_global_guid1(1);
+  auto shm_token1 = UnguessableToken::Create();
+  MemoryAllocatorDumpGuid shm_global_guid1 =
+      SharedMemoryTracker::GetGlobalDumpGUIDForTracing(shm_token1);
+  pmd->AddOverridableOwnershipEdge(shm_dump1->guid(), shm_global_guid1,
+                                   0 /* importance */);
+
+  pmd->CreateSharedMemoryOwnershipEdge(client_dump1->guid(),
+                                       client_global_guid1, shm_token1,
+                                       1 /* importance */);
+
+  EXPECT_EQ(2u, edges.size());
+  EXPECT_EQ(shm_global_guid1, edges.find(shm_dump1->guid())->second.target);
+  EXPECT_EQ(0, edges.find(shm_dump1->guid())->second.importance);
+  EXPECT_TRUE(edges.find(shm_dump1->guid())->second.overridable);
+  EXPECT_EQ(client_global_guid1,
+            edges.find(client_dump1->guid())->second.target);
+  EXPECT_EQ(1, edges.find(client_dump1->guid())->second.importance);
+  EXPECT_FALSE(edges.find(client_dump1->guid())->second.overridable);
+}
+
+TEST(ProcessMemoryDumpTest, NewSharedMemoryOwnershipTest) {
+  std::unique_ptr<ProcessMemoryDump> pmd(
+      new ProcessMemoryDump(nullptr, kDetailedDumpArgs));
+  const ProcessMemoryDump::AllocatorDumpEdgesMap& edges =
+      pmd->allocator_dumps_edges_for_testing();
+  MemoryAllocatorDumpGuid::SetUseSharedMemoryBasedGUIDsForTesting();
+
+  auto* client_dump2 = pmd->CreateAllocatorDump("discardable/segment2");
+  MemoryAllocatorDumpGuid client_global_guid2(2);
+  auto shm_token2 = UnguessableToken::Create();
+  MemoryAllocatorDumpGuid shm_local_guid2 =
+      SharedMemoryTracker::GetDumpGUIDForTracing(shm_token2);
+  MemoryAllocatorDumpGuid shm_global_guid2 =
+      SharedMemoryTracker::GetGlobalDumpGUIDForTracing(shm_token2);
+  pmd->AddOverridableOwnershipEdge(shm_local_guid2, shm_global_guid2,
+                                   0 /* importance */);
+
+  pmd->CreateSharedMemoryOwnershipEdge(client_dump2->guid(),
+                                       client_global_guid2, shm_token2,
+                                       1 /* importance */);
+  EXPECT_EQ(2u, edges.size());
+
+  EXPECT_EQ(shm_global_guid2, edges.find(shm_local_guid2)->second.target);
+  EXPECT_EQ(1, edges.find(shm_local_guid2)->second.importance);
+  EXPECT_FALSE(edges.find(shm_local_guid2)->second.overridable);
+  EXPECT_EQ(shm_local_guid2, edges.find(client_dump2->guid())->second.target);
+  EXPECT_EQ(0, edges.find(client_dump2->guid())->second.importance);
+  EXPECT_FALSE(edges.find(client_dump2->guid())->second.overridable);
+}
+
 TEST(ProcessMemoryDumpTest, BackgroundModeTest) {
   MemoryDumpArgs background_args = {MemoryDumpLevelOfDetail::BACKGROUND};
   std::unique_ptr<ProcessMemoryDump> pmd(
       new ProcessMemoryDump(nullptr, background_args));
   ProcessMemoryDump::is_black_hole_non_fatal_for_testing_ = true;
   SetAllocatorDumpNameWhitelistForTesting(kTestDumpNameWhitelist);
   MemoryAllocatorDump* black_hole_mad = pmd->GetBlackHoleMad();
 
   // Invalid dump names.
   EXPECT_EQ(black_hole_mad,
@@ skipping 50 matching lines @@
       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