Track managed memory usage in the command buffer.

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 360 matching lines @@
     return size_;
   }
 
   size_t estimated_size() const {
     return memory_tracker_.GetMemRepresented();
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   MemoryTypeTracker memory_tracker_;
+  size_t bytes_allocated_;
   GLuint id_;
   gfx::Size size_;
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 // Encapsulates an OpenGL render buffer of any format.
 class RenderBuffer {
  public:
   explicit RenderBuffer(GLES2DecoderImpl* decoder);
   ~RenderBuffer();
@@ skipping 16 matching lines @@
     return id_;
   }
 
   size_t estimated_size() const {
     return memory_tracker_.GetMemRepresented();
   }
 
  private:
   GLES2DecoderImpl* decoder_;
   MemoryTypeTracker memory_tracker_;
+  size_t bytes_allocated_;
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(RenderBuffer);
 };
 
 // Encapsulates an OpenGL frame buffer.
 class FrameBuffer {
  public:
   explicit FrameBuffer(GLES2DecoderImpl* decoder);
   ~FrameBuffer();
 
@@ skipping 1365 matching lines @@
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   decoder_->texture_upload_count_++;
   decoder_->total_texture_upload_time_ +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
 Texture::Texture(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
-      memory_tracker_(decoder->GetContextGroup()->memory_tracker()),
+      memory_tracker_(decoder->GetContextGroup()->memory_tracker(),
+                      MemoryTracker::kUnmanaged),
+      bytes_allocated_(0),
       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);
-  memory_tracker_.UpdateMemRepresented(16u * 16u * 4u);
+
+  bytes_allocated_ = 16u * 16u * 4u;
+  memory_tracker_.TrackMemAlloc(bytes_allocated_);
 }
 
 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);
-    memory_tracker_.UpdateMemRepresented(image_size);
+    memory_tracker_.TrackMemFree(bytes_allocated_);
+    bytes_allocated_ = image_size;
+    memory_tracker_.TrackMemAlloc(bytes_allocated_);
   }
   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;
-    memory_tracker_.UpdateMemRepresented(0);
   }
+  memory_tracker_.TrackMemFree(bytes_allocated_);
+  bytes_allocated_ = 0;
 }
 
 void Texture::Invalidate() {
   id_ = 0;
 }
 
 RenderBuffer::RenderBuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
-      memory_tracker_(decoder->GetContextGroup()->memory_tracker()),
+      memory_tracker_(decoder->GetContextGroup()->memory_tracker(),
+                      MemoryTracker::kUnmanaged),
+      bytes_allocated_(0),
       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);
 }
 
@@ skipping 22 matching lines @@
     } else {
       glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
                                           samples,
                                           format,
                                           size.width(),
                                           size.height());
     }
   }
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
-    memory_tracker_.UpdateMemRepresented(
+    memory_tracker_.TrackMemFree(bytes_allocated_);
+    bytes_allocated_ =
         size.width() * size.height() * samples *
-        GLES2Util::RenderbufferBytesPerPixel(format));
+        GLES2Util::RenderbufferBytesPerPixel(format);
+    memory_tracker_.TrackMemAlloc(bytes_allocated_);
   }
   return success;
 }
 
 void RenderBuffer::Destroy() {
   if (id_ != 0) {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteRenderbuffersEXT(1, &id_);
     id_ = 0;
-    memory_tracker_.UpdateMemRepresented(0);
   }
+  memory_tracker_.TrackMemFree(bytes_allocated_);
+  bytes_allocated_ = 0;
 }
 
 void RenderBuffer::Invalidate() {
   id_ = 0;
 }
 
 FrameBuffer::FrameBuffer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       id_(0) {
 }
@@ skipping 7765 matching lines @@
       target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 // 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