content: Add GpuMemoryBuffer MemoryDumpProvider implementation.

content/browser/gpu/browser_gpu_memory_buffer_manager.cc

 // Copyright 2014 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 "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 
 #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"
 #include "content/common/gpu/client/gpu_memory_buffer_impl_shared_memory.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 namespace {
 
 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 {
   AllocateGpuMemoryBufferRequest(const gfx::Size& size,
                                  gfx::GpuMemoryBuffer::Format format,
                                  gfx::GpuMemoryBuffer::Usage usage,
                                  int client_id,
                                  int surface_id)
       : event(true, false),
         size(size),
@@ skipping 102 matching lines @@
   if (!gpu_memory_buffer_factory_host_->IsGpuMemoryBufferConfigurationSupported(
           format, usage)) {
     // Early out if we cannot fallback to shared memory buffer.
     if (!GpuMemoryBufferImplSharedMemory::IsFormatSupported(format) ||
         !GpuMemoryBufferImplSharedMemory::IsSizeValidForFormat(size, format) ||
         usage != gfx::GpuMemoryBuffer::MAP) {
       callback.Run(gfx::GpuMemoryBufferHandle());
       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;
   }
 
   // Note: Handling of cases where the child process is removed before the
   // 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,
       base::Bind(&BrowserGpuMemoryBufferManager::
                      GpuMemoryBufferAllocatedForChildProcess,
                  weak_ptr_factory_.GetWeakPtr(), child_client_id, callback));
 }
 
 gfx::GpuMemoryBuffer*
 BrowserGpuMemoryBufferManager::GpuMemoryBufferFromClientBuffer(
     ClientBuffer buffer) {
   return GpuMemoryBufferImpl::FromClientBuffer(buffer);
 }
 
 void BrowserGpuMemoryBufferManager::SetDestructionSyncPoint(
     gfx::GpuMemoryBuffer* buffer,
     uint32 sync_point) {
   static_cast<GpuMemoryBufferImpl*>(buffer)
       ->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,
     int child_client_id,
     uint32 sync_point) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(clients_.find(child_client_id) != clients_.end());
 
   BufferMap& buffers = clients_[child_client_id];
 
   BufferMap::iterator buffer_it = buffers.find(id);
   if (buffer_it == buffers.end()) {
     LOG(ERROR) << "Invalid GpuMemoryBuffer ID for child process.";
     return;
   }
 
   // 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);
   }
 
   buffers.erase(buffer_it);
 }
 
 void BrowserGpuMemoryBufferManager::ProcessRemoved(
     base::ProcessHandle process_handle,
     int client_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ClientMap::iterator client_it = clients_.find(client_id);
   if (client_it == clients_.end())
     return;
 
   for (auto &buffer_it : client_it->second) {
     // 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,
                                                             client_id,
                                                             0);
   }
 
   clients_.erase(client_it);
 }
 
@@ skipping 56 matching lines @@
           handle.id, child_client_id, 0);
     }
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   BufferMap& buffers = client_it->second;
 
   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);
     callback.Run(gfx::GpuMemoryBufferHandle());
     return;
   }
 
   // The factory should never return a shared memory backed buffer.
   DCHECK_NE(handle.type, gfx::SHARED_MEMORY_BUFFER);
 
   // 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);
 }
 
 }  // namespace content