Logs buffers/renderbuffers. Additionally, makes

textures/buffers/renderbuffers children of the existing whole-client
dump, which will help catch errors in one or the other.

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

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

5 files changed, 116 insertions, 34 deletions

diff --git a/gpu/command_buffer/service/buffer_manager.cc b/gpu/command_buffer/service/buffer_manager.cc
index 59eef3a..e5fb1fe 100644
--- a/gpu/command_buffer/service/buffer_manager.cc
+++ b/gpu/command_buffer/service/buffer_manager.cc
@@ -5,6 +5,9 @@
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include <limits>
 #include "base/logging.h"
+#include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
@@ -13,34 +16,46 @@
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_implementation.h"
+#include "ui/gl/trace_util.h"
 
 namespace gpu {
 namespace gles2 {
 
-BufferManager::BufferManager(
-    MemoryTracker* memory_tracker,
-    FeatureInfo* feature_info)
-    : memory_tracker_(
+BufferManager::BufferManager(MemoryTracker* memory_tracker,
+                             FeatureInfo* feature_info)
+    : memory_type_tracker_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
+      memory_tracker_(memory_tracker),
       feature_info_(feature_info),
       allow_buffers_on_multiple_targets_(false),
       allow_fixed_attribs_(false),
       buffer_count_(0),
       have_context_(true),
       use_client_side_arrays_for_stream_buffers_(
-          feature_info ? feature_info->workarounds(
-              ).use_client_side_arrays_for_stream_buffers : 0) {
+          feature_info
+              ? feature_info->workarounds()
+                    .use_client_side_arrays_for_stream_buffers
+              : 0) {
+  // When created from InProcessCommandBuffer, we won't have a |memory_tracker_|
+  // so don't register a dump provider.
+  if (memory_tracker_) {
+    base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+        this, base::ThreadTaskRunnerHandle::Get());
+  }
 }
 
 BufferManager::~BufferManager() {
   DCHECK(buffers_.empty());
   CHECK_EQ(buffer_count_, 0u);
+
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 void BufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
   buffers_.clear();
-  DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
+  DCHECK_EQ(0u, memory_type_tracker_->GetMemRepresented());
 }
 
 void BufferManager::CreateBuffer(GLuint client_id, GLuint service_id) {
@@ -70,7 +85,7 @@ void BufferManager::StartTracking(Buffer* /* buffer */) {
 }
 
 void BufferManager::StopTracking(Buffer* buffer) {
-  memory_tracker_->TrackMemFree(buffer->size());
+  memory_type_tracker_->TrackMemFree(buffer->size());
   --buffer_count_;
 }
 
@@ -274,7 +289,7 @@ bool BufferManager::UseNonZeroSizeForClientSideArrayBuffer() {
 void BufferManager::SetInfo(Buffer* buffer, GLenum target, GLsizeiptr size,
                             GLenum usage, const GLvoid* data) {
   DCHECK(buffer);
-  memory_tracker_->TrackMemFree(buffer->size());
+  memory_type_tracker_->TrackMemFree(buffer->size());
   const bool is_client_side_array = IsUsageClientSideArray(usage);
   const bool support_fixed_attribs =
     gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
@@ -284,7 +299,7 @@ void BufferManager::SetInfo(Buffer* buffer, GLenum target, GLsizeiptr size,
                       (allow_fixed_attribs_ && !support_fixed_attribs) ||
                       is_client_side_array;
   buffer->SetInfo(size, usage, shadow, data, is_client_side_array);
-  memory_tracker_->TrackMemAlloc(buffer->size());
+  memory_type_tracker_->TrackMemAlloc(buffer->size());
 }
 
 void BufferManager::ValidateAndDoBufferData(
@@ -314,7 +329,7 @@ void BufferManager::ValidateAndDoBufferData(
     return;
   }
 
-  if (!memory_tracker_->EnsureGPUMemoryAvailable(size)) {
+  if (!memory_type_tracker_->EnsureGPUMemoryAvailable(size)) {
     ERRORSTATE_SET_GL_ERROR(
         error_state, GL_OUT_OF_MEMORY, "glBufferData", "out of memory");
     return;
@@ -517,7 +532,28 @@ Buffer* BufferManager::GetBufferInfoForTarget(
   }
 }
 
-}  // namespace gles2
-}  // namespace gpu
+bool BufferManager::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
+                                 base::trace_event::ProcessMemoryDump* pmd) {
+  const int client_id = memory_tracker_->ClientId();
+  for (const auto& buffer_entry : buffers_) {
+    const auto& client_buffer_id = buffer_entry.first;
+    const auto& buffer = buffer_entry.second;
+
+    std::string dump_name = base::StringPrintf("gl/client_%d/buffers/buffer_%d",
+                                               client_id, client_buffer_id);
+    base::trace_event::MemoryAllocatorDump* dump =
+        pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                    base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                    static_cast<uint64_t>(buffer->size()));
 
+    auto guid = gfx::GetGLBufferGUIDForTracing(
+        memory_tracker_->ClientTracingId(), client_buffer_id);
+    pmd->CreateSharedGlobalAllocatorDump(guid);
+    pmd->AddOwnershipEdge(dump->guid(), guid);
+  }
+  return true;
+}
 
+}  // namespace gles2
+}  // namespace gpu
diff --git a/gpu/command_buffer/service/buffer_manager.h b/gpu/command_buffer/service/buffer_manager.h
index 0048c76..2f64e0d 100644
--- a/gpu/command_buffer/service/buffer_manager.h
+++ b/gpu/command_buffer/service/buffer_manager.h
@@ -202,10 +202,10 @@ class GPU_EXPORT Buffer : public base::RefCounted<Buffer> {
 //
 // NOTE: To support shared resources an instance of this class will need to be
 // shared by multiple GLES2Decoders.
-class GPU_EXPORT BufferManager {
+class GPU_EXPORT BufferManager : public base::trace_event::MemoryDumpProvider {
  public:
   BufferManager(MemoryTracker* memory_tracker, FeatureInfo* feature_info);
-  ~BufferManager();
+  ~BufferManager() override;
 
   // Must call before destruction.
   void Destroy(bool have_context);
@@ -256,7 +256,7 @@ class GPU_EXPORT BufferManager {
   }
 
   size_t mem_represented() const {
-    return memory_tracker_->GetMemRepresented();
+    return memory_type_tracker_->GetMemRepresented();
   }
 
   // Tells for a given usage if this would be a client side array.
@@ -268,6 +268,10 @@ class GPU_EXPORT BufferManager {
 
   Buffer* GetBufferInfoForTarget(ContextState* state, GLenum target) const;
 
+  // base::trace_event::MemoryDumpProvider implementation.
+  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
+                    base::trace_event::ProcessMemoryDump* pmd) override;
+
  private:
   friend class Buffer;
   friend class TestHelper;  // Needs access to DoBufferData.
@@ -301,7 +305,8 @@ class GPU_EXPORT BufferManager {
   void SetInfo(Buffer* buffer, GLenum target, GLsizeiptr size, GLenum usage,
                const GLvoid* data);
 
-  scoped_ptr<MemoryTypeTracker> memory_tracker_;
+  scoped_ptr<MemoryTypeTracker> memory_type_tracker_;
+  MemoryTracker* memory_tracker_;
   scoped_refptr<FeatureInfo> feature_info_;
 
   // Info for each buffer in the system.
diff --git a/gpu/command_buffer/service/renderbuffer_manager.cc b/gpu/command_buffer/service/renderbuffer_manager.cc
index 2b57e57..8ae6bc3 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager.cc
@@ -6,6 +6,8 @@
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ -13,6 +15,7 @@
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_version_info.h"
+#include "ui/gl/trace_util.h"
 
 namespace gpu {
 namespace gles2 {
@@ -41,19 +44,25 @@ struct RenderbufferSignature {
   }
 };
 
-RenderbufferManager::RenderbufferManager(
-    MemoryTracker* memory_tracker,
-    GLint max_renderbuffer_size,
-    GLint max_samples,
-    FeatureInfo* feature_info)
-    : memory_tracker_(
+RenderbufferManager::RenderbufferManager(MemoryTracker* memory_tracker,
+                                         GLint max_renderbuffer_size,
+                                         GLint max_samples,
+                                         FeatureInfo* feature_info)
+    : memory_type_tracker_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
+      memory_tracker_(memory_tracker),
       max_renderbuffer_size_(max_renderbuffer_size),
       max_samples_(max_samples),
       feature_info_(feature_info),
       num_uncleared_renderbuffers_(0),
       renderbuffer_count_(0),
       have_context_(true) {
+  // When created from InProcessCommandBuffer, we won't have a |memory_tracker_|
+  // so don't register a dump provider.
+  if (memory_tracker_) {
+    base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+        this, base::ThreadTaskRunnerHandle::Get());
+  }
 }
 
 RenderbufferManager::~RenderbufferManager() {
@@ -63,6 +72,9 @@ RenderbufferManager::~RenderbufferManager() {
   CHECK_EQ(renderbuffer_count_, 0u);
 
   DCHECK_EQ(0, num_uncleared_renderbuffers_);
+
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
 }
 
 size_t Renderbuffer::EstimatedSize() {
@@ -118,7 +130,7 @@ Renderbuffer::~Renderbuffer() {
 void RenderbufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
   renderbuffers_.clear();
-  DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
+  DCHECK_EQ(0u, memory_type_tracker_->GetMemRepresented());
 }
 
 void RenderbufferManager::StartTracking(Renderbuffer* /* renderbuffer */) {
@@ -130,7 +142,7 @@ void RenderbufferManager::StopTracking(Renderbuffer* renderbuffer) {
   if (!renderbuffer->cleared()) {
     --num_uncleared_renderbuffers_;
   }
-  memory_tracker_->TrackMemFree(renderbuffer->EstimatedSize());
+  memory_type_tracker_->TrackMemFree(renderbuffer->EstimatedSize());
 }
 
 void RenderbufferManager::SetInfo(
@@ -140,9 +152,9 @@ void RenderbufferManager::SetInfo(
   if (!renderbuffer->cleared()) {
     --num_uncleared_renderbuffers_;
   }
-  memory_tracker_->TrackMemFree(renderbuffer->EstimatedSize());
+  memory_type_tracker_->TrackMemFree(renderbuffer->EstimatedSize());
   renderbuffer->SetInfo(samples, internalformat, width, height);
-  memory_tracker_->TrackMemAlloc(renderbuffer->EstimatedSize());
+  memory_type_tracker_->TrackMemAlloc(renderbuffer->EstimatedSize());
   if (!renderbuffer->cleared()) {
     ++num_uncleared_renderbuffers_;
   }
@@ -231,7 +243,30 @@ GLenum RenderbufferManager::InternalRenderbufferFormatToImplFormat(
   return impl_format;
 }
 
-}  // namespace gles2
-}  // namespace gpu
+bool RenderbufferManager::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  int client_id = memory_tracker_->ClientId();
+  for (const auto& renderbuffer_entry : renderbuffers_) {
+    const auto& client_renderbuffer_id = renderbuffer_entry.first;
+    const auto& renderbuffer = renderbuffer_entry.second;
+
+    std::string dump_name =
+        base::StringPrintf("gl/client_%d/renderbuffers/renderbuffer_%d",
+                           client_id, client_renderbuffer_id);
+    base::trace_event::MemoryAllocatorDump* dump =
+        pmd->CreateAllocatorDump(dump_name);
+    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                    base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                    static_cast<uint64_t>(renderbuffer->EstimatedSize()));
 
+    auto guid = gfx::GetGLRenderbufferGUIDForTracing(
+        memory_tracker_->ClientTracingId(), client_renderbuffer_id);
+    pmd->CreateSharedGlobalAllocatorDump(guid);
+    pmd->AddOwnershipEdge(dump->guid(), guid);
+  }
+  return true;
+}
 
+}  // namespace gles2
+}  // namespace gpu
diff --git a/gpu/command_buffer/service/renderbuffer_manager.h b/gpu/command_buffer/service/renderbuffer_manager.h
index be4cc09..72b0aae 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.h
+++ b/gpu/command_buffer/service/renderbuffer_manager.h
@@ -124,13 +124,14 @@ class GPU_EXPORT Renderbuffer
 
 // This class keeps track of the renderbuffers and whether or not they have
 // been cleared.
-class GPU_EXPORT RenderbufferManager {
+class GPU_EXPORT RenderbufferManager
+    : public base::trace_event::MemoryDumpProvider {
  public:
   RenderbufferManager(MemoryTracker* memory_tracker,
                       GLint max_renderbuffer_size,
                       GLint max_samples,
                       FeatureInfo* feature_info);
-  ~RenderbufferManager();
+  ~RenderbufferManager() override;
 
   GLint max_renderbuffer_size() const {
     return max_renderbuffer_size_;
@@ -163,7 +164,7 @@ class GPU_EXPORT RenderbufferManager {
   void RemoveRenderbuffer(GLuint client_id);
 
   size_t mem_represented() const {
-    return memory_tracker_->GetMemRepresented();
+    return memory_type_tracker_->GetMemRepresented();
   }
 
   bool ComputeEstimatedRenderbufferSize(int width,
@@ -173,13 +174,18 @@ class GPU_EXPORT RenderbufferManager {
                                         uint32* size) const;
   GLenum InternalRenderbufferFormatToImplFormat(GLenum impl_format) const;
 
+  // base::trace_event::MemoryDumpProvider implementation.
+  bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
+                    base::trace_event::ProcessMemoryDump* pmd) override;
+
  private:
   friend class Renderbuffer;
 
   void StartTracking(Renderbuffer* renderbuffer);
   void StopTracking(Renderbuffer* renderbuffer);
 
-  scoped_ptr<MemoryTypeTracker> memory_tracker_;
+  scoped_ptr<MemoryTypeTracker> memory_type_tracker_;
+  MemoryTracker* memory_tracker_;
 
   GLint max_renderbuffer_size_;
   GLint max_samples_;
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index 5085efa..24912ee 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -2073,7 +2073,7 @@ void TextureManager::DumpTextureRef(base::trace_event::ProcessMemoryDump* pmd,
     return;
 
   std::string dump_name =
-      base::StringPrintf("gl/textures/client_%d/texture_%d",
+      base::StringPrintf("gl/client_%d/textures/texture_%d",
                          memory_tracker_->ClientId(), ref->client_id());
   base::trace_event::MemoryAllocatorDump* dump =
       pmd->CreateAllocatorDump(dump_name);