Shrink QueryTracker when freeing everything

gpu/command_buffer/client/query_tracker.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 <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 
 #include "../client/query_tracker.h"
 
 #include "../client/atomicops.h"
 #include "../client/gles2_cmd_helper.h"
 #include "../client/gles2_implementation.h"
 #include "../client/mapped_memory.h"
 #include "../common/time.h"
 
 namespace gpu {
 namespace gles2 {
 
 QuerySyncManager::QuerySyncManager(MappedMemoryManager* manager)
     : mapped_memory_(manager) {
   GPU_DCHECK(manager);
 }
 
 QuerySyncManager::~QuerySyncManager() {
   while (!buckets_.empty()) {
-    mapped_memory_->Free(buckets_.front());
-    buckets_.pop();
+    mapped_memory_->Free(buckets_.front()->syncs);
+    delete buckets_.front();
+    buckets_.pop_front();
   }
 }
 
 bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) {
   GPU_DCHECK(info);
   if (free_queries_.empty()) {
     int32 shm_id;
     unsigned int shm_offset;
     void* mem = mapped_memory_->Alloc(
         kSyncsPerBucket * sizeof(QuerySync), &shm_id, &shm_offset);
     if (!mem) {
       return false;
     }
     QuerySync* syncs = static_cast<QuerySync*>(mem);
-    buckets_.push(syncs);
+    Bucket* bucket = new Bucket(syncs);
+    buckets_.push_back(bucket);
     for (size_t ii = 0; ii < kSyncsPerBucket; ++ii) {
-      free_queries_.push(QueryInfo(shm_id, shm_offset, syncs));
+      free_queries_.push_back(QueryInfo(bucket, shm_id, shm_offset, syncs));
       ++syncs;
       shm_offset += sizeof(*syncs);
     }
   }
   *info = free_queries_.front();
+  ++(info->bucket->used_query_count);
   info->sync->Reset();
-  free_queries_.pop();
+  free_queries_.pop_front();
   return true;
 }
 
 void QuerySyncManager::Free(const QuerySyncManager::QueryInfo& info) {
-  free_queries_.push(info);
+  DCHECK_GT(info.bucket->used_query_count, 0u);
+  --(info.bucket->used_query_count);
+  free_queries_.push_back(info);
+}
+
+void QuerySyncManager::Shrink() {
+  std::deque<QueryInfo> new_queue;
+  while (!free_queries_.empty()) {
+    if (free_queries_.front().bucket->used_query_count)
+      new_queue.push_back(free_queries_.front());
+    free_queries_.pop_front();
+  }
+  free_queries_.swap(new_queue);
+
+  std::deque<Bucket*> new_buckets;
+  while (!buckets_.empty()) {
+    Bucket* bucket = buckets_.front();
+    if (bucket->used_query_count) {
+      new_buckets.push_back(bucket);
+    } else {
+      mapped_memory_->Free(bucket->syncs);
+      delete bucket;
+    }
+    buckets_.pop_front();
+  }
+  buckets_.swap(new_buckets);
 }
 
 QueryTracker::Query::Query(GLuint id, GLenum target,
                            const QuerySyncManager::QueryInfo& info)
     : id_(id),
       target_(target),
       info_(info),
       state_(kUninitialized),
       submit_count_(0),
       token_(0),
@@ skipping 130 matching lines @@
   QueryMap::iterator it = queries_.find(client_id);
   if (it != queries_.end()) {
     Query* query = it->second;
     GPU_DCHECK(context_lost || !query->Pending());
     query_sync_manager_.Free(query->info_);
     queries_.erase(it);
     delete query;
   }
 }
 
+void QueryTracker::Shrink() {
+  query_sync_manager_.Shrink();
+}
+
 }  // namespace gles2
 }  // namespace gpu