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

media/video/gpu_memory_buffer_video_frame_pool.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 "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <list>
 #include <memory>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/containers/stack_container.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/shared_memory.h"
+#include "base/memory/shared_memory_tracker.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "ui/gfx/buffer_format_util.h"
@@ skipping 411 matching lines @@
   }
 
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PoolImpl::CopyVideoFrameToGpuMemoryBuffers, this,
                             video_frame, frame_resources, frame_ready_cb));
 }
 
 bool GpuMemoryBufferVideoFramePool::PoolImpl::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
-  const uint64_t tracing_process_id =
-      base::trace_event::MemoryDumpManager::GetInstance()
-          ->GetTracingProcessId();
-  const int kImportance = 2;
+  // const int kImportance = 2;
   for (const FrameResources* frame_resources : resources_pool_) {
     for (const PlaneResource& plane_resource :
          frame_resources->plane_resources) {
       if (plane_resource.gpu_memory_buffer) {
         gfx::GpuMemoryBufferId buffer_id =
             plane_resource.gpu_memory_buffer->GetId();
         std::string dump_name = base::StringPrintf(
             "media/video_frame_memory/buffer_%d", buffer_id.id);
         base::trace_event::MemoryAllocatorDump* dump =
             pmd->CreateAllocatorDump(dump_name);
         size_t buffer_size_in_bytes = gfx::BufferSizeForBufferFormat(
             plane_resource.size, plane_resource.gpu_memory_buffer->GetFormat());
         dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                         buffer_size_in_bytes);
         dump->AddScalar("free_size",
                         base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                         frame_resources->IsInUse() ? 0 : buffer_size_in_bytes);
-        base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid =
-            gfx::GetGpuMemoryBufferGUIDForTracing(tracing_process_id,
-                                                  buffer_id);
-        pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
-        pmd->AddOwnershipEdge(dump->guid(), shared_buffer_guid, kImportance);
+        // TODO: Fix this
+        /*base::SharedMemory* shared_memory =
+            plane_resource.gpu_memory_buffer->GetHandle();
+        base::SharedMemoryTracker::AddOwnershipEdges(
+        pmd, dump, *shared_memory, buffer_size_in_bytes);*/
       }
     }
   }
   return true;
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::OnCopiesDone(
     const scoped_refptr<VideoFrame>& video_frame,
     FrameResources* frame_resources,
     const FrameReadyCB& frame_ready_cb) {
@@ skipping 336 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media