Switch to standard integer types in gpu/.

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 <stddef.h>
+#include <stdint.h>
+
 #include "base/compiler_specific.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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::StrictMock;
 
 namespace gpu {
 
 
 class TransferBufferTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t 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) {
   }
 
   void SetUp() override;
   void TearDown() override;
 
   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<MockClientCommandBufferMockFlush> command_buffer_;
   scoped_ptr<CommandBufferHelper> helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
-  int32 transfer_buffer_id_;
+  int32_t transfer_buffer_id_;
 };
 
 void TransferBufferTest::SetUp() {
   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();
@@ skipping 11 matching lines @@
   EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*command_buffer(), OnFlush()).Times(AtMost(1));
   EXPECT_CALL(*command_buffer(), Flush(_)).Times(AtMost(1));
   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 int32_t TransferBufferTest::kNumCommandEntries;
+const int32_t 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(
@@ skipping 117 matching lines @@
 }
 
 class MockClientCommandBufferCanFail : public MockClientCommandBufferMockFlush {
  public:
   MockClientCommandBufferCanFail() {
   }
   virtual ~MockClientCommandBufferCanFail() {
   }
 
   MOCK_METHOD2(CreateTransferBuffer,
-               scoped_refptr<Buffer>(size_t size, int32* id));
+               scoped_refptr<Buffer>(size_t size, int32_t* id));
 
-  scoped_refptr<gpu::Buffer> RealCreateTransferBuffer(size_t size, int32* id) {
+  scoped_refptr<gpu::Buffer> RealCreateTransferBuffer(size_t size,
+                                                      int32_t* id) {
     return MockCommandBufferBase::CreateTransferBuffer(size, id);
   }
 };
 
 class TransferBufferExpandContractTest : public testing::Test {
  protected:
-  static const int32 kNumCommandEntries = 400;
-  static const int32 kCommandBufferSizeBytes =
+  static const int32_t kNumCommandEntries = 400;
+  static const int32_t kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const unsigned int kStartingOffset = 64;
   static const unsigned int kAlignment = 4;
   static const size_t kStartTransferBufferSize = 256;
   static const size_t kMaxTransferBufferSize = 1024;
   static const size_t kMinTransferBufferSize = 128;
 
   TransferBufferExpandContractTest()
       : transfer_buffer_id_(0) {
   }
 
   void SetUp() override;
   void TearDown() override;
 
   MockClientCommandBufferCanFail* command_buffer() const {
     return command_buffer_.get();
   }
 
   scoped_ptr<MockClientCommandBufferCanFail> command_buffer_;
   scoped_ptr<CommandBufferHelper> helper_;
   scoped_ptr<TransferBuffer> transfer_buffer_;
-  int32 transfer_buffer_id_;
+  int32_t transfer_buffer_id_;
 };
 
 void TransferBufferExpandContractTest::SetUp() {
   command_buffer_.reset(new StrictMock<MockClientCommandBufferCanFail>());
   ASSERT_TRUE(command_buffer_->Initialize());
 
   EXPECT_CALL(*command_buffer(),
               CreateTransferBuffer(kCommandBufferSizeBytes, _))
       .WillOnce(Invoke(
           command_buffer(),
@@ skipping 30 matching lines @@
   }
   // For command buffer.
   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 TransferBufferExpandContractTest::kNumCommandEntries;
-const int32 TransferBufferExpandContractTest::kCommandBufferSizeBytes;
+const int32_t TransferBufferExpandContractTest::kNumCommandEntries;
+const int32_t TransferBufferExpandContractTest::kCommandBufferSizeBytes;
 const unsigned int TransferBufferExpandContractTest::kStartingOffset;
 const unsigned int TransferBufferExpandContractTest::kAlignment;
 const size_t TransferBufferExpandContractTest::kStartTransferBufferSize;
 const size_t TransferBufferExpandContractTest::kMaxTransferBufferSize;
 const size_t TransferBufferExpandContractTest::kMinTransferBufferSize;
 #endif
 
 TEST_F(TransferBufferExpandContractTest, Expand) {
   // Check it starts at starting size.
   EXPECT_EQ(
@@ skipping 152 matching lines @@
 
   // Check it's the default size.
   EXPECT_EQ(
       kStartTransferBufferSize - kStartingOffset,
       transfer_buffer_->GetCurrentMaxAllocationWithoutRealloc());
 }
 
 }  // namespace gpu