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

components/viz/display_compositor/host_shared_bitmap_manager.cc

 // Copyright 2013 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 "components/viz/display_compositor/host_shared_bitmap_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "build/build_config.h"
 #include "mojo/public/cpp/system/platform_handle.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace viz {
 
 class BitmapData : public base::RefCountedThreadSafe<BitmapData> {
@@ skipping 19 matching lines @@
                    HostSharedBitmapManager* manager)
       : SharedBitmap(pixels, id),
         bitmap_data_(bitmap_data),
         manager_(manager) {}
 
   ~HostSharedBitmap() override {
     if (manager_)
       manager_->FreeSharedMemoryFromMap(id());
   }
 
+  base::SharedMemory* GetSharedMemory() const override {
+    return bitmap_data_->memory.get();
+  }
+
  private:
   scoped_refptr<BitmapData> bitmap_data_;
   HostSharedBitmapManager* manager_;
 };
 
 }  // namespace
 
 base::LazyInstance<HostSharedBitmapManager>::DestructorAtExit
     g_shared_memory_manager = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 105 matching lines @@
             "sharedbitmap/%s",
             base::HexEncode(bitmap.first.name, sizeof(bitmap.first.name))
                 .c_str()));
     if (!dump)
       return false;
 
     dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                     base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                     bitmap.second->buffer_size);
 
-    // Generate a global GUID used to share this allocation with renderer
-    // processes.
-    auto guid = cc::GetSharedBitmapGUIDForTracing(bitmap.first);
-    pmd->CreateSharedGlobalAllocatorDump(guid);
-    pmd->AddOwnershipEdge(dump->guid(), guid);
+    if (bitmap.second->memory) {
+      base::SharedMemoryTracker::AddOwnershipEdges(pmd, dump->guid(),
+                                                   *bitmap.second->memory);
+    } else {
+      // Generate a global GUID used to share this allocation with renderer
+      // processes.
+      auto guid = cc::GetSharedBitmapGUIDForTracing(bitmap.first);
+      pmd->CreateSharedGlobalAllocatorDump(guid);
+      pmd->AddOwnershipEdge(dump->guid(), guid);
+    }
   }
 
   return true;
 }
 
 bool HostSharedBitmapManager::ChildAllocatedSharedBitmap(
     size_t buffer_size,
     const base::SharedMemoryHandle& handle,
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
@@ skipping 19 matching lines @@
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 }  // namespace viz