content: Use the memory-infra graph API for GpuMemoryBufferManager.

This makes BrowserGpuMemoryBufferManager emit dumps of the form:
gpumemorybuffer/client_X/buffer_Y

This allows child process GpuMemoryBuffer clients to create a dump
for the same buffer by attaching the same guid to it. By doing that,
the trace-viewer UI can infer that the two buffers, that are,
"gpumemorybuffer/client_X/buffer_Y" on the browser side and
"gpumemorybuffer/buffer_Y" on the child side, refer to the same
memory and should be counted only once.

BUG=
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1230133008

Cr-Commit-Position: refs/heads/master@{#340104}

15 files changed, 85 insertions, 25 deletions

diff --git a/cc/test/test_gpu_memory_buffer_manager.cc b/cc/test/test_gpu_memory_buffer_manager.cc
index 154ead3..c889cb7 100644
--- a/cc/test/test_gpu_memory_buffer_manager.cc
+++ b/cc/test/test_gpu_memory_buffer_manager.cc
@@ -135,6 +135,10 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
       stride[i] =
           base::checked_cast<int>(StrideInBytes(size_.width(), format_, i));
   }
+  gfx::GpuMemoryBufferId GetId() const override {
+    NOTREACHED();
+    return 0;
+  }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     gfx::GpuMemoryBufferHandle handle;
     handle.type = gfx::SHARED_MEMORY_BUFFER;
diff --git a/components/view_manager/gles2/mojo_gpu_memory_buffer.cc b/components/view_manager/gles2/mojo_gpu_memory_buffer.cc
index 65c95e4..29c15d1 100644
--- a/components/view_manager/gles2/mojo_gpu_memory_buffer.cc
+++ b/components/view_manager/gles2/mojo_gpu_memory_buffer.cc
@@ -166,6 +166,10 @@ void MojoGpuMemoryBufferImpl::GetStride(int* stride) const {
         base::checked_cast<int>(StrideInBytes(size_.width(), format_, i));
 }
 
+gfx::GpuMemoryBufferId MojoGpuMemoryBufferImpl::GetId() const {
+  return 0;
+}
+
 gfx::GpuMemoryBufferHandle MojoGpuMemoryBufferImpl::GetHandle() const {
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
diff --git a/components/view_manager/gles2/mojo_gpu_memory_buffer.h b/components/view_manager/gles2/mojo_gpu_memory_buffer.h
index ca72945..9a98178 100644
--- a/components/view_manager/gles2/mojo_gpu_memory_buffer.h
+++ b/components/view_manager/gles2/mojo_gpu_memory_buffer.h
@@ -31,6 +31,7 @@ class MojoGpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   bool IsMapped() const override;
   Format GetFormat() const override;
   void GetStride(int* stride) const override;
+  gfx::GpuMemoryBufferId GetId() const override;
   gfx::GpuMemoryBufferHandle GetHandle() const override;
   ClientBuffer AsClientBuffer() override;
 
diff --git a/content/browser/compositor/buffer_queue_unittest.cc b/content/browser/compositor/buffer_queue_unittest.cc
index 5c52bfa..670d4d3 100644
--- a/content/browser/compositor/buffer_queue_unittest.cc
+++ b/content/browser/compositor/buffer_queue_unittest.cc
@@ -32,6 +32,7 @@ class StubGpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   bool IsMapped() const override { return false; }
   Format GetFormat() const override { return gfx::GpuMemoryBuffer::RGBX_8888; }
   void GetStride(int* stride) const override {}
+  gfx::GpuMemoryBufferId GetId() const override { return 0; }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     return gfx::GpuMemoryBufferHandle();
   }
diff --git a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
index 23d2b50..51e08cb 100644
--- a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
+++ b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
@@ -10,6 +10,7 @@
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/gpu/gpu_process_host.h"
@@ -123,8 +124,6 @@ BrowserGpuMemoryBufferManager* g_gpu_memory_buffer_manager = nullptr;
 // Global atomic to generate gpu memory buffer unique IDs.
 base::StaticAtomicSequenceNumber g_next_gpu_memory_buffer_id;
 
-const char kMemoryAllocatorName[] = "gpumemorybuffer";
-
 }  // namespace
 
 struct BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferRequest {
@@ -154,8 +153,7 @@ BrowserGpuMemoryBufferManager::BrowserGpuMemoryBufferManager(int gpu_client_id)
       supported_configurations_(
           GetSupportedGpuMemoryBufferConfigurations(factory_type_)),
       gpu_client_id_(gpu_client_id),
-      gpu_host_id_(0),
-      weak_ptr_factory_(this) {
+      gpu_host_id_(0) {
   DCHECK(!g_gpu_memory_buffer_manager);
   g_gpu_memory_buffer_manager = this;
 }
@@ -267,12 +265,16 @@ bool BrowserGpuMemoryBufferManager::OnMemoryDump(
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (const auto& client : clients_) {
+    int client_id = client.first;
+
     for (const auto& buffer : client.second) {
       if (buffer.second.type == gfx::EMPTY_BUFFER)
         continue;
 
-      base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
-          base::StringPrintf("%s/%d", kMemoryAllocatorName, buffer.first));
+      gfx::GpuMemoryBufferId buffer_id = buffer.first;
+      base::trace_event::MemoryAllocatorDump* dump =
+          pmd->CreateAllocatorDump(base::StringPrintf(
+              "gpumemorybuffer/client_%d/buffer_%d", client_id, buffer_id));
       if (!dump)
         return false;
 
@@ -287,6 +289,18 @@ bool BrowserGpuMemoryBufferManager::OnMemoryDump(
       dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                       base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                       buffer_size_in_bytes);
+
+      // Create the cross-process ownership edge. If the client creates a
+      // corresponding dump for the same buffer, this will avoid to
+      // double-count them in tracing. If, instead, no other process will emit a
+      // dump with the same guid, the segment will be accounted to the browser.
+      const uint64 client_tracing_process_id = base::trace_event::
+          MemoryDumpManager::ChildProcessIdToTracingProcessId(client_id);
+      base::trace_event::MemoryAllocatorDumpGuid shared_buffer_guid =
+          gfx::GetGpuMemoryBufferGUIDForTracing(client_tracing_process_id,
+                                                buffer_id);
+      pmd->CreateSharedGlobalAllocatorDump(shared_buffer_guid);
+      pmd->AddOwnershipEdge(dump->guid(), shared_buffer_guid);
     }
   }
 
@@ -394,8 +408,15 @@ void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForSurfaceOnIO(
   // Allocate shared memory buffer as fallback.
   buffers[new_id] = BufferInfo(request->size, gfx::SHARED_MEMORY_BUFFER,
                                request->format, request->usage, 0);
+  // Note: Unretained is safe as IO thread is stopped before manager is
+  // destroyed.
   request->result = GpuMemoryBufferImplSharedMemory::Create(
-      new_id, request->size, request->format);
+      new_id, request->size, request->format,
+      base::Bind(
+          &GpuMemoryBufferDeleted,
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
+          base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
+                     base::Unretained(this), new_id, request->client_id)));
   request->event.Signal();
 }
 
@@ -410,14 +431,15 @@ void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedForSurfaceOnIO(
     return;
   }
 
+  // Note: Unretained is safe as IO thread is stopped before manager is
+  // destroyed.
   request->result = GpuMemoryBufferImpl::CreateFromHandle(
       handle, request->size, request->format, request->usage,
       base::Bind(
           &GpuMemoryBufferDeleted,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
           base::Bind(&BrowserGpuMemoryBufferManager::DestroyGpuMemoryBufferOnIO,
-                     weak_ptr_factory_.GetWeakPtr(), handle.id,
-                     request->client_id)));
+                     base::Unretained(this), handle.id, request->client_id)));
   request->event.Signal();
 }
 
@@ -464,10 +486,12 @@ void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferOnIO(
   // and verify that this has not changed when allocation completes.
   buffers[id] = BufferInfo(size, gfx::EMPTY_BUFFER, format, usage, 0);
 
+  // Note: Unretained is safe as IO thread is stopped before manager is
+  // destroyed.
   host->CreateGpuMemoryBuffer(
       id, size, format, usage, client_id, surface_id,
       base::Bind(&BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedOnIO,
-                 weak_ptr_factory_.GetWeakPtr(), id, client_id, surface_id,
+                 base::Unretained(this), id, client_id, surface_id,
                  gpu_host_id_, reused_gpu_process, callback));
 }
 
diff --git a/content/browser/gpu/browser_gpu_memory_buffer_manager.h b/content/browser/gpu/browser_gpu_memory_buffer_manager.h
index 7941878..6a3d13b 100644
--- a/content/browser/gpu/browser_gpu_memory_buffer_manager.h
+++ b/content/browser/gpu/browser_gpu_memory_buffer_manager.h
@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "base/callback.h"
-#include "base/memory/weak_ptr.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
@@ -136,9 +135,6 @@ class CONTENT_EXPORT BrowserGpuMemoryBufferManager
   using ClientMap = base::hash_map<int, BufferMap>;
   ClientMap clients_;
 
-  // This should only be accessed on the IO thread.
-  base::WeakPtrFactory<BrowserGpuMemoryBufferManager> weak_ptr_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(BrowserGpuMemoryBufferManager);
 };
 
diff --git a/content/browser/renderer_host/media/video_capture_buffer_pool_unittest.cc b/content/browser/renderer_host/media/video_capture_buffer_pool_unittest.cc
index 4f3ce3d..4e61fab 100644
--- a/content/browser/renderer_host/media/video_capture_buffer_pool_unittest.cc
+++ b/content/browser/renderer_host/media/video_capture_buffer_pool_unittest.cc
@@ -69,6 +69,7 @@ class VideoCaptureBufferPoolTest
       *stride = size_.width() * 4;
       return;
     }
+    gfx::GpuMemoryBufferId GetId() const override { return 0; }
     gfx::GpuMemoryBufferHandle GetHandle() const override {
       return gfx::GpuMemoryBufferHandle();
     }
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl.cc b/content/common/gpu/client/gpu_memory_buffer_impl.cc
index fcf99bc..377bfe9 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl.cc
+++ b/content/common/gpu/client/gpu_memory_buffer_impl.cc
@@ -201,6 +201,10 @@ bool GpuMemoryBufferImpl::IsMapped() const {
   return mapped_;
 }
 
+gfx::GpuMemoryBufferId GpuMemoryBufferImpl::GetId() const {
+  return id_;
+}
+
 ClientBuffer GpuMemoryBufferImpl::AsClientBuffer() {
   return reinterpret_cast<ClientBuffer>(this);
 }
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl.h b/content/common/gpu/client/gpu_memory_buffer_impl.h
index 8fdfbd0..fa65133 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl.h
+++ b/content/common/gpu/client/gpu_memory_buffer_impl.h
@@ -61,6 +61,7 @@ class CONTENT_EXPORT GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   // Overridden from gfx::GpuMemoryBuffer:
   bool IsMapped() const override;
   Format GetFormat() const override;
+  gfx::GpuMemoryBufferId GetId() const override;
   ClientBuffer AsClientBuffer() override;
 
   void set_destruction_sync_point(uint32 sync_point) {
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
index 992372b..0ccf48f 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
+++ b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.cc
@@ -9,12 +9,6 @@
 #include "ui/gl/gl_bindings.h"
 
 namespace content {
-namespace {
-
-void Noop(uint32 sync_point) {
-}
-
-}  // namespace
 
 GpuMemoryBufferImplSharedMemory::GpuMemoryBufferImplSharedMemory(
     gfx::GpuMemoryBufferId id,
@@ -35,7 +29,8 @@ GpuMemoryBufferImplSharedMemory::~GpuMemoryBufferImplSharedMemory() {
 scoped_ptr<GpuMemoryBufferImpl> GpuMemoryBufferImplSharedMemory::Create(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
-    Format format) {
+    Format format,
+    const DestructionCallback& callback) {
   size_t buffer_size = 0u;
   if (!BufferSizeInBytes(size, format, &buffer_size))
     return scoped_ptr<GpuMemoryBufferImpl>();
@@ -45,7 +40,7 @@ scoped_ptr<GpuMemoryBufferImpl> GpuMemoryBufferImplSharedMemory::Create(
     return scoped_ptr<GpuMemoryBufferImpl>();
 
   return make_scoped_ptr(new GpuMemoryBufferImplSharedMemory(
-      id, size, format, base::Bind(&Noop), shared_memory.Pass()));
+      id, size, format, callback, shared_memory.Pass()));
 }
 
 // static
diff --git a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h
index 97d6b73..bb26deb 100644
--- a/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h
+++ b/content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h
@@ -14,9 +14,11 @@ class GpuMemoryBufferImplSharedMemory : public GpuMemoryBufferImpl {
  public:
   ~GpuMemoryBufferImplSharedMemory() override;
 
-  static scoped_ptr<GpuMemoryBufferImpl> Create(gfx::GpuMemoryBufferId id,
-                                                const gfx::Size& size,
-                                                Format format);
+  static scoped_ptr<GpuMemoryBufferImpl> Create(
+      gfx::GpuMemoryBufferId id,
+      const gfx::Size& size,
+      Format format,
+      const DestructionCallback& callback);
 
   static gfx::GpuMemoryBufferHandle AllocateForChildProcess(
       gfx::GpuMemoryBufferId id,
diff --git a/gpu/command_buffer/tests/gl_manager.cc b/gpu/command_buffer/tests/gl_manager.cc
index eee18aa..6dc8a10 100644
--- a/gpu/command_buffer/tests/gl_manager.cc
+++ b/gpu/command_buffer/tests/gl_manager.cc
@@ -159,6 +159,10 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
     for (size_t i = 0; i < num_planes; ++i)
       stride[i] = StrideInBytes(size_.width(), format_, i);
   }
+  gfx::GpuMemoryBufferId GetId() const override {
+    NOTREACHED();
+    return 0;
+  }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     NOTREACHED();
     return gfx::GpuMemoryBufferHandle();
diff --git a/media/renderers/mock_gpu_video_accelerator_factories.cc b/media/renderers/mock_gpu_video_accelerator_factories.cc
index a1f49e4..1bbc7ac 100644
--- a/media/renderers/mock_gpu_video_accelerator_factories.cc
+++ b/media/renderers/mock_gpu_video_accelerator_factories.cc
@@ -28,6 +28,10 @@ class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
   }
   Format GetFormat() const override { return gfx::GpuMemoryBuffer::R_8; }
   void GetStride(int* stride) const override { stride[0] = size_.width(); }
+  gfx::GpuMemoryBufferId GetId() const override {
+    NOTREACHED();
+    return 0;
+  }
   gfx::GpuMemoryBufferHandle GetHandle() const override {
     NOTREACHED();
     return gfx::GpuMemoryBufferHandle();
diff --git a/ui/gfx/gpu_memory_buffer.cc b/ui/gfx/gpu_memory_buffer.cc
index 54f7ce1..44fcd31 100644
--- a/ui/gfx/gpu_memory_buffer.cc
+++ b/ui/gfx/gpu_memory_buffer.cc
@@ -4,8 +4,19 @@
 
 #include "ui/gfx/gpu_memory_buffer.h"
 
+#include "base/format_macros.h"
+#include "base/strings/stringprintf.h"
+
 namespace gfx {
 
+base::trace_event::MemoryAllocatorDumpGuid GetGpuMemoryBufferGUIDForTracing(
+    uint64 tracing_process_id,
+    GpuMemoryBufferId buffer_id) {
+  return base::trace_event::MemoryAllocatorDumpGuid(
+      base::StringPrintf("gpumemorybuffer-x-process/%" PRIx64 "/%d",
+                         tracing_process_id, buffer_id));
+}
+
 GpuMemoryBufferHandle::GpuMemoryBufferHandle()
     : type(EMPTY_BUFFER), id(0), handle(base::SharedMemory::NULLHandle()) {
 }
diff --git a/ui/gfx/gpu_memory_buffer.h b/ui/gfx/gpu_memory_buffer.h
index aefad9d..30ae21c 100644
--- a/ui/gfx/gpu_memory_buffer.h
+++ b/ui/gfx/gpu_memory_buffer.h
@@ -6,6 +6,7 @@
 #define UI_GFX_GPU_MEMORY_BUFFER_H_
 
 #include "base/memory/shared_memory.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "build/build_config.h"
 #include "ui/gfx/gfx_export.h"
 
@@ -32,6 +33,10 @@ struct GFX_EXPORT GpuMemoryBufferHandle {
   base::SharedMemoryHandle handle;
 };
 
+base::trace_event::MemoryAllocatorDumpGuid GFX_EXPORT
+GetGpuMemoryBufferGUIDForTracing(uint64 tracing_process_id,
+                                 GpuMemoryBufferId buffer_id);
+
 // This interface typically correspond to a type of shared memory that is also
 // shared with the GPU. A GPU memory buffer can be written to directly by
 // regular CPU code, but can also be read by the GPU.
@@ -85,6 +90,9 @@ class GFX_EXPORT GpuMemoryBuffer {
   // plane K is stored at index K-1 of the |stride| array.
   virtual void GetStride(int* stride) const = 0;
 
+  // Returns a unique identifier associated with buffer.
+  virtual GpuMemoryBufferId GetId() const = 0;
+
   // Returns a platform specific handle for this buffer.
   virtual GpuMemoryBufferHandle GetHandle() const = 0;