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

cc/raster/staging_buffer_pool.cc

 // Copyright 2016 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 "cc/raster/staging_buffer_pool.h"
 
 #include <memory>
 
 #include "base/memory/memory_coordinator_client_registry.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 "cc/base/container_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
-#include "ui/gfx/gpu_memory_buffer_tracing.h"
 
 using base::trace_event::MemoryAllocatorDump;
 using base::trace_event::MemoryAllocatorDumpGuid;
 using base::trace_event::MemoryDumpLevelOfDetail;
 
 namespace cc {
 namespace {
 
 // Delay between checking for query result to be available.
 const int kCheckForQueryResultAvailableTickRateMs = 1;
@@ skipping 74 matching lines @@
   MemoryAllocatorDump* buffer_dump = pmd->CreateAllocatorDump(buffer_dump_name);
 
   uint64_t buffer_size_in_bytes =
       ResourceUtil::UncheckedSizeInBytes<uint64_t>(size, format);
   buffer_dump->AddScalar(MemoryAllocatorDump::kNameSize,
                          MemoryAllocatorDump::kUnitsBytes,
                          buffer_size_in_bytes);
   buffer_dump->AddScalar("free_size", MemoryAllocatorDump::kUnitsBytes,
                          in_free_list ? buffer_size_in_bytes : 0);
 
-  // Emit an ownership edge towards a global allocator dump node.
-  const uint64_t tracing_process_id =
-      base::trace_event::MemoryDumpManager::GetInstance()
-          ->GetTracingProcessId();
-  auto shared_buffer_guid =
-      gpu_memory_buffer->GetGUIDForTracing(tracing_process_id);
-  pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
+  base::SharedMemory* shared_memory = gpu_memory_buffer->GetSharedMemory();
+  if (shared_memory) {
+    base::SharedMemoryTracker::AddOwnershipEdges(pmd, buffer_dump->guid(),
+                                                 *shared_memory);
+  } else {
+    // Emit an ownership edge towards a global allocator dump node.
+    const uint64_t tracing_process_id =
+        base::trace_event::MemoryDumpManager::GetInstance()
+            ->GetTracingProcessId();
+    auto shared_buffer_guid =
+        gpu_memory_buffer->GetGUIDForTracing(tracing_process_id);
+    pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
 
-  // By creating an edge with a higher |importance| (w.r.t. browser-side dumps)
-  // the tracing UI will account the effective size of the buffer to the child.
-  const int kImportance = 2;
-  pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
+    // By creating an edge with a higher |importance| (w.r.t. browser-side
+    // dumps) the tracing UI will account the effective size of the buffer to
+    // the child.
+    const int kImportance = 2;
+    pmd->AddOwnershipEdge(buffer_dump->guid(), shared_buffer_guid, kImportance);
+  }
 }
 
 StagingBufferPool::StagingBufferPool(base::SequencedTaskRunner* task_runner,
                                      ContextProvider* worker_context_provider,
                                      ResourceProvider* resource_provider,
                                      bool use_partial_raster,
                                      int max_staging_buffer_usage_in_bytes)
     : task_runner_(task_runner),
       worker_context_provider_(worker_context_provider),
       resource_provider_(resource_provider),
@@ skipping 298 matching lines @@
   }
 }
 
 void StagingBufferPool::OnPurgeMemory() {
   base::AutoLock lock(lock_);
   // Release all buffers, regardless of how recently they were used.
   ReleaseBuffersNotUsedSince(base::TimeTicks() + base::TimeDelta::Max());
 }
 
 }  // namespace cc