Log both GL and cpu-side memory in GLImage*Memory

ui/gl/gl_image_memory.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 "ui/gl/gl_image_memory.h"
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 125 matching lines @@
 }
 
 GLsizei SizeInBytes(const Size& size, BufferFormat format) {
   size_t stride_in_bytes = 0;
   bool valid_stride = GLImageMemory::StrideInBytes(
       size.width(), format, &stride_in_bytes);
   DCHECK(valid_stride);
   return static_cast<GLsizei>(stride_in_bytes * size.height());
 }
 
+bool GetTextureBindingForTarget(GLenum target, GLenum* binding) {
+  switch (target) {
+    case GL_TEXTURE_2D:
+      *binding = GL_TEXTURE_BINDING_2D;
+      return true;
+    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+    case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+    case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+    case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+    case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+      *binding = GL_TEXTURE_BINDING_CUBE_MAP;
+      return true;
+    case GL_TEXTURE_RECTANGLE_ARB:
+      *binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
+      return true;
+    case GL_TEXTURE_EXTERNAL_OES:
+      *binding = GL_TEXTURE_BINDING_EXTERNAL_OES;
+      return true;
+  }
+
+  return false;
+}
+
 }  // namespace
 
 GLImageMemory::GLImageMemory(const Size& size, unsigned internalformat)
     : size_(size),
       internalformat_(internalformat),
       memory_(NULL),
       format_(BufferFormat::RGBA_8888),
       in_use_(false),
       target_(0),
-      need_do_bind_tex_image_(false)
+      need_do_bind_tex_image_(false),
+      texture_id_(0u),
+      need_to_free_texture_id_(false)
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
       ,
-      egl_texture_id_(0u),
       egl_image_(EGL_NO_IMAGE_KHR)
 #endif
 {
 }
 
 GLImageMemory::~GLImageMemory() {
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
   DCHECK_EQ(EGL_NO_IMAGE_KHR, egl_image_);
-  DCHECK_EQ(0u, egl_texture_id_);
+  DCHECK_IMPLIES(need_to_free_texture_id_, texture_id_ == 0u);
 #endif
 }
 
 // static
 bool GLImageMemory::StrideInBytes(size_t width,
                                   BufferFormat format,
                                   size_t* stride_in_bytes) {
   base::CheckedNumeric<size_t> checked_stride = width;
   switch (format) {
     case BufferFormat::ATCIA:
@@ skipping 58 matching lines @@
 }
 
 void GLImageMemory::Destroy(bool have_context) {
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
   if (egl_image_ != EGL_NO_IMAGE_KHR) {
     eglDestroyImageKHR(GLSurfaceEGL::GetHardwareDisplay(), egl_image_);
     egl_image_ = EGL_NO_IMAGE_KHR;
   }
 
-  if (egl_texture_id_) {
+  if (texture_id_ && need_to_free_texture_id_) {
     if (have_context)
-      glDeleteTextures(1, &egl_texture_id_);
-    egl_texture_id_ = 0u;
+      glDeleteTextures(1, &texture_id_);
+    texture_id_ = 0u;
   }
 #endif
   memory_ = NULL;
 }
 
 Size GLImageMemory::GetSize() {
   return size_;
 }
 
 unsigned GLImageMemory::GetInternalFormat() {
@@ skipping 83 matching lines @@
   TRACE_EVENT0("gpu", "GLImageMemory::DoBindTexImage");
 
   DCHECK(need_do_bind_tex_image_);
   need_do_bind_tex_image_ = false;
 
   DCHECK(memory_);
 #if defined(OS_WIN) || defined(USE_X11) || defined(OS_ANDROID) || \
     defined(USE_OZONE)
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     if (egl_image_ == EGL_NO_IMAGE_KHR) {
-      DCHECK_EQ(0u, egl_texture_id_);
-      glGenTextures(1, &egl_texture_id_);
+      DCHECK_EQ(0u, texture_id_);
+      glGenTextures(1, &texture_id_);
+      need_to_free_texture_id_ = true;
 
       {
-        ScopedTextureBinder texture_binder(GL_TEXTURE_2D, egl_texture_id_);
+        ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id_);
 
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         if (IsCompressedFormat(format_)) {
           glCompressedTexImage2D(GL_TEXTURE_2D,
                                  0,  // mip level
                                  TextureFormat(format_), size_.width(),
                                  size_.height(),
                                  0,  // border
                                  SizeInBytes(size_, format_), memory_);
         } else {
           glTexImage2D(GL_TEXTURE_2D,
                        0,  // mip level
                        TextureFormat(format_),
                        size_.width(),
                        size_.height(),
                        0,  // border
                        DataFormat(format_),
                        DataType(format_),
                        memory_);
         }
       }
 
       EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
       // Need to pass current EGL rendering context to eglCreateImageKHR for
       // target type EGL_GL_TEXTURE_2D_KHR.
-      egl_image_ =
-          eglCreateImageKHR(GLSurfaceEGL::GetHardwareDisplay(),
-                            eglGetCurrentContext(),
-                            EGL_GL_TEXTURE_2D_KHR,
-                            reinterpret_cast<EGLClientBuffer>(egl_texture_id_),
-                            attrs);
+      egl_image_ = eglCreateImageKHR(
+          GLSurfaceEGL::GetHardwareDisplay(), eglGetCurrentContext(),
+          EGL_GL_TEXTURE_2D_KHR, reinterpret_cast<EGLClientBuffer>(texture_id_),
+          attrs);
       DCHECK_NE(EGL_NO_IMAGE_KHR, egl_image_)
           << "Error creating EGLImage: " << eglGetError();
     } else {
-      ScopedTextureBinder texture_binder(GL_TEXTURE_2D, egl_texture_id_);
+      ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id_);
 
       if (IsCompressedFormat(format_)) {
         glCompressedTexSubImage2D(GL_TEXTURE_2D,
                                   0,  // mip level
                                   0,  // x-offset
                                   0,  // y-offset
                                   size_.width(), size_.height(),
                                   DataFormat(format_),
                                   SizeInBytes(size_, format_), memory_);
       } else {
         glTexSubImage2D(GL_TEXTURE_2D,
                         0,  // mip level
                         0,  // x-offset
                         0,  // y-offset
                         size_.width(),
                         size_.height(),
                         DataFormat(format_),
                         DataType(format_),
                         memory_);
       }
     }
 
     glEGLImageTargetTexture2DOES(target, egl_image_);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
     return;
   }
 #endif
 
+  // Make sure the same image is only ever bound to one texture.

[reveman, 2015/08/31 17:38:48]

I don't think any of this is needed as we will always release the image before
re-binding it. All we need to check afaict is that the image is not already
bound when trying to bind it.

[ericrk, 2015/08/31 18:31:14]

sgtm - added a comment and used the original logic you suggested.

+  GLenum binding;
+  if (!GetTextureBindingForTarget(target, &binding)) {
+    LOG(ERROR) << "Trying to bind image to an invalid target";
+    return;
+  }
+
+  GLuint texture_id;
+  glGetIntegerv(binding, reinterpret_cast<GLint*>(&texture_id));
+  if (!texture_id) {
+    LOG(ERROR) << "Trying to bind image without no texture bound";
+    return;
+  }
+
+  if (texture_id_ && texture_id_ != texture_id) {
+    LOG(ERROR) << "Image can only be bound to one texture ID";
+    return;
+  }
+
+  texture_id_ = texture_id;
+
   DCHECK_NE(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES), target);
   if (IsCompressedFormat(format_)) {
     glCompressedTexImage2D(target,
                            0,  // mip level
                            TextureFormat(format_), size_.width(),
                            size_.height(),
                            0,  // border
                            SizeInBytes(size_, format_), memory_);
   } else {
     glTexImage2D(target,
                  0,  // mip level
                  TextureFormat(format_),
                  size_.width(),
                  size_.height(),
                  0,  // border
                  DataFormat(format_),
                  DataType(format_),
                  memory_);
   }
 }
 
 void GLImageMemory::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                  uint64_t process_tracing_id,
                                  const std::string& dump_name) {
-  // Log size 0 if |ref_counted_memory_| has been released.
-  size_t size_in_bytes = memory_ ? SizeInBytes(size_, format_) : 0;
+  size_t size_in_bytes = texture_id_ ? SizeInBytes(size_, format_) : 0;
 
   base::trace_event::MemoryAllocatorDump* dump =
-      pmd->CreateAllocatorDump(dump_name);
+      pmd->CreateAllocatorDump(dump_name + "/texture_memory");
   dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                   base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                   static_cast<uint64_t>(size_in_bytes));
+
+  // No need for a global shared edge here. This object in the GPU process is
+  // the sole owner of this texture id.
 }
 
 }  // namespace gfx