Switch to standard integer types in gpu/.

gpu/command_buffer/client/vertex_array_object_manager_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.
 
 #include "gpu/command_buffer/client/vertex_array_object_manager.h"
 
 #include <GLES2/gl2ext.h>
 #include <GLES3/gl3.h>
+#include <stddef.h>
+#include <stdint.h>
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 namespace gles2 {
 
 class VertexArrayObjectManagerTest : public testing::Test {
  protected:
   static const GLuint kMaxAttribs = 4;
   static const GLuint kClientSideArrayBuffer = 0x1234;
   static const GLuint kClientSideElementArrayBuffer = 0x1235;
@@ skipping 14 matching lines @@
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const GLuint VertexArrayObjectManagerTest::kMaxAttribs;
 const GLuint VertexArrayObjectManagerTest::kClientSideArrayBuffer;
 const GLuint VertexArrayObjectManagerTest::kClientSideElementArrayBuffer;
 #endif
 
 TEST_F(VertexArrayObjectManagerTest, Basic) {
   EXPECT_FALSE(manager_->HaveEnabledClientSideBuffers());
   // Check out of bounds access.
-  uint32 param;
+  uint32_t param;
   void* ptr;
   EXPECT_FALSE(manager_->GetVertexAttrib(
       kMaxAttribs, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &param));
   EXPECT_FALSE(manager_->GetAttribPointer(
       kMaxAttribs, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr));
   // Check defaults.
   for (GLuint ii = 0; ii < kMaxAttribs; ++ii) {
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &param));
     EXPECT_EQ(0u, param);
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &param));
     EXPECT_EQ(0u, param);
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_SIZE, &param));
     EXPECT_EQ(4u, param);
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_TYPE, &param));
-    EXPECT_EQ(static_cast<uint32>(GL_FLOAT), param);
+    EXPECT_EQ(static_cast<uint32_t>(GL_FLOAT), param);
     EXPECT_TRUE(manager_->GetVertexAttrib(
         ii, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &param));
     EXPECT_EQ(0u, param);
     EXPECT_TRUE(manager_->GetAttribPointer(
         ii, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr));
     EXPECT_TRUE(NULL == ptr);
   }
 }
 
 TEST_F(VertexArrayObjectManagerTest, UnbindBuffer) {
@@ skipping 20 matching lines @@
     manager_->BindElementArray(kElementArray);
   }
   EXPECT_FALSE(manager_->HaveEnabledClientSideBuffers());
   EXPECT_TRUE(manager_->BindVertexArray(ids[0], &changed));
   // Unbind the buffer.
   manager_->UnbindBuffer(kBufferToUnbind);
   manager_->UnbindBuffer(kElementArray);
   // The attribs are still enabled but their buffer is 0.
   EXPECT_TRUE(manager_->HaveEnabledClientSideBuffers());
   // Check the status of the bindings.
-  static const uint32 expected[][4] = {
-    { 0, kBufferToRemain, 0, kBufferToRemain, },
-    { kBufferToUnbind, kBufferToRemain, kBufferToUnbind, kBufferToRemain, },
+  static const uint32_t expected[][4] = {
+      {
+          0, kBufferToRemain, 0, kBufferToRemain,
+      },
+      {
+          kBufferToUnbind, kBufferToRemain, kBufferToUnbind, kBufferToRemain,
+      },
   };
   static const GLuint expected_element_array[] = {
     0, kElementArray,
   };
   for (size_t ii = 0; ii < arraysize(ids); ++ii) {
     EXPECT_TRUE(manager_->BindVertexArray(ids[ii], &changed));
     for (size_t jj = 0; jj < 4; ++jj) {
-      uint32 param = 1;
+      uint32_t param = 1;
       EXPECT_TRUE(manager_->GetVertexAttrib(
           jj, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &param));
       EXPECT_EQ(expected[ii][jj], param)
           << "id: " << ids[ii] << ", attrib: " << jj;
     }
     EXPECT_EQ(expected_element_array[ii],
               manager_->bound_element_array_buffer());
   }
 
   // The vao that was not bound still has all service side bufferws.
   EXPECT_FALSE(manager_->HaveEnabledClientSideBuffers());
 
   // Make sure unbinding 0 does not effect count incorrectly.
   EXPECT_TRUE(manager_->BindVertexArray(0, &changed));
   EXPECT_FALSE(manager_->HaveEnabledClientSideBuffers());
   manager_->SetAttribEnable(2, true);
   manager_->UnbindBuffer(0);
   manager_->SetAttribEnable(2, false);
   EXPECT_FALSE(manager_->HaveEnabledClientSideBuffers());
 }
 
 TEST_F(VertexArrayObjectManagerTest, GetSet) {
   const char* dummy = "dummy";
   const void* p = reinterpret_cast<const void*>(dummy);
   manager_->SetAttribEnable(1, true);
   manager_->SetAttribPointer(123, 1, 3, GL_BYTE, true, 3, p, GL_TRUE);
-  uint32 param;
+  uint32_t param;
   void* ptr;
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &param));
   EXPECT_EQ(123u, param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &param));
   EXPECT_NE(0u, param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_SIZE, &param));
   EXPECT_EQ(3u, param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_TYPE, &param));
-  EXPECT_EQ(static_cast<uint32>(GL_BYTE), param);
+  EXPECT_EQ(static_cast<uint32_t>(GL_BYTE), param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, &param));
   EXPECT_NE(0u, param);
   EXPECT_TRUE(manager_->GetVertexAttrib(
       1, GL_VERTEX_ATTRIB_ARRAY_INTEGER, &param));
   EXPECT_EQ(1u, param);
   EXPECT_TRUE(manager_->GetAttribPointer(
       1, GL_VERTEX_ATTRIB_ARRAY_POINTER, &ptr));
   EXPECT_EQ(p, ptr);
 
@@ skipping 94 matching lines @@
   EXPECT_TRUE(manager_->IsReservedId(kClientSideArrayBuffer));
   EXPECT_TRUE(manager_->IsReservedId(kClientSideElementArrayBuffer));
   EXPECT_FALSE(manager_->IsReservedId(0));
   EXPECT_FALSE(manager_->IsReservedId(1));
   EXPECT_FALSE(manager_->IsReservedId(2));
 }
 
 }  // namespace gles2
 }  // namespace gpu