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

trunk/src/gpu/command_buffer/client/fenced_allocator_test.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.
 
 // This file contains the tests for the FencedAllocator class.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/aligned_memory.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 11 matching lines @@
 #endif
 
 namespace gpu {
 
 using testing::Return;
 using testing::Mock;
 using testing::Truly;
 using testing::Sequence;
 using testing::DoAll;
 using testing::Invoke;
-using testing::InvokeWithoutArgs;
 using testing::_;
 
 class BaseFencedAllocatorTest : public testing::Test {
  protected:
   static const unsigned int kBufferSize = 1024;
   static const int kAllocAlignment = 16;
 
   virtual void SetUp() {
     api_mock_.reset(new AsyncAPIMock);
     // ignore noops in the mock - we don't want to inspect the internals of the
@@ skipping 39 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 BaseFencedAllocatorTest::kBufferSize;
 #endif
 
-namespace {
-void EmptyPoll() {
-}
-}
-
 // Test fixture for FencedAllocator test - Creates a FencedAllocator, 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 FencedAllocatorTest : public BaseFencedAllocatorTest {
  protected:
   virtual void SetUp() {
     BaseFencedAllocatorTest::SetUp();
-    allocator_.reset(new FencedAllocator(kBufferSize,
-                                         helper_.get(),
-                                         base::Bind(&EmptyPoll)));
+    allocator_.reset(new FencedAllocator(kBufferSize, helper_.get()));
   }
 
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
 
     EXPECT_TRUE(allocator_->CheckConsistency());
 
     BaseFencedAllocatorTest::TearDown();
   }
@@ skipping 274 matching lines @@
   // Check that the token has indeed passed.
   EXPECT_LE(token, GetToken());
   allocator_->Free(offset);
 
   // Everything now has been freed...
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
   // ... for real.
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 }
 
-class FencedAllocatorPollTest : public BaseFencedAllocatorTest {
- public:
-  static const unsigned int kAllocSize = 128;
-
-  MOCK_METHOD0(MockedPoll, void());
-
- protected:
-  virtual void TearDown() {
-    // If the GpuScheduler posts any tasks, this forces them to run.
-    base::MessageLoop::current()->RunUntilIdle();
-
-    BaseFencedAllocatorTest::TearDown();
-  }
-};
-
-TEST_F(FencedAllocatorPollTest, TestPoll) {
-  scoped_ptr<FencedAllocator> allocator(
-      new FencedAllocator(kBufferSize,
-                          helper_.get(),
-                          base::Bind(&FencedAllocatorPollTest::MockedPoll,
-                                     base::Unretained(this))));
-
-  FencedAllocator::Offset mem1 = allocator->Alloc(kAllocSize);
-  FencedAllocator::Offset mem2 = allocator->Alloc(kAllocSize);
-  EXPECT_NE(mem1, FencedAllocator::kInvalidOffset);
-  EXPECT_NE(mem2, FencedAllocator::kInvalidOffset);
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 2);
-
-  // Check that no-op Poll doesn't affect the state.
-  EXPECT_CALL(*this, MockedPoll()).RetiresOnSaturation();
-  allocator->FreeUnused();
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 2);
-
-  // Check that freeing in Poll works.
-  base::Closure free_mem1_closure =
-      base::Bind(&FencedAllocator::Free,
-                 base::Unretained(allocator.get()),
-                 mem1);
-  EXPECT_CALL(*this, MockedPoll())
-      .WillOnce(InvokeWithoutArgs(&free_mem1_closure, &base::Closure::Run))
-      .RetiresOnSaturation();
-  allocator->FreeUnused();
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), kAllocSize * 1);
-
-  // Check that freeing still works.
-  EXPECT_CALL(*this, MockedPoll()).RetiresOnSaturation();
-  allocator->Free(mem2);
-  allocator->FreeUnused();
-  EXPECT_TRUE(allocator->CheckConsistency());
-  EXPECT_EQ(allocator->bytes_in_use(), 0u);
-
-  allocator.reset();
-}
-
 // Test fixture for FencedAllocatorWrapper test - Creates a
 // FencedAllocatorWrapper, 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 FencedAllocatorWrapperTest : public BaseFencedAllocatorTest {
  protected:
   virtual void SetUp() {
     BaseFencedAllocatorTest::SetUp();
 
     // Though allocating this buffer isn't strictly necessary, it makes
     // allocations point to valid addresses, so they could be used for
     // something.
     buffer_.reset(static_cast<char*>(base::AlignedAlloc(
         kBufferSize, kAllocAlignment)));
-    allocator_.reset(new FencedAllocatorWrapper(kBufferSize,
-                                                helper_.get(),
-                                                base::Bind(&EmptyPoll),
+    allocator_.reset(new FencedAllocatorWrapper(kBufferSize, helper_.get(),
                                                 buffer_.get()));
   }
 
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
 
     EXPECT_TRUE(allocator_->CheckConsistency());
 
     BaseFencedAllocatorTest::TearDown();
@@ skipping 149 matching lines @@
   EXPECT_LE(token, GetToken());
 
   // Free up everything.
   for (unsigned int i = 0; i < kAllocCount; ++i) {
     allocator_->Free(pointers[i]);
     EXPECT_TRUE(allocator_->CheckConsistency());
   }
 }
 
 }  // namespace gpu