Add AsyncFlush when transferbuffer is > a certain size

gpu/command_buffer/client/transfer_buffer_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.
 
 // Tests for the Command Buffer Helper.
 
 #include "gpu/command_buffer/client/transfer_buffer.h"
 
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/compiler_specific.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace gpu {
 
+
 class TransferBufferTest : public testing::Test {
  protected:
   static const int32 kNumCommandEntries = 400;
   static const int32 kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const unsigned int kStartingOffset = 64;
   static const unsigned int kAlignment = 4;
   static const size_t kTransferBufferSize = 256;
 
   TransferBufferTest()
       : transfer_buffer_id_(0) {
   }
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  MockClientCommandBuffer* command_buffer() const {
+  virtual void Initialize(unsigned int size_to_flush) {
+    ASSERT_TRUE(transfer_buffer_->Initialize(
+        kTransferBufferSize,
+        kStartingOffset,
+        kTransferBufferSize,
+        kTransferBufferSize,
+        kAlignment,
+        size_to_flush));
+  }
+
+  MockClientCommandBufferMockFlush* command_buffer() const {
     return command_buffer_.get();
   }
 
-  scoped_ptr<MockClientCommandBuffer> command_buffer_;
+  scoped_ptr<MockClientCommandBufferMockFlush> command_buffer_;
   scoped_ptr<CommandBufferHelper> helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
   int32 transfer_buffer_id_;
 };
 
 void TransferBufferTest::SetUp() {
-  command_buffer_.reset(new StrictMock<MockClientCommandBuffer>());
+  command_buffer_.reset(new StrictMock<MockClientCommandBufferMockFlush>());
   ASSERT_TRUE(command_buffer_->Initialize());
 
   helper_.reset(new CommandBufferHelper(command_buffer()));
   ASSERT_TRUE(helper_->Initialize(kCommandBufferSizeBytes));
 
   transfer_buffer_id_ = command_buffer()->GetNextFreeTransferBufferId();
 
   transfer_buffer_.reset(new TransferBuffer(helper_.get()));
-  ASSERT_TRUE(transfer_buffer_->Initialize(
-      kTransferBufferSize,
-      kStartingOffset,
-      kTransferBufferSize,
-      kTransferBufferSize,
-      kAlignment));
 }
 
 void TransferBufferTest::TearDown() {
   if (transfer_buffer_->HaveBuffer()) {
     EXPECT_CALL(*command_buffer(), OnFlush())
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
         .Times(1)
         .RetiresOnSaturation();
   }
   transfer_buffer_.reset();
 }
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const int32 TransferBufferTest::kNumCommandEntries;
 const int32 TransferBufferTest::kCommandBufferSizeBytes;
 const unsigned int TransferBufferTest::kStartingOffset;
 const unsigned int TransferBufferTest::kAlignment;
 const size_t TransferBufferTest::kTransferBufferSize;
 #endif
 
 TEST_F(TransferBufferTest, Basic) {
+  Initialize(0);
   EXPECT_TRUE(transfer_buffer_->HaveBuffer());
   EXPECT_EQ(transfer_buffer_id_, transfer_buffer_->GetShmId());
   EXPECT_EQ(
       kTransferBufferSize - kStartingOffset,
       transfer_buffer_->GetCurrentMaxAllocationWithoutRealloc());
 }
 
 TEST_F(TransferBufferTest, Free) {
+  Initialize(0);
   EXPECT_TRUE(transfer_buffer_->HaveBuffer());
   EXPECT_EQ(transfer_buffer_id_, transfer_buffer_->GetShmId());
 
   // Free buffer.
   EXPECT_CALL(*command_buffer(), OnFlush())
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
@@ skipping 58 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
   transfer_buffer_->Free();
   transfer_buffer_->Free();
 }
 
 TEST_F(TransferBufferTest, TooLargeAllocation) {
+  Initialize(0);
   // Check that we can't allocate large than max size.
   void* ptr = transfer_buffer_->Alloc(kTransferBufferSize + 1);
   EXPECT_TRUE(ptr == NULL);
   // Check we if we try to allocate larger than max we get max.
   unsigned int size_allocated = 0;
   ptr = transfer_buffer_->AllocUpTo(
       kTransferBufferSize + 1, &size_allocated);
   ASSERT_TRUE(ptr != NULL);
   EXPECT_EQ(kTransferBufferSize - kStartingOffset, size_allocated);
   transfer_buffer_->FreePendingToken(ptr, 1);
 }
 
-class MockClientCommandBufferCanFail : public MockClientCommandBuffer {
+TEST_F(TransferBufferTest, Flush) {
+  Initialize(16u);
+  unsigned int size_allocated = 0;
+  for (int i = 0; i < 8; ++i) {
+    void* ptr = transfer_buffer_->AllocUpTo(8u, &size_allocated);
+    ASSERT_TRUE(ptr != NULL);
+    EXPECT_EQ(8u, size_allocated);
+    if (i % 2) {
+      EXPECT_CALL(*command_buffer(), Flush(_))
+          .Times(1)
+          .RetiresOnSaturation();
+    }
+    transfer_buffer_->FreePendingToken(ptr, 1);
+  }
+  for (int i = 0; i < 8; ++i) {
+    void* ptr = transfer_buffer_->Alloc(8u);
+    ASSERT_TRUE(ptr != NULL);
+    if (i % 2) {
+      EXPECT_CALL(*command_buffer(), Flush(_))
+          .Times(1)
+          .RetiresOnSaturation();
+    }
+    transfer_buffer_->FreePendingToken(ptr, 1);
+  }
+}
+
+class MockClientCommandBufferCanFail : public MockClientCommandBufferMockFlush {
  public:
   MockClientCommandBufferCanFail() {
   }
   virtual ~MockClientCommandBufferCanFail() {
   }
 
   MOCK_METHOD2(CreateTransferBuffer, int32(size_t size, int32 id_request));
 
   int32 RealCreateTransferBuffer(size_t size, int32 id_request) {
     return MockCommandBufferBase::CreateTransferBuffer(size, id_request);
@@ skipping 50 matching lines @@
           command_buffer(),
           &MockClientCommandBufferCanFail::RealCreateTransferBuffer))
       .RetiresOnSaturation();
 
   transfer_buffer_.reset(new TransferBuffer(helper_.get()));
   ASSERT_TRUE(transfer_buffer_->Initialize(
       kStartTransferBufferSize,
       kStartingOffset,
       kMinTransferBufferSize,
       kMaxTransferBufferSize,
-      kAlignment));
+      kAlignment,
+      0));
 }
 
 void TransferBufferExpandContractTest::TearDown() {
   if (transfer_buffer_->HaveBuffer()) {
     EXPECT_CALL(*command_buffer(), OnFlush())
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
         .Times(1)
         .RetiresOnSaturation();
@@ skipping 153 matching lines @@
       .WillOnce(Return(-1))
       .RetiresOnSaturation();
 
   const size_t kSize1 = 512 - kStartingOffset;
   unsigned int size_allocated = 0;
   void* ptr = transfer_buffer_->AllocUpTo(kSize1, &size_allocated);
   ASSERT_TRUE(ptr == NULL);
   EXPECT_FALSE(transfer_buffer_->HaveBuffer());
 }
 
+
 }  // namespace gpu