gpu: Assert that FencedAllocator is empty in destructor

gpu/command_buffer/client/mapped_memory_unittest.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/client/mapped_memory.h"
 
 #include <list>
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 250 matching lines @@
   EXPECT_NE(new_id, -1);
   EXPECT_NE(new_offset, 0xFFFFFFFFu);
 
   // Free up everything.
   manager_->Free(new_ptr);
   for (unsigned int i = 1; i < kAllocCount; ++i) {
     manager_->Free(pointers[i]);
   }
 }
 
-// Check if we don't free we don't crash.
-TEST_F(MappedMemoryManagerTest, DontFree) {
-  const unsigned int kSize = 1024;
-  // Check we can alloc.
-  int32 id1 = -1;
-  unsigned int offset1 = 0xFFFFFFFFU;
-  void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
-  ASSERT_TRUE(mem1);
-}
-
 TEST_F(MappedMemoryManagerTest, FreeUnused) {
   int32 id = -1;
   unsigned int offset = 0xFFFFFFFFU;
   void* m1 = manager_->Alloc(kBufferSize, &id, &offset);
   void* m2 = manager_->Alloc(kBufferSize, &id, &offset);
   ASSERT_TRUE(m1 != NULL);
   ASSERT_TRUE(m2 != NULL);
   EXPECT_EQ(2u, manager_->num_chunks());
   manager_->FreeUnused();
   EXPECT_EQ(2u, manager_->num_chunks());
@@ skipping 23 matching lines @@
   void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
   ASSERT_TRUE(mem1);
   ASSERT_TRUE(mem2);
   ASSERT_TRUE(mem3);
   EXPECT_NE(-1, id1);
   EXPECT_EQ(id1, id2);
   EXPECT_NE(id2, id3);
   EXPECT_EQ(0u, offset1);
   EXPECT_EQ(kSize, offset2);
   EXPECT_EQ(0u, offset3);
+
+  manager_->Free(mem1);
+  manager_->Free(mem2);
+  manager_->Free(mem3);
 }
 
 TEST_F(MappedMemoryManagerTest, UnusedMemoryLimit) {
   const unsigned int kChunkSize = 2048;
   // Reset the manager with a memory limit.
   manager_.reset(new MappedMemoryManager(
       helper_.get(), base::Bind(&EmptyPoll), kChunkSize));
   manager_->set_chunk_size_multiple(kChunkSize);
 
   // Allocate one chunk worth of memory.
   int32 id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kChunkSize, &id1, &offset1);
   ASSERT_TRUE(mem1);
   EXPECT_NE(-1, id1);
   EXPECT_EQ(0u, offset1);
 
   // Allocate half a chunk worth of memory again.
   // The same chunk will be used.
   int32 id2 = -1;
   unsigned int offset2 = 0xFFFFFFFFU;
   void* mem2 = manager_->Alloc(kChunkSize, &id2, &offset2);
   ASSERT_TRUE(mem2);
   EXPECT_NE(-1, id2);
   EXPECT_EQ(0u, offset2);
 
   // Expect two chunks to be allocated, exceeding the limit,
   // since all memory is in use.
   EXPECT_EQ(2 * kChunkSize, manager_->allocated_memory());
+
+  manager_->Free(mem1);
+  manager_->Free(mem2);
 }
 
 TEST_F(MappedMemoryManagerTest, MemoryLimitWithReuse) {
   const unsigned int kSize = 1024;
   // Reset the manager with a memory limit.
   manager_.reset(new MappedMemoryManager(
       helper_.get(), base::Bind(&EmptyPoll), kSize));
   const unsigned int kChunkSize = 2 * 1024;
   manager_->set_chunk_size_multiple(kChunkSize);
 
@@ skipping 30 matching lines @@
   int32 id3 = -1;
   unsigned int offset3 = 0xFFFFFFFFU;
   void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
   ASSERT_TRUE(mem3);
   EXPECT_NE(-1, id3);
   // It will reuse the space from the second allocation just freed.
   EXPECT_EQ(kSize, offset3);
 
   // Expect one chunk to be allocated
   EXPECT_EQ(1 * kChunkSize, manager_->allocated_memory());
+
+  manager_->Free(mem1);
+  manager_->Free(mem3);
 }
 
 namespace {
 void Poll(MappedMemoryManagerTest *test, std::list<void*>* list) {
   std::list<void*>::iterator it = list->begin();
   while (it != list->end()) {
     void* address = *it;
     test->manager()->Free(address);
     it = list->erase(it);
   }
@@ skipping 34 matching lines @@
   unsigned int offset3;
   void* mem3 = manager_->Alloc(kSize, &id3, &offset3);
   EXPECT_EQ(manager_->bytes_in_use(), kSize * 2);
 
   manager_->Free(mem2);
   manager_->Free(mem3);
   EXPECT_EQ(manager_->bytes_in_use(), static_cast<size_t>(0));
 }
 
 }  // namespace gpu