Switch to standard integer types in gpu/.

gpu/command_buffer/client/cmd_buffer_helper_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.
 
 // Tests for the Command Buffer Helper.
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <list>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/macros.h"
 #include "base/memory/linked_ptr.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"
 
 namespace gpu {
 
 using testing::Return;
 using testing::Mock;
 using testing::Truly;
 using testing::Sequence;
 using testing::DoAll;
 using testing::Invoke;
 using testing::_;
 
-const int32 kTotalNumCommandEntries = 32;
-const int32 kCommandBufferSizeBytes =
+const int32_t kTotalNumCommandEntries = 32;
+const int32_t kCommandBufferSizeBytes =
     kTotalNumCommandEntries * sizeof(CommandBufferEntry);
-const int32 kUnusedCommandId = 5;  // we use 0 and 2 currently.
+const int32_t kUnusedCommandId = 5;  // we use 0 and 2 currently.
 
 // Override CommandBufferService::Flush() to lock flushing and simulate
 // the buffer becoming full in asynchronous mode.
 class CommandBufferServiceLocked : public CommandBufferService {
  public:
   explicit CommandBufferServiceLocked(
       TransferBufferManagerInterface* transfer_buffer_manager)
       : CommandBufferService(transfer_buffer_manager),
         flush_locked_(false),
         last_flush_(-1),
         previous_put_offset_(0),
         flush_count_(0) {}
   ~CommandBufferServiceLocked() override {}
 
   // Overridden from CommandBufferService
-  void Flush(int32 put_offset) override {
+  void Flush(int32_t put_offset) override {
     flush_count_++;
     if (!flush_locked_) {
       last_flush_ = -1;
       previous_put_offset_ = put_offset;
       CommandBufferService::Flush(put_offset);
     } else {
       last_flush_ = put_offset;
     }
   }
 
   void LockFlush() { flush_locked_ = true; }
 
   void UnlockFlush() { flush_locked_ = false; }
 
   int FlushCount() { return flush_count_; }
 
-  void WaitForGetOffsetInRange(int32 start, int32 end) override {
+  void WaitForGetOffsetInRange(int32_t start, int32_t end) override {
     // Flush only if it's required to unblock this Wait.
     if (last_flush_ != -1 &&
         !CommandBuffer::InRange(start, end, previous_put_offset_)) {
       previous_put_offset_ = last_flush_;
       CommandBufferService::Flush(last_flush_);
       last_flush_ = -1;
     }
     CommandBufferService::WaitForGetOffsetInRange(start, end);
   }
 
@@ skipping 45 matching lines @@
   virtual void TearDown() {
     // If the GpuScheduler posts any tasks, this forces them to run.
     base::MessageLoop::current()->RunUntilIdle();
     test_command_args_.clear();
   }
 
   const CommandParser* GetParser() const {
     return gpu_scheduler_->parser();
   }
 
-  int32 ImmediateEntryCount() const { return helper_->immediate_entry_count_; }
+  int32_t ImmediateEntryCount() const {
+    return helper_->immediate_entry_count_;
+  }
 
   // Adds a command to the buffer through the helper, while adding it as an
   // expected call on the API mock.
   void AddCommandWithExpect(error::Error _return,
                             unsigned int command,
                             int arg_count,
                             CommandBufferEntry *args) {
     CommandHeader header;
     header.size = arg_count + 1;
     header.command = command;
@@ skipping 13 matching lines @@
 
   void AddUniqueCommandWithExpect(error::Error _return, int cmd_size) {
     EXPECT_GE(cmd_size, 1);
     EXPECT_LT(cmd_size, kTotalNumCommandEntries);
     int arg_count = cmd_size - 1;
 
     // Allocate array for args.
     linked_ptr<std::vector<CommandBufferEntry> > args_ptr(
         new std::vector<CommandBufferEntry>(arg_count ? arg_count : 1));
 
-    for (int32 ii = 0; ii < arg_count; ++ii) {
+    for (int32_t ii = 0; ii < arg_count; ++ii) {
       (*args_ptr)[ii].value_uint32 = 0xF00DF00D + ii;
     }
 
     // Add command and save args in test_command_args_ until the test completes.
     AddCommandWithExpect(
         _return, test_command_next_id_++, arg_count, &(*args_ptr)[0]);
     test_command_args_.insert(test_command_args_.end(), args_ptr);
   }
 
-  void TestCommandWrappingFull(int32 cmd_size, int32 start_commands) {
-    const int32 num_args = cmd_size - 1;
+  void TestCommandWrappingFull(int32_t cmd_size, int32_t start_commands) {
+    const int32_t num_args = cmd_size - 1;
     EXPECT_EQ(kTotalNumCommandEntries % cmd_size, 0);
 
     std::vector<CommandBufferEntry> args(num_args);
-    for (int32 ii = 0; ii < num_args; ++ii) {
+    for (int32_t ii = 0; ii < num_args; ++ii) {
       args[ii].value_uint32 = ii + 1;
     }
 
     // Initially insert commands up to start_commands and Finish().
-    for (int32 ii = 0; ii < start_commands; ++ii) {
+    for (int32_t ii = 0; ii < start_commands; ++ii) {
       AddCommandWithExpect(
           error::kNoError, ii + kUnusedCommandId, num_args, &args[0]);
     }
     helper_->Finish();
 
     EXPECT_EQ(GetParser()->put(),
               (start_commands * cmd_size) % kTotalNumCommandEntries);
     EXPECT_EQ(GetParser()->get(),
               (start_commands * cmd_size) % kTotalNumCommandEntries);
 
     // Lock flushing to force the buffer to get full.
     command_buffer_->LockFlush();
 
     // Add enough commands to over fill the buffer.
-    for (int32 ii = 0; ii < kTotalNumCommandEntries / cmd_size + 2; ++ii) {
+    for (int32_t ii = 0; ii < kTotalNumCommandEntries / cmd_size + 2; ++ii) {
       AddCommandWithExpect(error::kNoError,
                            start_commands + ii + kUnusedCommandId,
                            num_args,
                            &args[0]);
     }
 
     // Flush all commands.
     command_buffer_->UnlockFlush();
     helper_->Finish();
 
@@ skipping 20 matching lines @@
       if (put >= parser_put) {
         // we're on the top side, check we are below the limit.
         EXPECT_GE(kTotalNumCommandEntries, limit);
       } else {
         // we're on the bottom side, check we are below get.
         EXPECT_GT(parser_get, limit);
       }
     }
   }
 
-  int32 GetGetOffset() {
-    return command_buffer_->GetLastState().get_offset;
-  }
+  int32_t GetGetOffset() { return command_buffer_->GetLastState().get_offset; }
 
-  int32 GetPutOffset() {
-    return command_buffer_->GetPutOffset();
-  }
+  int32_t GetPutOffset() { return command_buffer_->GetPutOffset(); }
 
-  int32 GetHelperGetOffset() { return helper_->get_offset(); }
+  int32_t GetHelperGetOffset() { return helper_->get_offset(); }
 
-  int32 GetHelperPutOffset() { return helper_->put_; }
+  int32_t GetHelperPutOffset() { return helper_->put_; }
 
-  uint32 GetHelperFlushGeneration() { return helper_->flush_generation(); }
+  uint32_t GetHelperFlushGeneration() { return helper_->flush_generation(); }
 
   error::Error GetError() {
     return command_buffer_->GetLastState().error;
   }
 
   CommandBufferOffset get_helper_put() { return helper_->put_; }
 
   scoped_ptr<AsyncAPIMock> api_mock_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<CommandBufferServiceLocked> command_buffer_;
@@ skipping 221 matching lines @@
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock_.get());
 
   // Check the error status.
   EXPECT_EQ(error::kNoError, GetError());
 }
 
 // Checks the case where the command inserted exactly matches the space left in
 // the command buffer.
 TEST_F(CommandBufferHelperTest, TestCommandWrappingExactMultiple) {
-  const int32 kCommandSize = kTotalNumCommandEntries / 2;
+  const int32_t kCommandSize = kTotalNumCommandEntries / 2;
   const size_t kNumArgs = kCommandSize - 1;
   static_assert(kTotalNumCommandEntries % kCommandSize == 0,
                 "kTotalNumCommandEntries should be a multiple of kCommandSize");
   CommandBufferEntry args1[kNumArgs];
   for (size_t ii = 0; ii < kNumArgs; ++ii) {
     args1[ii].value_uint32 = ii + 1;
   }
 
   for (unsigned int i = 0; i < 5; ++i) {
     AddCommandWithExpect(
@@ skipping 59 matching lines @@
 // Checks that the InsertToken/WaitForToken work.
 TEST_F(CommandBufferHelperTest, TestToken) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Add a first command.
   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 3, 2, args);
   // keep track of the buffer position.
   CommandBufferOffset command1_put = get_helper_put();
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
 
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
                       Return(error::kNoError)));
   // Add another command.
   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 4, 2, args);
   helper_->WaitForToken(token);
   // check that the get pointer is beyond the first command.
   EXPECT_LE(command1_put, GetGetOffset());
   helper_->Finish();
 
   // Check that the commands did happen.
   Mock::VerifyAndClearExpectations(api_mock_.get());
 
   // Check the error status.
   EXPECT_EQ(error::kNoError, GetError());
 }
 
 // Checks WaitForToken doesn't Flush if token is already read.
 TEST_F(CommandBufferHelperTest, TestWaitForTokenFlush) {
   CommandBufferEntry args[2];
   args[0].value_uint32 = 3;
   args[1].value_float = 4.f;
 
   // Add a first command.
   AddCommandWithExpect(error::kNoError, kUnusedCommandId + 3, 2, args);
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
 
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
                       Return(error::kNoError)));
 
   int flush_count = command_buffer_->FlushCount();
 
   // Test that waiting for pending token causes a Flush.
   helper_->WaitForToken(token);
   EXPECT_EQ(command_buffer_->FlushCount(), flush_count + 1);
@@ skipping 19 matching lines @@
 }
 
 TEST_F(CommandBufferHelperTest, FreeRingBuffer) {
   EXPECT_TRUE(helper_->HaveRingBuffer());
 
   // Test freeing ring buffer.
   helper_->FreeRingBuffer();
   EXPECT_FALSE(helper_->HaveRingBuffer());
 
   // Test that InsertToken allocates a new one
-  int32 token = helper_->InsertToken();
+  int32_t token = helper_->InsertToken();
   EXPECT_TRUE(helper_->HaveRingBuffer());
   EXPECT_CALL(*api_mock_.get(), DoCommand(cmd::kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
                       Return(error::kNoError)));
   helper_->WaitForToken(token);
   helper_->FreeRingBuffer();
   EXPECT_FALSE(helper_->HaveRingBuffer());
 
   // Test that WaitForAvailableEntries allocates a new one
   AddCommandWithExpect(error::kNoError, kUnusedCommandId, 0, NULL);
@@ skipping 20 matching lines @@
   command_buffer_->SetParseError(error::kGenericError);
   EXPECT_TRUE(helper_->IsContextLost());
 }
 
 // Checks helper's 'flush generation' updates.
 TEST_F(CommandBufferHelperTest, TestFlushGeneration) {
   // Explicit flushing only.
   helper_->SetAutomaticFlushes(false);
 
   // Generation should change after Flush() but not before.
-  uint32 gen1, gen2, gen3;
+  uint32_t gen1, gen2, gen3;
 
   gen1 = GetHelperFlushGeneration();
   AddUniqueCommandWithExpect(error::kNoError, 2);
   gen2 = GetHelperFlushGeneration();
   helper_->Flush();
   gen3 = GetHelperFlushGeneration();
   EXPECT_EQ(gen2, gen1);
   EXPECT_NE(gen3, gen2);
 
   // Generation should change after Finish() but not before.
@@ skipping 12 matching lines @@
 
   // Check the error status.
   EXPECT_EQ(error::kNoError, GetError());
 }
 
 TEST_F(CommandBufferHelperTest, TestOrderingBarrierFlushGeneration) {
   // Explicit flushing only.
   helper_->SetAutomaticFlushes(false);
 
   // Generation should change after OrderingBarrier() but not before.
-  uint32 gen1, gen2, gen3;
+  uint32_t gen1, gen2, gen3;
 
   gen1 = GetHelperFlushGeneration();
   AddUniqueCommandWithExpect(error::kNoError, 2);
   gen2 = GetHelperFlushGeneration();
   helper_->OrderingBarrier();
   gen3 = GetHelperFlushGeneration();
   EXPECT_EQ(gen2, gen1);
   EXPECT_NE(gen3, gen2);
 
   helper_->Finish();
@@ skipping 35 matching lines @@
   helper_->OrderingBarrier();
   flush_count2 = command_buffer_->FlushCount();
   helper_->OrderingBarrier();
   flush_count3 = command_buffer_->FlushCount();
 
   EXPECT_EQ(flush_count2, flush_count1 + 1);
   EXPECT_EQ(flush_count3, flush_count2 + 1);
 }
 
 }  // namespace gpu