Add tracing for GL texture objects

cc/resources/resource_provider.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.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 "cc/base/math_util.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
 #include "cc/resources/transferable_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gl/trace_util.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 class IdAllocator {
  public:
   virtual ~IdAllocator() {}
 
   virtual GLuint NextId() = 0;
@@ skipping 354 matching lines @@
   scoped_ptr<ResourceProvider> resource_provider(new ResourceProvider(
       output_surface, shared_bitmap_manager, gpu_memory_buffer_manager,
       blocking_main_thread_task_runner, highp_threshold_min,
       use_rgba_4444_texture_format, id_allocation_chunk_size,
       use_persistent_map_for_gpu_memory_buffers));
   resource_provider->Initialize();
   return resource_provider;
 }
 
 ResourceProvider::~ResourceProvider() {
+  base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
+      this);
+
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), FOR_SHUTDOWN);
 
   GLES2Interface* gl = ContextGL();
   if (default_resource_type_ != RESOURCE_TYPE_GL_TEXTURE) {
     // We are not in GL mode, but double check before returning.
     DCHECK(!gl);
     return;
@@ skipping 693 matching lines @@
       use_sync_query_(false),
       use_persistent_map_for_gpu_memory_buffers_(
           use_persistent_map_for_gpu_memory_buffers) {
   DCHECK(output_surface_->HasClient());
   DCHECK(id_allocation_chunk_size_);
 }
 
 void ResourceProvider::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
+      this, base::ThreadTaskRunnerHandle::Get());
+
   GLES2Interface* gl = ContextGL();
   if (!gl) {
     default_resource_type_ = RESOURCE_TYPE_BITMAP;
     // Pick an arbitrary limit here similar to what hardware might.
     max_texture_size_ = 16 * 1024;
     best_texture_format_ = RGBA_8888;
     return;
   }
 
   DCHECK(!texture_id_allocator_);
@@ skipping 821 matching lines @@
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
+bool ResourceProvider::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  const uint64 tracing_process_id =
+      base::trace_event::MemoryDumpManager::GetInstance()->tracing_process_id();
+
+  for (const auto& resource_entry : resources_) {
+    const auto& resource = resource_entry.second;
+
+    // Only log INTERNAL resources - other resources are owned by (and will be
+    // logged by) another ResourceProvider.
+    if (resource.origin != Resource::INTERNAL)
+      continue;
+
+    std::string dump_name = base::StringPrintf("cc/resource_memory/resource_%d",
+                                               resource_entry.first);
+    base::trace_event::MemoryAllocatorDump* dump =
+        pmd->CreateAllocatorDump(dump_name);
+
+    // Calculate the size of the current resource.
+    // TODO(ericrk): Replace this with helper fn once crrev.com/1202843008
+    // goes in.
+    unsigned bytes_per_pixel = BitsPerPixel(resource.format) / 8;
+    uint32_t total_bytes =
+        resource.size.height() *
+        MathUtil::RoundUp(bytes_per_pixel * resource.size.width(), 4u);
+
+    dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
+                    base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+                    static_cast<uint64_t>(total_bytes));
+
+    // Resources which are shared across processes require a shared GUID to
+    // prevent double counting the memory. We currently support shared GUIDs for
+    // GpuMemoryBuffer, SharedBitmap, and GL backed resources.
+    base::trace_event::MemoryAllocatorDumpGuid guid;
+    if (resource.gpu_memory_buffer) {
+      guid = gfx::GetGpuMemoryBufferGUIDForTracing(
+          tracing_process_id, resource.gpu_memory_buffer->GetHandle().id);
+    } else if (resource.shared_bitmap) {
+      guid = GetSharedBitmapGUIDForTracing(resource.shared_bitmap->id());
+    } else if (resource.gl_id && resource.allocated) {
+      guid =
+          gfx::GetGLTextureGUIDForTracing(tracing_process_id, resource.gl_id);
+    }
+
+    if (!guid.empty()) {
+      const int kImportance = 2;
+      pmd->CreateSharedGlobalAllocatorDump(guid);
+      pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
+    }
+  }
+
+  return true;
+}
+
 }  // namespace cc