content: Add GpuMemoryBuffer MemoryDumpProvider implementation.

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

Index: content/browser/gpu/browser_gpu_memory_buffer_manager.cc
diff --git a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
index 59b2ed7f26f9081b053248e234bbc7ee58914df1..1ec8aeb84e0726d2cece87af4a93c2c1a104069a 100644
--- a/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
+++ b/content/browser/gpu/browser_gpu_memory_buffer_manager.cc
@@ -7,8 +7,10 @@
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
+#include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_restrictions.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/client/gpu_memory_buffer_factory_host.h"
 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
@@ -23,6 +25,8 @@ 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 {
@@ -145,7 +149,7 @@ void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
       return;
     }
 
-    buffers[new_id] = gfx::SHARED_MEMORY_BUFFER;
+    buffers[new_id] = BufferInfo(size, format, gfx::SHARED_MEMORY_BUFFER);
     callback.Run(GpuMemoryBufferImplSharedMemory::AllocateForChildProcess(
         new_id, size, format, child_process_handle));
     return;
@@ -155,7 +159,7 @@ void BrowserGpuMemoryBufferManager::AllocateGpuMemoryBufferForChildProcess(
   // allocation completes is less subtle if we set the buffer type to
   // EMPTY_BUFFER here and verify that this has not changed when allocation
   // completes.
-  buffers[new_id] = gfx::EMPTY_BUFFER;
+  buffers[new_id] = BufferInfo(size, format, gfx::EMPTY_BUFFER);
 
   gpu_memory_buffer_factory_host_->CreateGpuMemoryBuffer(
       new_id, size, format, usage, child_client_id, 0,
@@ -177,6 +181,38 @@ void BrowserGpuMemoryBufferManager::SetDestructionSyncPoint(
       ->set_destruction_sync_point(sync_point);
 }
 
+bool BrowserGpuMemoryBufferManager::OnMemoryDump(
+    base::trace_event::ProcessMemoryDump* pmd) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  for (auto& client_it : clients_) {

[Primiano Tucci (use gerrit), 2015/04/28 20:13:08]

Maybe these two could be "const" auto& (or is there some non-const accessor
there)?

[reveman, 2015/04/28 20:52:25]

Done.

+    for (auto& buffer_it : client_it.second) {
+      if (buffer_it.second.type == gfx::EMPTY_BUFFER)
+        continue;
+
+      base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
+          base::StringPrintf("%s/%d", kMemoryAllocatorName, buffer_it.first));
+      if (!dump)
+        return false;
+
+      size_t buffer_size_in_bytes = 0;
+      // Note: BufferSizeInBytes returns an approximated size for the buffer
+      // but the factory can be made to return the exact size if this
+      // approximation is not good enough.
+      bool valid_size = GpuMemoryBufferImpl::BufferSizeInBytes(
+          buffer_it.second.size, buffer_it.second.format,
+          &buffer_size_in_bytes);
+      DCHECK(valid_size);
+
+      dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameInnerSize,

[Primiano Tucci (use gerrit), 2015/04/28 20:13:08]

Is it this really intending to be InnerSize (As opposite to OuterSize).
In my mind an allocator should offer either the OuterSize or both. In essence
it's mostly a deal of being aware or not of internal fragmentation / bookeeping
metadata etc.

If you did just because kNameInnerSize is what shows up in the UI... we just
fixed that and will be reversed in the next UI roll (i.e. kNameOuterSize will be
the thing that the UI will show by default in the summary).

[reveman, 2015/04/28 20:52:25]

I used InnerSize as we don't know what the internal fragmentation and possible
book keeping metadata is at this level. The comment above is related to this.

I changed it in latest patch as I think it's better to think of it as OuterSize
at this level and add another dump provider at the lower level with InnerSize
that matches the OuterSize here if necessary.

+                      base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                      buffer_size_in_bytes);
+    }
+  }
+
+  return true;
+}
+
 void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     base::ProcessHandle child_process_handle,
@@ -195,14 +231,14 @@ void BrowserGpuMemoryBufferManager::ChildProcessDeletedGpuMemoryBuffer(
 
   // This can happen if a child process managed to trigger a call to this while
   // a buffer is in the process of being allocated.
-  if (buffer_it->second == gfx::EMPTY_BUFFER) {
+  if (buffer_it->second.type == gfx::EMPTY_BUFFER) {
     LOG(ERROR) << "Invalid GpuMemoryBuffer type.";
     return;
   }
 
   // Buffers allocated using the factory need to be destroyed through the
   // factory.
-  if (buffer_it->second != gfx::SHARED_MEMORY_BUFFER) {
+  if (buffer_it->second.type != gfx::SHARED_MEMORY_BUFFER) {
     gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(id,
                                                             child_client_id,
                                                             sync_point);
@@ -224,11 +260,11 @@ void BrowserGpuMemoryBufferManager::ProcessRemoved(
     // This might happen if buffer is currenlty in the process of being
     // allocated. The buffer will in that case be cleaned up when allocation
     // completes.
-    if (buffer_it.second == gfx::EMPTY_BUFFER)
+    if (buffer_it.second.type == gfx::EMPTY_BUFFER)
       continue;
 
     // Skip shared memory buffers as they were not allocated using the factory.
-    if (buffer_it.second == gfx::SHARED_MEMORY_BUFFER)
+    if (buffer_it.second.type == gfx::SHARED_MEMORY_BUFFER)
       continue;
 
     gpu_memory_buffer_factory_host_->DestroyGpuMemoryBuffer(buffer_it.first,
@@ -305,7 +341,7 @@ void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedForChildProcess(
 
   BufferMap::iterator buffer_it = buffers.find(handle.id);
   DCHECK(buffer_it != buffers.end());
-  DCHECK_EQ(buffer_it->second, gfx::EMPTY_BUFFER);
+  DCHECK_EQ(buffer_it->second.type, gfx::EMPTY_BUFFER);
 
   if (handle.is_null()) {
     buffers.erase(buffer_it);
@@ -318,7 +354,7 @@ void BrowserGpuMemoryBufferManager::GpuMemoryBufferAllocatedForChildProcess(
 
   // Store the type of this buffer so it can be cleaned up if the child
   // process is removed.
-  buffer_it->second = handle.type;
+  buffer_it->second.type = handle.type;
 
   callback.Run(handle);
 }