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

base/trace_event/process_memory_dump.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
 #define BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_
 
 #include <stddef.h>
 
 #include <map>
@@ skipping 12 matching lines @@
 #include "base/trace_event/process_memory_totals.h"
 #include "build/build_config.h"
 
 // Define COUNT_RESIDENT_BYTES_SUPPORTED if platform supports counting of the
 // resident memory.
 #if (defined(OS_POSIX) && !defined(OS_NACL)) || defined(OS_WIN)
 #define COUNT_RESIDENT_BYTES_SUPPORTED
 #endif
 
 namespace base {
+
+class UnguessableToken;
+
 namespace trace_event {
 
 class HeapProfilerSerializationState;
 class TracedValue;
 
 // ProcessMemoryDump is as a strongly typed container which holds the dumps
 // produced by the MemoryDumpProvider(s) for a specific process.
 class BASE_EXPORT ProcessMemoryDump {
  public:
   struct MemoryAllocatorDumpEdge {
@@ skipping 100 matching lines @@
   void AddOwnershipEdge(const MemoryAllocatorDumpGuid& source,
                         const MemoryAllocatorDumpGuid& target);
 
   // Adds edges that can be overriden by a later or earlier call to
   // AddOwnershipEdge() with the same source and target with a different
   // |importance| value.
   void AddOverridableOwnershipEdge(const MemoryAllocatorDumpGuid& source,
                                    const MemoryAllocatorDumpGuid& target,
                                    int importance);
 
+  // Creates ownership edges for memory backed by base::SharedMemory. Handles
+  // the case of cross process sharing and importnace of ownership for the case
+  // with and without the base::SharedMemory dump provider. The new version
+  // should just use global dumps created by SharedMemoryTracker and this
+  // function handles the transition until we get SharedMemory IDs through mojo
+  // channel crbug.com/713763. The weak version creates a weak global dump.
+  // |client_local_dump_guid| The guid of the local dump created by the client
+  // of base::SharedMemory.
+  // |client_global_dump_guid| The global guid given by the clients to create
+  // ownership edges of their own. These global dumps will no longer be required
+  // after the transition.
+  // |shared_memory_guid| The ID of the base::SharedMemory that is assigned
+  // globally, used to create global dump edges in the new model.
+  // |importance| Importance of the global dump edges to say if the current
+  // process owns the memory segment.

[dcheng, 2017/06/08 19:28:30]

I'm not sure what "importance" means still based on this comment. Is this to
help hint which process the shared memory should be counted against?

[ssid, 2017/06/08 19:43:16]

what importance means is explained in the comment on function
AddOwnershipEdge(). "importance of edges" refers to the description in line 141.
That is why I did not explain in further detail here.

Yes you are right about how importance is used.

[dcheng, 2017/06/08 20:40:52]

I see; I didn't see it because that section was collapsed by default in the
Rietveld diff.

[ssid, 2017/06/08 20:43:35]

Or maybe memory-infra is too complicated :P

+  void CreateSharedMemoryOwnershipEdge(
+      const MemoryAllocatorDumpGuid& client_local_dump_guid,
+      const MemoryAllocatorDumpGuid& client_global_dump_guid,
+      const UnguessableToken& shared_memory_guid,
+      int importance);
+  void CreateWeakSharedMemoryOwnershipEdge(
+      const MemoryAllocatorDumpGuid& client_local_dump_guid,
+      const MemoryAllocatorDumpGuid& client_global_dump_guid,
+      const UnguessableToken& shared_memory_guid,
+      int importance);
+
   const AllocatorDumpEdgesMap& allocator_dumps_edges_for_testing() const {
     return allocator_dumps_edges_;
   }
 
   // Utility method to add a suballocation relationship with the following
   // semantics: |source| is suballocated from |target_node_name|.
   // This creates a child node of |target_node_name| and adds an ownership edge
   // between |source| and the new child node. As a result, the UI will not
   // account the memory of |source| in the target node.
   void AddSuballocation(const MemoryAllocatorDumpGuid& source,
@@ skipping 31 matching lines @@
   const HeapDumpsMap& heap_dumps() const { return heap_dumps_; }
 
   const MemoryDumpArgs& dump_args() const { return dump_args_; }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ProcessMemoryDumpTest, BackgroundModeTest);
 
   MemoryAllocatorDump* AddAllocatorDumpInternal(
       std::unique_ptr<MemoryAllocatorDump> mad);
 
+  void CreateSharedMemoryOwnershipEdgeInternal(
+      const MemoryAllocatorDumpGuid& client_local_dump_guid,
+      const MemoryAllocatorDumpGuid& client_global_dump_guid,
+      const UnguessableToken& shared_memory_guid,
+      int importance,
+      bool is_weak);

[dcheng, 2017/06/08 19:28:30]

Normally I would suggest using an enum, the bool is pretty unclear

(but maybe this is OK since it's a private helper)

[ssid, 2017/06/08 19:43:16]

Yeah, i feel enum is not required for an internal implementation.

+
   MemoryAllocatorDump* GetBlackHoleMad();
 
   ProcessMemoryTotals process_totals_;
   bool has_process_totals_;
 
   ProcessMemoryMaps process_mmaps_;
   bool has_process_mmaps_;
 
   AllocatorDumpsMap allocator_dumps_;
   HeapDumpsMap heap_dumps_;
@@ skipping 17 matching lines @@
   // background mode are disabled for testing.
   static bool is_black_hole_non_fatal_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessMemoryDump);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_PROCESS_MEMORY_DUMP_H_