Revert 260177 "By keeping track of transfer buffer usage (both s..."

trunk/src/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"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 61 matching lines @@
   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferService> command_buffer_;
   scoped_ptr<GpuScheduler> gpu_scheduler_;
   scoped_ptr<CommandBufferHelper> helper_;
 };
 
 #ifndef _MSC_VER
 const unsigned int MappedMemoryTestBase::kBufferSize;
 #endif
 
-namespace {
-void EmptyPoll() {
-}
-}
-
 // Test fixture for MemoryChunk test - Creates a MemoryChunk, using a
 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
 // it directly, not through the RPC mechanism), making sure Noops are ignored
 // and SetToken are properly forwarded to the engine.
 class MemoryChunkTest : public MappedMemoryTestBase {
  protected:
   static const int32 kShmId = 123;
   virtual void SetUp() {
     MappedMemoryTestBase::SetUp();
     scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
     shared_memory->CreateAndMapAnonymous(kBufferSize);
     buffer_ = new gpu::Buffer(shared_memory.Pass(), kBufferSize);
-    chunk_.reset(new MemoryChunk(kShmId,
-                                 buffer_,
-                                 helper_.get(),
-                                 base::Bind(&EmptyPoll)));
+    chunk_.reset(new MemoryChunk(kShmId, buffer_, helper_.get()));
   }
 
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
 
     MappedMemoryTestBase::TearDown();
   }
 
   uint8* buffer_memory() { return static_cast<uint8*>(buffer_->memory()); }
@@ skipping 30 matching lines @@
   EXPECT_LE(buffer_memory(), pointer_char);
   EXPECT_GE(buffer_memory() + kBufferSize, pointer_char + kSize);
   EXPECT_EQ(kBufferSize - kSize, chunk_->GetLargestFreeSizeWithoutWaiting());
   EXPECT_EQ(kBufferSize - kSize, chunk_->GetLargestFreeSizeWithWaiting());
   chunk_->Free(pointer_char);
   EXPECT_EQ(kBufferSize, chunk_->GetLargestFreeSizeWithoutWaiting());
   EXPECT_EQ(kBufferSize, chunk_->GetLargestFreeSizeWithWaiting());
 }
 
 class MappedMemoryManagerTest : public MappedMemoryTestBase {
- public:
-  MappedMemoryManager* manager() const {
-    return manager_.get();
-  }
-
  protected:
   virtual void SetUp() {
     MappedMemoryTestBase::SetUp();
     manager_.reset(new MappedMemoryManager(
-        helper_.get(), base::Bind(&EmptyPoll), MappedMemoryManager::kNoLimit));
+        helper_.get(), MappedMemoryManager::kNoLimit));
   }
 
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
     manager_.reset();
     MappedMemoryTestBase::TearDown();
   }
 
   scoped_ptr<MappedMemoryManager> manager_;
@@ skipping 139 matching lines @@
   EXPECT_EQ(id1, id2);
   EXPECT_NE(id2, id3);
   EXPECT_EQ(0u, offset1);
   EXPECT_EQ(kSize, offset2);
   EXPECT_EQ(0u, offset3);
 }
 
 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_.reset(new MappedMemoryManager(helper_.get(), 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());
 }
 
 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));
+  manager_.reset(new MappedMemoryManager(helper_.get(), kSize));
   const unsigned int kChunkSize = 2 * 1024;
   manager_->set_chunk_size_multiple(kChunkSize);
 
   // Allocate half a chunk worth of memory.
   int32 id1 = -1;
   unsigned int offset1 = 0xFFFFFFFFU;
   void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
   ASSERT_TRUE(mem1);
   EXPECT_NE(-1, id1);
   EXPECT_EQ(0u, offset1);
@@ skipping 25 matching lines @@
   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());
 }
 
-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);
-  }
-}
-}
-
-TEST_F(MappedMemoryManagerTest, Poll) {
-  std::list<void*> unmanaged_memory_list;
-
-  const unsigned int kSize = 1024;
-  // Reset the manager with a memory limit.
-  manager_.reset(new MappedMemoryManager(
-      helper_.get(),
-      base::Bind(&Poll, this, &unmanaged_memory_list),
-      kSize));
-
-  // Allocate kSize bytes. Don't add the address to
-  // the unmanaged memory list, so that it won't be free:ed just yet.
-  int32 id1;
-  unsigned int offset1;
-  void* mem1 = manager_->Alloc(kSize, &id1, &offset1);
-  EXPECT_EQ(manager_->bytes_in_use(), kSize);
-
-  // Allocate kSize more bytes, and make sure we grew.
-  int32 id2;
-  unsigned int offset2;
-  void* mem2 = manager_->Alloc(kSize, &id2, &offset2);
-  EXPECT_EQ(manager_->bytes_in_use(), kSize * 2);
-
-  // Make the unmanaged buffer be released next time FreeUnused() is called
-  // in MappedMemoryManager/FencedAllocator. This happens for example when
-  // allocating new memory.
-  unmanaged_memory_list.push_back(mem1);
-
-  // Allocate kSize more bytes. This should poll unmanaged memory, which now
-  // should free the previously allocated unmanaged memory.
-  int32 id3;
-  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