Redesigned CommandBuffer and NPDevice3D interfaces

gpu/command_buffer/client/fenced_allocator_test.cc

 // Copyright (c) 2009 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/at_exit.h"
 #include "base/message_loop.h"
 #include "gpu/command_buffer/client/cmd_buffer_helper.h"
 #include "gpu/command_buffer/client/fenced_allocator.h"
@@ skipping 43 matching lines @@
         command_buffer_.get(), NULL, parser_, INT_MAX));
     command_buffer_->SetPutOffsetChangeCallback(NewCallback(
         gpu_processor.get(), &GPUProcessor::ProcessCommands));
 
     api_mock_->set_engine(gpu_processor.get());
 
     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
     helper_->Initialize();
   }
 
+  int32 GetToken() {
+    return command_buffer_->GetState().token;
+  }
+
   virtual void TearDown() {
     helper_.release();
   }
 
   base::AtExitManager at_exit_manager_;
   MessageLoop message_loop_;
   scoped_ptr<AsyncAPIMock> api_mock_;
   scoped_ptr<CommandBufferService> command_buffer_;
   CommandParser* parser_;
   scoped_ptr<CommandBufferHelper> helper_;
@@ skipping 106 matching lines @@
   EXPECT_TRUE(allocator_->CheckConsistency());
 
   // Free one successful allocation, pending fence.
   int32 token = helper_.get()->InsertToken();
   allocator_->FreePendingToken(offsets[0], token);
   EXPECT_TRUE(allocator_->CheckConsistency());
 
   // The way we hooked up the helper and engine, it won't process commands
   // until it has to wait for something. Which means the token shouldn't have
   // passed yet at this point.
-  EXPECT_GT(token, command_buffer_->GetToken());
+  EXPECT_GT(token, GetToken());
 
   // This allocation will need to reclaim the space freed above, so that should
   // process the commands until the token is passed.
   offsets[0] = allocator_->Alloc(kSize);
   EXPECT_NE(FencedAllocator::kInvalidOffset, offsets[0]);
   EXPECT_GE(kBufferSize, offsets[0]+kSize);
   EXPECT_TRUE(allocator_->CheckConsistency());
   // Check that the token has indeed passed.
-  EXPECT_LE(token, command_buffer_->GetToken());
+  EXPECT_LE(token, GetToken());
 
   // Free up everything.
   for (unsigned int i = 0; i < kAllocCount; ++i) {
     allocator_->Free(offsets[i]);
     EXPECT_TRUE(allocator_->CheckConsistency());
   }
 }
 
 // Tests GetLargestFreeSize
 TEST_F(FencedAllocatorTest, TestGetLargestFreeSize) {
@@ skipping 75 matching lines @@
 
   // Now all the buffers have been freed...
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
   // .. but one is still waiting for the token.
   EXPECT_EQ(kBufferSize - 3 * kSize,
             allocator_->GetLargestFreeSize());
 
   // The way we hooked up the helper and engine, it won't process commands
   // until it has to wait for something. Which means the token shouldn't have
   // passed yet at this point.
-  EXPECT_GT(token, command_buffer_->GetToken());
+  EXPECT_GT(token, GetToken());
   // This allocation will need to reclaim the space freed above, so that should
   // process the commands until the token is passed, but it will succeed.
   offset = allocator_->Alloc(kBufferSize);
   ASSERT_NE(FencedAllocator::kInvalidOffset, offset);
   // Check that the token has indeed passed.
-  EXPECT_LE(token, command_buffer_->GetToken());
+  EXPECT_LE(token, GetToken());
   allocator_->Free(offset);
 
   // Everything now has been freed...
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeOrPendingSize());
   // ... for real.
   EXPECT_EQ(kBufferSize, allocator_->GetLargestFreeSize());
 }
 
 // Test fixture for FencedAllocatorWrapper test - Creates a
 // FencedAllocatorWrapper, using a CommandBufferHelper with a mock
@@ skipping 124 matching lines @@
   EXPECT_TRUE(allocator_->CheckConsistency());
 
   // Free one successful allocation, pending fence.
   int32 token = helper_.get()->InsertToken();
   allocator_->FreePendingToken(pointers[0], token);
   EXPECT_TRUE(allocator_->CheckConsistency());
 
   // The way we hooked up the helper and engine, it won't process commands
   // until it has to wait for something. Which means the token shouldn't have
   // passed yet at this point.
-  EXPECT_GT(token, command_buffer_->GetToken());
+  EXPECT_GT(token, GetToken());
 
   // This allocation will need to reclaim the space freed above, so that should
   // process the commands until the token is passed.
   pointers[0] = allocator_->Alloc(kSize);
   EXPECT_TRUE(pointers[0]);
   EXPECT_TRUE(allocator_->CheckConsistency());
   // Check that the token has indeed passed.
-  EXPECT_LE(token, command_buffer_->GetToken());
+  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