Track memory consumption for decoder-internal resources

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 20 matching lines @@
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
+#include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 #include "gpu/command_buffer/service/texture_manager.h"
@@ skipping 290 matching lines @@
 
   GLuint id() const {
     return id_;
   }
 
   gfx::Size size() const {
     return size_;
   }
 
   size_t estimated_size() const {
-    return estimated_size_;
+    return memory_tracker_.GetMemRepresented();
   }
 
  private:
   GLES2DecoderImpl* decoder_;
+  MemoryTypeTracker memory_tracker_;
   GLuint id_;
   gfx::Size size_;
-  size_t estimated_size_;
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 // Encapsulates an OpenGL render buffer of any format.
 class RenderBuffer {
  public:
   explicit RenderBuffer(GLES2DecoderImpl* decoder);
   ~RenderBuffer();
 
   // Create a new render buffer.
   void Create();
 
   // Set the initial size and format of a render buffer or resize it.
   bool AllocateStorage(const gfx::Size& size, GLenum format, GLsizei samples);
 
   // Destroy the render buffer. This must be explicitly called before destroying
   // this object.
   void Destroy();
 
   // Invalidate the render buffer. This can be used when a context is lost and
   // it is not possible to make it current in order to free the resource.
   void Invalidate();
 
   GLuint id() const {
     return id_;
   }
 
   size_t estimated_size() const {
-    return estimated_size_;
+    return memory_tracker_.GetMemRepresented();
   }
 
  private:
   GLES2DecoderImpl* decoder_;
+  MemoryTypeTracker memory_tracker_;
   GLuint id_;
-  size_t estimated_size_;
   DISALLOW_COPY_AND_ASSIGN(RenderBuffer);
 };
 
 // Encapsulates an OpenGL frame buffer.
 class FrameBuffer {
  public:
   explicit FrameBuffer(GLES2DecoderImpl* decoder);
   ~FrameBuffer();
 
   // Create a new frame buffer.
@@ skipping 1279 matching lines @@
 
   ScopedGLErrorSuppressor suppressor(decoder_);
   decoder_->RestoreCurrentFramebufferBindings();
   if (decoder_->enable_scissor_test_) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 Texture::Texture(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
-      id_(0),
-      estimated_size_(0) {
+      memory_tracker_(decoder->GetContextGroup()->memory_tracker(),
+                      NULL, NULL),
+      id_(0) {
 }
 
 Texture::~Texture() {
   // This does not destroy the render texture because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
 }
 
 void Texture::Create() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   Destroy();
   glGenTextures(1, &id_);
   ScopedTexture2DBinder binder(decoder_, id_);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
   // TODO(apatrick): Attempt to diagnose crbug.com/97775. If SwapBuffers is
   // never called on an offscreen context, no data will ever be uploaded to the
   // saved offscreen color texture (it is deferred until to when SwapBuffers
   // is called). My idea is that some nvidia drivers might have a bug where
   // deleting a texture that has never been populated might cause a
   // crash.
   glTexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-  estimated_size_ = 16u * 16u * 4u;
+  memory_tracker_.UpdateMemRepresented(16u * 16u * 4u);
   TRACE_BACKBUFFER_MEMORY_TOTAL(decoder_);
 }
 
 bool Texture::AllocateStorage(const gfx::Size& size, GLenum format) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedTexture2DBinder binder(decoder_, id_);
 
   WrappedTexImage2D(GL_TEXTURE_2D,
                     0,  // mip level
                     format,
                     size.width(),
                     size.height(),
                     0,  // border
                     format,
                     GL_UNSIGNED_BYTE,
                     NULL);
 
   size_ = size;
 
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
     uint32 image_size = 0;
     GLES2Util::ComputeImageDataSizes(
         size.width(), size.height(), format, GL_UNSIGNED_BYTE, 4, &image_size,
         NULL, NULL);
-    estimated_size_ = image_size;
+    memory_tracker_.UpdateMemRepresented(image_size);
     TRACE_BACKBUFFER_MEMORY_TOTAL(decoder_);
   }
   return success;
 }
 
 void Texture::Copy(const gfx::Size& size, GLenum format) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedTexture2DBinder binder(decoder_, id_);
   glCopyTexImage2D(GL_TEXTURE_2D,
                    0,  // level
                    format,
                    0, 0,
                    size.width(),
                    size.height(),
                    0);  // border
 }
 
 void Texture::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteTextures(1, &id_);
     id_ = 0;
-    estimated_size_ = 0;
+    memory_tracker_.UpdateMemRepresented(0);
     TRACE_BACKBUFFER_MEMORY_TOTAL(decoder_);
   }
 }
 
 void Texture::Invalidate() {
   id_ = 0;
 }
 
 RenderBuffer::RenderBuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
-      id_(0),
-      estimated_size_(0) {
+      memory_tracker_(decoder->GetContextGroup()->memory_tracker(),
+                      NULL, NULL),
+      id_(0) {
 }
 
 RenderBuffer::~RenderBuffer() {
   // This does not destroy the render buffer because that would require that
   // the associated GL context was current. Just check that it was explicitly
   // destroyed.
   DCHECK_EQ(id_, 0u);
 }
 
 void RenderBuffer::Create() {
@@ skipping 21 matching lines @@
     } else {
       glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
                                           samples,
                                           format,
                                           size.width(),
                                           size.height());
     }
   }
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
-    estimated_size_ = size.width() * size.height() * samples *
-                      GLES2Util::RenderbufferBytesPerPixel(format);
+    memory_tracker_.UpdateMemRepresented(
+        size.width() * size.height() * samples *
+        GLES2Util::RenderbufferBytesPerPixel(format));
     TRACE_BACKBUFFER_MEMORY_TOTAL(decoder_);
   }
   return success;
 }
 
 void RenderBuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteRenderbuffersEXT(1, &id_);
     id_ = 0;
-    estimated_size_ = 0;
+    memory_tracker_.UpdateMemRepresented(0);
     TRACE_BACKBUFFER_MEMORY_TOTAL(decoder_);
   }
 }
 
 void RenderBuffer::Invalidate() {
   id_ = 0;
 }
 
 FrameBuffer::FrameBuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
@@ skipping 7338 matching lines @@
   BindAndApplyTextureParameters(info);
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu