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

base/trace_event/process_memory_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/process_memory_dump.h"
 
 #include <errno.h>
 
 #include <vector>
 
 #include "base/memory/ptr_util.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/heap_profiler_heap_dump_writer.h"
 #include "base/trace_event/memory_infra_background_whitelist.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
+#include "base/unguessable_token.h"
 #include "build/build_config.h"
 
 #if defined(OS_IOS)
 #include <mach/vm_page_size.h>
 #endif
 
 #if defined(OS_POSIX)
 #include <sys/mman.h>
 #endif
 
@@ skipping 318 matching lines @@
   allocator_dumps_edges_[source] = {
       source, target, importance, kEdgeTypeOwnership, false /* overridable */};
 }
 
 void ProcessMemoryDump::AddOwnershipEdge(
     const MemoryAllocatorDumpGuid& source,
     const MemoryAllocatorDumpGuid& target) {
   AddOwnershipEdge(source, target, 0 /* importance */);
 }
 
+void ProcessMemoryDump::CreateSharedMemoryOwnershipEdge(
+    const MemoryAllocatorDumpGuid& client_local_dump_guid,
+    const MemoryAllocatorDumpGuid& client_global_dump_guid,
+    const UnguessableToken& shared_memory_guid,
+    int importance) {
+  CreateWeakSharedMemoryOwnershipEdge(
+      client_local_dump_guid, client_global_dump_guid, shared_memory_guid,
+      importance, false /*is_weak*/);
+}
+
 void ProcessMemoryDump::AddOverridableOwnershipEdge(
     const MemoryAllocatorDumpGuid& source,
     const MemoryAllocatorDumpGuid& target,
     int importance) {
   if (allocator_dumps_edges_.find(source) == allocator_dumps_edges_.end()) {
     allocator_dumps_edges_[source] = {
         source, target, importance, kEdgeTypeOwnership, true /* overridable */};
   } else {
     // An edge between the source and target already exits. So, do nothing here
     // since the new overridable edge is implicitly overridden by a strong edge
     // which was created earlier.
     DCHECK(!allocator_dumps_edges_[source].overridable);
   }
 }
 
+void ProcessMemoryDump::CreateWeakSharedMemoryOwnershipEdge(
+    const MemoryAllocatorDumpGuid& client_local_dump_guid,
+    const MemoryAllocatorDumpGuid& client_global_dump_guid,
+    const UnguessableToken& shared_memory_guid,
+    int importance,
+    bool is_weak) {
+  if (MemoryAllocatorDumpGuid::UseSharedMemoryBasedGUIDs() &&
+      !shared_memory_guid.is_empty()) {
+    // New model where the global dumps created by SharedMemoryTracker are used
+    // for the clients.
+

[hajimehoshi, 2017/06/07 04:58:04]

First I thought CreateSharedGlobalAllocatorDump should be called here (and
actually I commented about this in the doc), but it might be that we can assume
all shared global dumps are created at SharedMemoryTracker? If so, I'd leave a
comment explaining this.

[ssid, 2017/06/08 00:05:58]

Added extra comment.
That is exactly what the todo below tells. We do not need to create dumps
because the tracker creates it. But we need a GetOrCreate method to change it to
weak.

+    // The guid of the local dump cretaed by
+    // SharedMemoryTracker for the memory segment.
+    auto local_shm_guid =
+        SharedMemoryTracker::GetDumpGUIDForTracing(shared_memory_guid);
+    // The dump guid of the global dump cretaed by the tracker for the memory
+    // segment.
+    auto global_shm_guid =
+        SharedMemoryTracker::GetGlobalDumpGUIDForTracing(shared_memory_guid);
+    // Create an edge between local dump of the client and the local dump of the
+    // SharedMemoryTracker.
+    AddOwnershipEdge(client_local_dump_guid, local_shm_guid);
+
+    // TODO(ssid): Handle the case of weak dumps here. This needs a new function
+    // GetOrCreaetGlobalDump() in PMD since we need to change the behavior of
+    // the created global dump.
+    // Create an edge that overrides the edge created
+    // by SharedMemoryTracker.
+    AddOwnershipEdge(local_shm_guid, global_shm_guid, importance);
+  } else {
+    // This is the old model where the clients create global dumps for
+    // themselves.
+    if (is_weak)
+      CreateWeakSharedGlobalAllocatorDump(client_global_dump_guid);
+    else
+      CreateSharedGlobalAllocatorDump(client_global_dump_guid);
+    AddOwnershipEdge(client_local_dump_guid, client_global_dump_guid,
+                     importance);
+  }
+}
+
 void ProcessMemoryDump::AddSuballocation(const MemoryAllocatorDumpGuid& source,
                                          const std::string& target_node_name) {
   // Do not create new dumps for suballocations in background mode.
   if (dump_args_.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND)
     return;
 
   std::string child_mad_name = target_node_name + "/__" + source.ToString();
   MemoryAllocatorDump* target_child_mad = CreateAllocatorDump(child_mad_name);
   AddOwnershipEdge(source, target_child_mad->guid());
 }
 
 MemoryAllocatorDump* ProcessMemoryDump::GetBlackHoleMad() {
   DCHECK(is_black_hole_non_fatal_for_testing_);
   if (!black_hole_mad_)
     black_hole_mad_.reset(new MemoryAllocatorDump("discarded", this));
   return black_hole_mad_.get();
 }
 
 }  // namespace trace_event
 }  // namespace base