Switch to standard integer types in gpu/.

gpu/command_buffer/client/vertex_array_object_manager.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 <stddef.h>
+#include <stdint.h>
+
 #include "base/logging.h"
+#include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 namespace gpu {
 namespace gles2 {
 
 static GLsizei RoundUpToMultipleOf4(GLsizei size) {
   return (size + 3) & ~3;
 }
 
@@ skipping 141 matching lines @@
 
   bool HaveEnabledClientSideBuffers() const;
 
   void SetAttribEnable(GLuint index, bool enabled);
 
   void SetAttribPointer(
     GLuint buffer_id,
     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
     const void* ptr, GLboolean integer);
 
-  bool GetVertexAttrib(
-      GLuint index, GLenum pname, uint32* param) const;
+  bool GetVertexAttrib(GLuint index, GLenum pname, uint32_t* param) const;
 
   void SetAttribDivisor(GLuint index, GLuint divisor);
 
   bool GetAttribPointer(GLuint index, GLenum pname, void** ptr) const;
 
   const VertexAttribs& vertex_attribs() const {
     return vertex_attribs_;
   }
 
   GLuint bound_element_array_buffer() const {
@@ skipping 78 matching lines @@
     }
 
     attrib.SetInfo(buffer_id, size, type, normalized, stride, ptr, integer);
 
     if (attrib.IsClientSide() && attrib.enabled()) {
       ++num_client_side_pointers_enabled_;
     }
   }
 }
 
-bool VertexArrayObject::GetVertexAttrib(
-    GLuint index, GLenum pname, uint32* param) const {
+bool VertexArrayObject::GetVertexAttrib(GLuint index,
+                                        GLenum pname,
+                                        uint32_t* param) const {
   const VertexAttrib* attrib = GetAttrib(index);
   if (!attrib) {
     return false;
   }
 
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
       *param = attrib->buffer_id();
       break;
     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
@@ skipping 136 matching lines @@
 }
 
 bool VertexArrayObjectManager::HaveEnabledClientSideBuffers() const {
   return bound_vertex_array_object_->HaveEnabledClientSideBuffers();
 }
 
 void VertexArrayObjectManager::SetAttribEnable(GLuint index, bool enabled) {
   bound_vertex_array_object_->SetAttribEnable(index, enabled);
 }
 
-bool VertexArrayObjectManager::GetVertexAttrib(
-    GLuint index, GLenum pname, uint32* param) {
+bool VertexArrayObjectManager::GetVertexAttrib(GLuint index,
+                                               GLenum pname,
+                                               uint32_t* param) {
   return bound_vertex_array_object_->GetVertexAttrib(index, pname, param);
 }
 
 bool VertexArrayObjectManager::GetAttribPointer(
     GLuint index, GLenum pname, void** ptr) const {
   return bound_vertex_array_object_->GetAttribPointer(index, pname, ptr);
 }
 
 bool VertexArrayObjectManager::SetAttribPointer(
     GLuint buffer_id,
@@ skipping 19 matching lines @@
 
 // Collects the data into the collection buffer and returns the number of
 // bytes collected.
 GLsizei VertexArrayObjectManager::CollectData(
     const void* data,
     GLsizei bytes_per_element,
     GLsizei real_stride,
     GLsizei num_elements) {
   GLsizei bytes_needed = bytes_per_element * num_elements;
   if (collection_buffer_size_ < bytes_needed) {
-    collection_buffer_.reset(new int8[bytes_needed]);
+    collection_buffer_.reset(new int8_t[bytes_needed]);
     collection_buffer_size_ = bytes_needed;
   }
-  const int8* src = static_cast<const int8*>(data);
-  int8* dst = collection_buffer_.get();
-  int8* end = dst + bytes_per_element * num_elements;
+  const int8_t* src = static_cast<const int8_t*>(data);
+  int8_t* dst = collection_buffer_.get();
+  int8_t* end = dst + bytes_per_element * num_elements;
   for (; dst < end; src += real_stride, dst += bytes_per_element) {
     memcpy(dst, src, bytes_per_element);
   }
   return bytes_needed;
 }
 
 bool VertexArrayObjectManager::IsDefaultVAOBound() const {
   return bound_vertex_array_object_ == default_vertex_array_object_;
 }
 
@@ skipping 79 matching lines @@
   *offset = ToGLuint(indices);
   if (!support_client_side_arrays_)
     return true;
   GLsizei num_elements = 0;
   if (bound_vertex_array_object_->bound_element_array_buffer() == 0) {
     *simulated = true;
     *offset = 0;
     GLsizei max_index = -1;
     switch (type) {
       case GL_UNSIGNED_BYTE: {
-        const uint8* src = static_cast<const uint8*>(indices);
+        const uint8_t* src = static_cast<const uint8_t*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           if (src[ii] > max_index) {
             max_index = src[ii];
           }
         }
         break;
       }
       case GL_UNSIGNED_SHORT: {
-        const uint16* src = static_cast<const uint16*>(indices);
+        const uint16_t* src = static_cast<const uint16_t*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           if (src[ii] > max_index) {
             max_index = src[ii];
           }
         }
         break;
       }
       case GL_UNSIGNED_INT: {
-        uint32 max_glsizei = static_cast<uint32>(
-            std::numeric_limits<GLsizei>::max());
-        const uint32* src = static_cast<const uint32*>(indices);
+        uint32_t max_glsizei =
+            static_cast<uint32_t>(std::numeric_limits<GLsizei>::max());
+        const uint32_t* src = static_cast<const uint32_t*>(indices);
         for (GLsizei ii = 0; ii < count; ++ii) {
           // Other parts of the API use GLsizei (signed) to store limits.
           // As such, if we encounter a index that cannot be represented with
           // an unsigned int we need to flag it as an error here.
           if(src[ii] > max_glsizei) {
             gl->SetGLError(
                 GL_INVALID_OPERATION, function_name, "index too large.");
             return false;
           }
           GLsizei signed_index = static_cast<GLsizei>(src[ii]);
@@ skipping 34 matching lines @@
       function_name, gl, gl_helper, num_elements, primcount,
       &simulated_client_side_buffers);
   *simulated = *simulated || simulated_client_side_buffers;
   return true;
 }
 
 }  // namespace gles2
 }  // namespace gpu