Track managed memory usage in the command buffer.

This adds infrastructure necessary to support tracking which allocations
are through the compositor (or, more generally, any managed allocator that
the GPU memory manager affect) and allocations that are not (e.g, WebGL).

This is part of a scheme which will add a GL extension where the compositor
can mark a texture as being managed by a call to glTexParameteri. 

This information had previously been tracked by an IPC being sent by the
compositor to the GPU process informing it of the managed memory usage (in
addition to the usage required for all visible content, etc). This had
the two problems. First, the information was not accurate -- the data sent
about managed allocations to the GPU memory manager would always lag the
actual allocations. Second, these IPCs were expensive and needed to be
throttled. The more we throttle the IPCs, the less accurate the information
would become, making the GPU memory manager's behavior less precise and
predictable.

BUG=164947


Review URL: https://chromiumcodereview.appspot.com/11516014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@172754 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 186 insertions, 110 deletions

diff --git a/content/common/gpu/gpu_command_buffer_stub.cc b/content/common/gpu/gpu_command_buffer_stub.cc
index 3f0ae69..2612db2 100644
--- a/content/common/gpu/gpu_command_buffer_stub.cc
+++ b/content/common/gpu/gpu_command_buffer_stub.cc
@@ -53,9 +53,11 @@ class GpuCommandBufferMemoryTracker : public gpu::gles2::MemoryTracker {
         channel->gpu_channel_manager()->gpu_memory_manager());
   }
 
-  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) {
+  void TrackMemoryAllocatedChange(size_t old_size,
+                                  size_t new_size,
+                                  gpu::gles2::MemoryTracker::Pool pool) {
     gpu_memory_manager_tracking_group_->TrackMemoryAllocatedChange(
-        old_size, new_size);
+        old_size, new_size, pool);
   }
 
  private:
diff --git a/content/common/gpu/gpu_memory_manager.cc b/content/common/gpu/gpu_memory_manager.cc
index 386ad90..f3834c8 100644
--- a/content/common/gpu/gpu_memory_manager.cc
+++ b/content/common/gpu/gpu_memory_manager.cc
@@ -44,9 +44,10 @@ GpuMemoryManager::GpuMemoryManager(
       bytes_available_gpu_memory_(0),
       bytes_available_gpu_memory_overridden_(false),
       bytes_backgrounded_available_gpu_memory_(0),
-      bytes_allocated_current_(0),
+      bytes_allocated_managed_current_(0),
       bytes_allocated_managed_visible_(0),
       bytes_allocated_managed_backgrounded_(0),
+      bytes_allocated_unmanaged_current_(0),
       bytes_allocated_historical_max_(0),
       window_count_has_been_received_(false),
       window_count_(0),
@@ -67,7 +68,8 @@ GpuMemoryManager::GpuMemoryManager(
 GpuMemoryManager::~GpuMemoryManager() {
   DCHECK(tracking_groups_.empty());
   DCHECK(clients_.empty());
-  DCHECK(!bytes_allocated_current_);
+  DCHECK(!bytes_allocated_managed_current_);
+  DCHECK(!bytes_allocated_unmanaged_current_);
   DCHECK(!bytes_allocated_managed_visible_);
   DCHECK(!bytes_allocated_managed_backgrounded_);
 }
@@ -258,16 +260,30 @@ void GpuMemoryManager::ScheduleManage(bool immediate) {
   }
 }
 
-void GpuMemoryManager::TrackMemoryAllocatedChange(size_t old_size,
-                                                  size_t new_size) {
-  TrackValueChanged(old_size, new_size, &bytes_allocated_current_);
+void GpuMemoryManager::TrackMemoryAllocatedChange(
+    size_t old_size,
+    size_t new_size,
+    gpu::gles2::MemoryTracker::Pool tracking_pool) {
+  switch (tracking_pool) {
+    case gpu::gles2::MemoryTracker::kManaged:
+      TrackValueChanged(old_size, new_size, &bytes_allocated_managed_current_);
+      break;
+    case gpu::gles2::MemoryTracker::kUnmanaged:
+      TrackValueChanged(old_size,
+                        new_size,
+                        &bytes_allocated_unmanaged_current_);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
   if (new_size != old_size) {
     TRACE_COUNTER1("gpu",
                    "GpuMemoryUsage",
-                   bytes_allocated_current_);
+                   GetCurrentUsage());
   }
-  if (bytes_allocated_current_ > bytes_allocated_historical_max_) {
-      bytes_allocated_historical_max_ = bytes_allocated_current_;
+  if (GetCurrentUsage() > bytes_allocated_historical_max_) {
+      bytes_allocated_historical_max_ = GetCurrentUsage();
       // If we're blowing into new memory usage territory, spam the browser
       // process with the most up-to-date information about our memory usage.
       SendUmaStatsToBrowser();
@@ -399,7 +415,7 @@ void GpuMemoryManager::GetVideoMemoryUsageStats(
 
   // Assign the total across all processes in the GPU process
   video_memory_usage_stats.process_map[
-      base::GetCurrentProcId()].video_memory = bytes_allocated_current_;
+      base::GetCurrentProcId()].video_memory = GetCurrentUsage();
   video_memory_usage_stats.process_map[
       base::GetCurrentProcId()].has_duplicates = true;
 }
@@ -614,7 +630,7 @@ void GpuMemoryManager::SendUmaStatsToBrowser() {
   if (!channel_manager_)
     return;
   GPUMemoryUmaStats params;
-  params.bytes_allocated_current = bytes_allocated_current_;
+  params.bytes_allocated_current = GetCurrentUsage();
   params.bytes_allocated_max = bytes_allocated_historical_max_;
   params.bytes_limit = bytes_available_gpu_memory_;
   params.window_count = window_count_;
diff --git a/content/common/gpu/gpu_memory_manager.h b/content/common/gpu/gpu_memory_manager.h
index bbd4cd2..4e585a9 100644
--- a/content/common/gpu/gpu_memory_manager.h
+++ b/content/common/gpu/gpu_memory_manager.h
@@ -77,7 +77,10 @@ class CONTENT_EXPORT GpuMemoryManager :
   void RemoveTrackingGroup(GpuMemoryTrackingGroup* tracking_group);
 
   // Track a change in memory allocated by any context
-  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size);
+  void TrackMemoryAllocatedChange(
+      size_t old_size,
+      size_t new_size,
+      gpu::gles2::MemoryTracker::Pool tracking_pool);
 
  private:
   friend class GpuMemoryManagerTest;
@@ -175,6 +178,12 @@ class CONTENT_EXPORT GpuMemoryManager :
   // Send memory usage stats to the browser process.
   void SendUmaStatsToBrowser();
 
+  // Get the current number of bytes allocated.
+  size_t GetCurrentUsage() const {
+    return bytes_allocated_managed_current_ +
+        bytes_allocated_unmanaged_current_;
+  }
+
   // Interfaces for testing
   void TestingSetClientVisible(GpuMemoryManagerClient* client, bool visible);
   void TestingSetClientLastUsedTime(GpuMemoryManagerClient* client,
@@ -216,9 +225,10 @@ class CONTENT_EXPORT GpuMemoryManager :
   size_t bytes_backgrounded_available_gpu_memory_;
 
   // The current total memory usage, and historical maximum memory usage
-  size_t bytes_allocated_current_;
+  size_t bytes_allocated_managed_current_;
   size_t bytes_allocated_managed_visible_;
   size_t bytes_allocated_managed_backgrounded_;
+  size_t bytes_allocated_unmanaged_current_;
   size_t bytes_allocated_historical_max_;
 
   // The number of browser windows that exist. If we ever receive a
diff --git a/content/common/gpu/gpu_memory_manager_unittest.cc b/content/common/gpu/gpu_memory_manager_unittest.cc
index 9d33528..d93a19b 100644
--- a/content/common/gpu/gpu_memory_manager_unittest.cc
+++ b/content/common/gpu/gpu_memory_manager_unittest.cc
@@ -11,7 +11,10 @@
 
 class FakeMemoryTracker : public gpu::gles2::MemoryTracker {
  public:
-  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) {
+  void TrackMemoryAllocatedChange(
+      size_t old_size,
+      size_t new_size,
+      gpu::gles2::MemoryTracker::Pool pool) {
   }
  private:
   ~FakeMemoryTracker() {
diff --git a/content/common/gpu/gpu_memory_tracking.h b/content/common/gpu/gpu_memory_tracking.h
index 79bea78..d5f4159 100644
--- a/content/common/gpu/gpu_memory_tracking.h
+++ b/content/common/gpu/gpu_memory_tracking.h
@@ -29,7 +29,10 @@ class GpuMemoryTrackingGroup {
   ~GpuMemoryTrackingGroup() {
     memory_manager_->RemoveTrackingGroup(this);
   }
-  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) {
+  void TrackMemoryAllocatedChange(
+      size_t old_size,
+      size_t new_size,
+      gpu::gles2::MemoryTracker::Pool tracking_pool) {
     if (old_size < new_size) {
       size_t delta = new_size - old_size;
       size_ += delta;
@@ -39,7 +42,8 @@ class GpuMemoryTrackingGroup {
       DCHECK(size_ >= delta);
       size_ -= delta;
     }
-    memory_manager_->TrackMemoryAllocatedChange(old_size, new_size);
+    memory_manager_->TrackMemoryAllocatedChange(
+        old_size, new_size, tracking_pool);
   }
   base::ProcessId GetPid() const {
     return pid_;
diff --git a/gpu/command_buffer/service/buffer_manager.cc b/gpu/command_buffer/service/buffer_manager.cc
index 3dc5191..001e602 100644
--- a/gpu/command_buffer/service/buffer_manager.cc
+++ b/gpu/command_buffer/service/buffer_manager.cc
@@ -14,12 +14,12 @@ namespace gpu {
 namespace gles2 {
 
 BufferManager::BufferManager(MemoryTracker* memory_tracker)
-    : buffer_memory_tracker_(new MemoryTypeTracker(memory_tracker)),
+    : memory_tracker_(
+          new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
       allow_buffers_on_multiple_targets_(false),
-      mem_represented_(0),
       buffer_info_count_(0),
       have_context_(true) {
-  UpdateMemRepresented();
+  memory_tracker_->UpdateMemRepresented();
 }
 
 BufferManager::~BufferManager() {
@@ -30,12 +30,8 @@ BufferManager::~BufferManager() {
 void BufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
   buffer_infos_.clear();
-  DCHECK_EQ(0u, mem_represented_);
-  UpdateMemRepresented();
-}
-
-void BufferManager::UpdateMemRepresented() {
-  buffer_memory_tracker_->UpdateMemRepresented(mem_represented_);
+  DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
+  memory_tracker_->UpdateMemRepresented();
 }
 
 void BufferManager::CreateBufferInfo(GLuint client_id, GLuint service_id) {
@@ -65,9 +61,9 @@ void BufferManager::StartTracking(BufferManager::BufferInfo* /* buffer */) {
 }
 
 void BufferManager::StopTracking(BufferManager::BufferInfo* buffer) {
-  mem_represented_ -= buffer->size();
+  memory_tracker_->TrackMemFree(buffer->size());
   --buffer_info_count_;
-  UpdateMemRepresented();
+  memory_tracker_->UpdateMemRepresented();
 }
 
 BufferManager::BufferInfo::BufferInfo(BufferManager* manager, GLuint service_id)
@@ -227,12 +223,13 @@ bool BufferManager::GetClientId(GLuint service_id, GLuint* client_id) const {
 void BufferManager::SetInfo(
     BufferManager::BufferInfo* info, GLsizeiptr size, GLenum usage) {
   DCHECK(info);
-  mem_represented_ -= info->size();
+  memory_tracker_->TrackMemFree(info->size());
   info->SetInfo(size,
                 usage,
                 info->target() == GL_ELEMENT_ARRAY_BUFFER ||
                 allow_buffers_on_multiple_targets_);
-  mem_represented_ += info->size();
+  memory_tracker_->TrackMemAlloc(info->size());
+  memory_tracker_->UpdateMemRepresented();
 }
 
 bool BufferManager::SetTarget(BufferManager::BufferInfo* info, GLenum target) {
diff --git a/gpu/command_buffer/service/buffer_manager.h b/gpu/command_buffer/service/buffer_manager.h
index f807349..ae8fcbb 100644
--- a/gpu/command_buffer/service/buffer_manager.h
+++ b/gpu/command_buffer/service/buffer_manager.h
@@ -12,14 +12,12 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 namespace gles2 {
 
-class MemoryTracker;
-class MemoryTypeTracker;
-
 // This class keeps track of the buffers and their sizes so we can do
 // bounds checking.
 //
@@ -190,16 +188,14 @@ class GPU_EXPORT BufferManager {
   }
 
   size_t mem_represented() const {
-    return mem_represented_;
+    return memory_tracker_->GetMemRepresented();
   }
 
  private:
-  void UpdateMemRepresented();
-
   void StartTracking(BufferInfo* info);
   void StopTracking(BufferInfo* info);
 
-  scoped_ptr<MemoryTypeTracker> buffer_memory_tracker_;
+  scoped_ptr<MemoryTypeTracker> memory_tracker_;
 
   // Info for each buffer in the system.
   typedef base::hash_map<GLuint, BufferInfo::Ref> BufferInfoMap;
@@ -208,8 +204,6 @@ class GPU_EXPORT BufferManager {
   // Whether or not buffers can be bound to multiple targets.
   bool allow_buffers_on_multiple_targets_;
 
-  size_t mem_represented_;
-
   // Counts the number of BufferInfo allocated with 'this' as its manager.
   // Allows to check no BufferInfo will outlive this.
   unsigned int buffer_info_count_;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 54c95eb..3fc39c6 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -378,6 +378,7 @@ class Texture {
  private:
   GLES2DecoderImpl* decoder_;
   MemoryTypeTracker memory_tracker_;
+  size_t bytes_allocated_;
   GLuint id_;
   gfx::Size size_;
   DISALLOW_COPY_AND_ASSIGN(Texture);
@@ -414,6 +415,7 @@ class RenderBuffer {
  private:
   GLES2DecoderImpl* decoder_;
   MemoryTypeTracker memory_tracker_;
+  size_t bytes_allocated_;
   GLuint id_;
   DISALLOW_COPY_AND_ASSIGN(RenderBuffer);
 };
@@ -1799,7 +1801,9 @@ ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
 
 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) {
 }
 
@@ -1828,7 +1832,9 @@ void Texture::Create() {
   // 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) {
@@ -1854,7 +1860,9 @@ bool Texture::AllocateStorage(const gfx::Size& size, GLenum format) {
     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;
 }
@@ -1877,8 +1885,9 @@ void Texture::Destroy() {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteTextures(1, &id_);
     id_ = 0;
-    memory_tracker_.UpdateMemRepresented(0);
   }
+  memory_tracker_.TrackMemFree(bytes_allocated_);
+  bytes_allocated_ = 0;
 }
 
 void Texture::Invalidate() {
@@ -1887,7 +1896,9 @@ void Texture::Invalidate() {
 
 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) {
 }
 
@@ -1930,9 +1941,11 @@ bool RenderBuffer::AllocateStorage(const gfx::Size& size, GLenum format,
   }
   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;
 }
@@ -1942,8 +1955,9 @@ void RenderBuffer::Destroy() {
     ScopedGLErrorSuppressor suppressor(decoder_);
     glDeleteRenderbuffersEXT(1, &id_);
     id_ = 0;
-    memory_tracker_.UpdateMemRepresented(0);
   }
+  memory_tracker_.TrackMemFree(bytes_allocated_);
+  bytes_allocated_ = 0;
 }
 
 void RenderBuffer::Invalidate() {
diff --git a/gpu/command_buffer/service/memory_tracking.h b/gpu/command_buffer/service/memory_tracking.h
index 35ba950..de82ceb 100644
--- a/gpu/command_buffer/service/memory_tracking.h
+++ b/gpu/command_buffer/service/memory_tracking.h
@@ -16,7 +16,14 @@ namespace gles2 {
 // statistics to the global GpuMemoryManager.
 class MemoryTracker : public base::RefCounted<MemoryTracker> {
  public:
-  virtual void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) = 0;
+   enum Pool {
+     kUnmanaged,
+     kManaged
+   };
+
+   virtual void TrackMemoryAllocatedChange(size_t old_size,
+                                           size_t new_size,
+                                           Pool pool) = 0;
 
  protected:
   friend class base::RefCounted<MemoryTracker>;
@@ -32,34 +39,49 @@ class MemoryTracker : public base::RefCounted<MemoryTracker> {
 // MemoryTracker.
 class MemoryTypeTracker {
  public:
-  MemoryTypeTracker(MemoryTracker* memory_tracker)
+  MemoryTypeTracker(MemoryTracker* memory_tracker, MemoryTracker::Pool pool)
     : memory_tracker_(memory_tracker),
-      has_updated_mem_represented_(false),
-      last_updated_mem_represented_(0) {
+      pool_(pool),
+      has_done_update_(false),
+      mem_represented_(0),
+      mem_represented_at_last_update_(0) {
+  }
+
+  void TrackMemAlloc(size_t bytes) {
+    mem_represented_ += bytes;
+  }
+
+  void TrackMemFree(size_t bytes) {
+    DCHECK(bytes <= mem_represented_);
+    mem_represented_ -= bytes;
   }
 
-  void UpdateMemRepresented(size_t mem_represented) {
-    if (!has_updated_mem_represented_ &&
-        mem_represented == last_updated_mem_represented_) {
+  void UpdateMemRepresented() {
+    // Skip redundant updates only if we have already done an update.
+    if (!has_done_update_ &&
+        mem_represented_ == mem_represented_at_last_update_) {
       return;
     }
     if (memory_tracker_) {
       memory_tracker_->TrackMemoryAllocatedChange(
-        last_updated_mem_represented_,
-        mem_represented);
+        mem_represented_at_last_update_,
+        mem_represented_,
+        pool_);
     }
-    has_updated_mem_represented_ = true;
-    last_updated_mem_represented_ = mem_represented;
+    has_done_update_ = true;
+    mem_represented_at_last_update_ = mem_represented_;
   }
 
   size_t GetMemRepresented() const {
-    return last_updated_mem_represented_;
+    return mem_represented_at_last_update_;
   }
 
  private:
   MemoryTracker* memory_tracker_;
-  bool has_updated_mem_represented_;
-  size_t last_updated_mem_represented_;
+  MemoryTracker::Pool pool_;
+  bool has_done_update_;
+  size_t mem_represented_;
+  size_t mem_represented_at_last_update_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryTypeTracker);
 };
diff --git a/gpu/command_buffer/service/renderbuffer_manager.cc b/gpu/command_buffer/service/renderbuffer_manager.cc
index 56a8490..e94518a 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.cc
+++ b/gpu/command_buffer/service/renderbuffer_manager.cc
@@ -17,14 +17,14 @@ RenderbufferManager::RenderbufferManager(
     MemoryTracker* memory_tracker,
     GLint max_renderbuffer_size,
     GLint max_samples)
-    : renderbuffer_memory_tracker_(new MemoryTypeTracker(memory_tracker)),
+    : memory_tracker_(
+          new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
       max_renderbuffer_size_(max_renderbuffer_size),
       max_samples_(max_samples),
       num_uncleared_renderbuffers_(0),
-      mem_represented_(0),
       renderbuffer_info_count_(0),
       have_context_(true) {
-  UpdateMemRepresented();
+  memory_tracker_->UpdateMemRepresented();
 }
 
 RenderbufferManager::~RenderbufferManager() {
@@ -60,16 +60,11 @@ RenderbufferManager::RenderbufferInfo::~RenderbufferInfo() {
   }
 }
 
-
-void RenderbufferManager::UpdateMemRepresented() {
-  renderbuffer_memory_tracker_->UpdateMemRepresented(mem_represented_);
-}
-
 void RenderbufferManager::Destroy(bool have_context) {
   have_context_ = have_context;
   renderbuffer_infos_.clear();
-  DCHECK_EQ(0u, mem_represented_);
-  UpdateMemRepresented();
+  DCHECK_EQ(0u, memory_tracker_->GetMemRepresented());
+  memory_tracker_->UpdateMemRepresented();
 }
 
 void RenderbufferManager::StartTracking(RenderbufferInfo* /* renderbuffer */) {
@@ -81,7 +76,8 @@ void RenderbufferManager::StopTracking(RenderbufferInfo* renderbuffer) {
   if (!renderbuffer->cleared()) {
     --num_uncleared_renderbuffers_;
   }
-  mem_represented_ -= renderbuffer->EstimatedSize();
+  memory_tracker_->TrackMemFree(renderbuffer->EstimatedSize());
+  memory_tracker_->UpdateMemRepresented();
 }
 
 void RenderbufferManager::SetInfo(
@@ -91,10 +87,10 @@ void RenderbufferManager::SetInfo(
   if (!renderbuffer->cleared()) {
     --num_uncleared_renderbuffers_;
   }
-  mem_represented_ -= renderbuffer->EstimatedSize();
+  memory_tracker_->TrackMemFree(renderbuffer->EstimatedSize());
   renderbuffer->SetInfo(samples, internalformat, width, height);
-  mem_represented_ += renderbuffer->EstimatedSize();
-  UpdateMemRepresented();
+  memory_tracker_->TrackMemAlloc(renderbuffer->EstimatedSize());
+  memory_tracker_->UpdateMemRepresented();
   if (!renderbuffer->cleared()) {
     ++num_uncleared_renderbuffers_;
   }
diff --git a/gpu/command_buffer/service/renderbuffer_manager.h b/gpu/command_buffer/service/renderbuffer_manager.h
index f440ab0..b64fd7d 100644
--- a/gpu/command_buffer/service/renderbuffer_manager.h
+++ b/gpu/command_buffer/service/renderbuffer_manager.h
@@ -11,14 +11,12 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
 
 namespace gpu {
 namespace gles2 {
 
-class MemoryTracker;
-class MemoryTypeTracker;
-
 // This class keeps track of the renderbuffers and whether or not they have
 // been cleared.
 class GPU_EXPORT RenderbufferManager {
@@ -169,24 +167,20 @@ class GPU_EXPORT RenderbufferManager {
   bool GetClientId(GLuint service_id, GLuint* client_id) const;
 
   size_t mem_represented() const {
-    return mem_represented_;
+    return memory_tracker_->GetMemRepresented();
   }
 
  private:
-  void UpdateMemRepresented();
-
   void StartTracking(RenderbufferInfo* renderbuffer);
   void StopTracking(RenderbufferInfo* renderbuffer);
 
-  scoped_ptr<MemoryTypeTracker> renderbuffer_memory_tracker_;
+  scoped_ptr<MemoryTypeTracker> memory_tracker_;
 
   GLint max_renderbuffer_size_;
   GLint max_samples_;
 
   int num_uncleared_renderbuffers_;
 
-  size_t mem_represented_;
-
   // Counts the number of RenderbufferInfo allocated with 'this' as its manager.
   // Allows to check no RenderbufferInfo will outlive this.
   unsigned renderbuffer_info_count_;
diff --git a/gpu/command_buffer/service/texture_manager.cc b/gpu/command_buffer/service/texture_manager.cc
index ce54615..7f6dadb 100644
--- a/gpu/command_buffer/service/texture_manager.cc
+++ b/gpu/command_buffer/service/texture_manager.cc
@@ -82,8 +82,10 @@ void TextureManager::Destroy(bool have_context) {
     glDeleteTextures(arraysize(black_texture_ids_), black_texture_ids_);
   }
 
-  DCHECK_EQ(0u, mem_represented_);
-  UpdateMemRepresented();
+  DCHECK_EQ(0u, memory_tracker_managed_->GetMemRepresented());
+  DCHECK_EQ(0u, memory_tracker_unmanaged_->GetMemRepresented());
+  memory_tracker_managed_->UpdateMemRepresented();
+  memory_tracker_unmanaged_->UpdateMemRepresented();
 }
 
 TextureManager::TextureInfo::TextureInfo(TextureManager* manager,
@@ -99,6 +101,7 @@ TextureManager::TextureInfo::TextureInfo(TextureManager* manager,
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
+      tracking_pool_(MemoryTracker::kUnmanaged),
       max_level_set_(-1),
       texture_complete_(false),
       cube_complete_(false),
@@ -692,7 +695,10 @@ TextureManager::TextureManager(
     FeatureInfo* feature_info,
     GLint max_texture_size,
     GLint max_cube_map_texture_size)
-    : texture_memory_tracker_(new MemoryTypeTracker(memory_tracker)),
+    : memory_tracker_managed_(
+          new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
+      memory_tracker_unmanaged_(
+          new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
       feature_info_(feature_info),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
@@ -706,19 +712,15 @@ TextureManager::TextureManager(
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       texture_info_count_(0),
-      mem_represented_(0),
       have_context_(true) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
   }
 }
 
-void TextureManager::UpdateMemRepresented() {
-  texture_memory_tracker_->UpdateMemRepresented(mem_represented_);
-}
-
 bool TextureManager::Initialize() {
-  UpdateMemRepresented();
+  memory_tracker_managed_->UpdateMemRepresented();
+  memory_tracker_unmanaged_->UpdateMemRepresented();
 
   // TODO(gman): The default textures have to be real textures, not the 0
   // texture because we simulate non shared resources on top of shared
@@ -912,12 +914,13 @@ void TextureManager::SetLevelInfo(
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  mem_represented_ -= info->estimated_size();
+
+  GetMemTracker(info->tracking_pool_)->TrackMemFree(info->estimated_size());
   info->SetLevelInfo(
       feature_info_, target, level, internal_format, width, height, depth,
       border, format, type, cleared);
-  mem_represented_ += info->estimated_size();
-  UpdateMemRepresented();
+  GetMemTracker(info->tracking_pool_)->TrackMemAlloc(info->estimated_size());
+  GetMemTracker(info->tracking_pool_)->UpdateMemRepresented();
 
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info_)) {
@@ -1069,10 +1072,10 @@ bool TextureManager::MarkMipmapsGenerated(TextureManager::TextureInfo* info) {
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  mem_represented_ -= info->estimated_size();
+  GetMemTracker(info->tracking_pool_)->TrackMemFree(info->estimated_size());
   bool result = info->MarkMipmapsGenerated(feature_info_);
-  mem_represented_ += info->estimated_size();
-  UpdateMemRepresented();
+  GetMemTracker(info->tracking_pool_)->TrackMemAlloc(info->estimated_size());
+  GetMemTracker(info->tracking_pool_)->UpdateMemRepresented();
 
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info_)) {
@@ -1132,8 +1135,25 @@ void TextureManager::StopTracking(TextureManager::TextureInfo* texture) {
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
-  mem_represented_ -= texture->estimated_size();
-  UpdateMemRepresented();
+  GetMemTracker(texture->tracking_pool_)->TrackMemFree(
+      texture->estimated_size());
+  GetMemTracker(texture->tracking_pool_)->UpdateMemRepresented();
+}
+
+MemoryTypeTracker* TextureManager::GetMemTracker(
+    MemoryTracker::Pool tracking_pool) {
+  switch(tracking_pool) {
+    case MemoryTracker::kManaged:
+      return memory_tracker_managed_.get();
+      break;
+    case MemoryTracker::kUnmanaged:
+      return memory_tracker_unmanaged_.get();
+      break;
+    default:
+      break;
+  }
+  NOTREACHED();
+  return NULL;
 }
 
 bool TextureManager::GetClientId(GLuint service_id, GLuint* client_id) const {
diff --git a/gpu/command_buffer/service/texture_manager.h b/gpu/command_buffer/service/texture_manager.h
index f2e7963..8c3100b 100644
--- a/gpu/command_buffer/service/texture_manager.h
+++ b/gpu/command_buffer/service/texture_manager.h
@@ -13,6 +13,7 @@
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gl_utils.h"
+#include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
 #include "ui/gl/gl_image.h"
 
@@ -22,8 +23,6 @@ namespace gles2 {
 class GLES2Decoder;
 class Display;
 class TextureDefinition;
-class MemoryTracker;
-class MemoryTypeTracker;
 
 // This class keeps track of the textures and their sizes so we can do NPOT and
 // texture complete checking.
@@ -312,6 +311,11 @@ class GPU_EXPORT TextureManager {
     GLenum wrap_t_;
     GLenum usage_;
 
+    // The accounting pool towards which the memory for this allocation should
+    // be charged. This will be rolled into a new GLenum texture parameter in
+    // a separate change.
+    MemoryTracker::Pool tracking_pool_;
+
     // The maximum level that has been set.
     GLint max_level_set_;
 
@@ -508,8 +512,10 @@ class GPU_EXPORT TextureManager {
     }
   }
 
-  uint32 mem_represented() const {
-    return mem_represented_;
+  size_t mem_represented() const {
+    return
+        memory_tracker_managed_->GetMemRepresented() +
+        memory_tracker_unmanaged_->GetMemRepresented();
   }
 
   void SetLevelImage(
@@ -530,12 +536,12 @@ class GPU_EXPORT TextureManager {
       GLenum target,
       GLuint* black_texture);
 
-  void UpdateMemRepresented();
-
   void StartTracking(TextureInfo* info);
   void StopTracking(TextureInfo* info);
 
-  scoped_ptr<MemoryTypeTracker> texture_memory_tracker_;
+  MemoryTypeTracker* GetMemTracker(MemoryTracker::Pool tracking_pool);
+  scoped_ptr<MemoryTypeTracker> memory_tracker_managed_;
+  scoped_ptr<MemoryTypeTracker> memory_tracker_unmanaged_;
 
   FeatureInfo::Ref feature_info_;
 
@@ -556,8 +562,6 @@ class GPU_EXPORT TextureManager {
   // Allows to check no TextureInfo will outlive this.
   unsigned int texture_info_count_;
 
-  uint32 mem_represented_;
-
   bool have_context_;
 
   // Black (0,0,0,1) textures for when non-renderable textures are used.