Track managed memory usage in the command buffer.

gpu/command_buffer/service/buffer_manager.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/buffer_manager.h"
 #include <limits>
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 
 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() {
   DCHECK(buffer_infos_.empty());
   CHECK_EQ(buffer_info_count_, 0u);
 }
 
 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) {
   BufferInfo::Ref buffer(new BufferInfo(this, service_id));
   std::pair<BufferInfoMap::iterator, bool> result =
       buffer_infos_.insert(std::make_pair(client_id, buffer));
   DCHECK(result.second);
 }
 
 BufferManager::BufferInfo* BufferManager::GetBufferInfo(
     GLuint client_id) {
   BufferInfoMap::iterator it = buffer_infos_.find(client_id);
   return it != buffer_infos_.end() ? it->second : NULL;
 }
 
 void BufferManager::RemoveBufferInfo(GLuint client_id) {
   BufferInfoMap::iterator it = buffer_infos_.find(client_id);
   if (it != buffer_infos_.end()) {
     BufferInfo* buffer = it->second;
     buffer->MarkAsDeleted();
     buffer_infos_.erase(it);
   }
 }
 
 void BufferManager::StartTracking(BufferManager::BufferInfo* /* buffer */) {
   ++buffer_info_count_;
 }
 
 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)
     : manager_(manager),
       deleted_(false),
       service_id_(service_id),
       target_(0),
       size_(0),
       usage_(GL_STATIC_DRAW),
       shadowed_(false) {
@@ skipping 139 matching lines @@
       *client_id = it->first;
       return true;
     }
   }
   return false;
 }
 
 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) {
   // Check that we are not trying to bind it to a different target.
   if (info->target() != 0 && info->target() != target &&
       !allow_buffers_on_multiple_targets_) {
     return false;
   }
   if (info->target() == 0) {
     info->set_target(target);
   }
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu