GLImage::OnMemoryDump Stubs + Some Impls

gpu/command_buffer/service/texture_manager.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/service/texture_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 1277 matching lines @@
   if (image)
     image->WillModifyTexImage();
 }
 
 void Texture::OnDidModifyPixels() {
   gfx::GLImage* image = GetLevelImage(target(), 0);
   if (image)
     image->DidModifyTexImage();
 }
 
+void Texture::DumpLevelMemory(base::trace_event::ProcessMemoryDump* pmd,
+                              uint64_t client_tracing_id,
+                              const std::string& dump_name) const {
+  for (uint32_t face_index = 0; face_index < face_infos_.size(); ++face_index) {
+    const auto& level_infos = face_infos_[face_index].level_infos;
+    for (uint32_t level_index = 0; level_index < level_infos.size();
+         ++level_index) {
+      // Skip levels with no size. Textures will have empty levels for all
+      // potential mip levels which are not in use.
+      if (!level_infos[level_index].estimated_size)
+        continue;
+
+      if (level_infos[level_index].image) {
+        // If a level is backed by a GLImage, ask the GLImage to dump itself.
+        level_infos[level_index].image->OnMemoryDump(
+            pmd, client_tracing_id,
+            base::StringPrintf("%s/face_%d/level_%d", dump_name.c_str(),
+                               face_index, level_index));
+      } else {
+        // If a level is not backed by a GLImage, create a simple dump.
+        base::trace_event::MemoryAllocatorDump* dump = pmd->CreateAllocatorDump(
+            base::StringPrintf("%s/face_%d/level_%d", dump_name.c_str(),
+                               face_index, level_index));
+        dump->AddScalar(
+            base::trace_event::MemoryAllocatorDump::kNameSize,
+            base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+            static_cast<uint64_t>(level_infos[level_index].estimated_size));
+      }
+    }
+  }
+}
+
 TextureRef::TextureRef(TextureManager* manager,
                        GLuint client_id,
                        Texture* texture)
     : manager_(manager),
       texture_(texture),
       client_id_(client_id),
       num_observers_(0) {
   DCHECK(manager_);
   DCHECK(texture_);
   texture_->AddTextureRef(this);
@@ skipping 747 matching lines @@
     if (default_textures_[i]) {
       DumpTextureRef(pmd, default_textures_[i].get());
     }
   }
 
   return true;
 }
 
 void TextureManager::DumpTextureRef(base::trace_event::ProcessMemoryDump* pmd,
                                     TextureRef* ref) {
-  // TODO(ericrk): Trace image-backed textures. crbug.com/514914
-  if (ref->texture()->HasImages())
-    return;
-
   uint32_t size = ref->texture()->estimated_size();
 
   // Ignore unallocated texture IDs.
   if (size == 0)
     return;
 
   std::string dump_name =
       base::StringPrintf("gl/textures/client_%d/texture_%d",
                          memory_tracker_->ClientId(), ref->client_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>(size));
 
   // Add the |client_guid| which expresses shared ownership with the client
   // process.
   auto client_guid = gfx::GetGLTextureGUIDForTracing(
       memory_tracker_->ClientTracingId(), ref->client_id());
   pmd->CreateSharedGlobalAllocatorDump(client_guid);
   pmd->AddOwnershipEdge(dump->guid(), client_guid);
 
   // Add a |service_guid| which expresses shared ownership between the various
   // |client_guid|s.
   // TODO(ericrk): May need to ensure uniqueness using GLShareGroup and
   // potentially cross-share-group sharing via EGLImages. crbug.com/512534
   auto service_guid =
       gfx::GetGLTextureGUIDForTracing(0, ref->texture()->service_id());
   pmd->CreateSharedGlobalAllocatorDump(service_guid);
 
   int importance = 0;  // Default importance.
   // The link to the memory tracking |client_id| is given a higher importance
   // than other refs.
   if (ref == ref->texture()->memory_tracking_ref_)
     importance = 2;
 
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
+
+  // Dump all sub-levels held by the texture. They will appear below the main
+  // gl/textures/client_X/texture_Y dump.
+  ref->texture()->DumpLevelMemory(pmd, memory_tracker_->ClientTracingId(),
+                                  dump_name);
 }
 
 }  // namespace gles2
 }  // namespace gpu