[WIP] Add SharedMemoryTracker to dump base::SharedMemory usage

gpu/command_buffer/client/mapped_memory.cc

 // Copyright (c) 2011 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 "gpu/command_buffer/client/mapped_memory.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <functional>
 
 #include "base/atomic_sequence_num.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/common/buffer.h"
 
 namespace gpu {
 namespace {
@@ skipping 140 matching lines @@
     std::string dump_name =
         base::StringPrintf("gpu/mapped_memory/manager_%d", tracing_id_);
     MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
     dump->AddScalar(MemoryAllocatorDump::kNameSize,
                     MemoryAllocatorDump::kUnitsBytes, allocated_memory_);
 
     // Early out, no need for more detail in a BACKGROUND dump.
     return true;
   }
 
-  const uint64_t tracing_process_id =
-      base::trace_event::MemoryDumpManager::GetInstance()
-          ->GetTracingProcessId();
   for (const auto& chunk : chunks_) {
     std::string dump_name = base::StringPrintf(
         "gpu/mapped_memory/manager_%d/chunk_%d", tracing_id_, chunk->shm_id());
     MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(dump_name);
 
     dump->AddScalar(MemoryAllocatorDump::kNameSize,
                     MemoryAllocatorDump::kUnitsBytes, chunk->GetSize());
     dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes,
                     chunk->GetFreeSize());
 
-    auto guid = GetBufferGUIDForTracing(tracing_process_id, chunk->shm_id());
-
-    const int kImportance = 2;
-    pmd->CreateSharedGlobalAllocatorDump(guid);
-    pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
+    auto* shared_memory = chunk->buffer()->backing()->shared_memory();
+    if (shared_memory) {
+      base::SharedMemoryTracker::AddOwnershipEdges(pmd, dump->guid(),
+                                                   *shared_memory);
+    } else {
+      const uint64_t tracing_process_id =
+          base::trace_event::MemoryDumpManager::GetInstance()
+              ->GetTracingProcessId();
+      auto guid = GetBufferGUIDForTracing(tracing_process_id, chunk->shm_id());
+      const int kImportance = 2;
+      pmd->CreateSharedGlobalAllocatorDump(guid);
+      pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
+    }
   }
 
   return true;
 }
 
 void ScopedMappedMemoryPtr::Release() {
   if (buffer_) {
     mapped_memory_manager_->FreePendingToken(buffer_, helper_->InsertToken());
     buffer_ = nullptr;
     size_ = 0;
     shm_id_ = 0;
     shm_offset_ = 0;
 
     if (flush_after_release_)
       helper_->CommandBufferHelper::Flush();
   }
 }
 
 void ScopedMappedMemoryPtr::Reset(uint32_t new_size) {
   Release();
 
   if (new_size) {
     buffer_ = mapped_memory_manager_->Alloc(new_size, &shm_id_, &shm_offset_);
     size_ = buffer_ ? new_size : 0;
   }
 }
 
 }  // namespace gpu