Switch to standard integer types in gpu/.

gpu/command_buffer/common/gles2_cmd_utils.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.
 
 // This file is here so other GLES2 related files can have a common set of
 // includes where appropriate.
 
 #include <sstream>
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 483 matching lines @@
     case GL_UNSIGNED_BYTE:
     case GL_BYTE:
        return 1;
     default:
        return 0;
   }
 }
 
 }  // anonymous namespace
 
-uint32 GLES2Util::ComputeImageGroupSize(int format, int type) {
+uint32_t GLES2Util::ComputeImageGroupSize(int format, int type) {
   int bytes_per_element = BytesPerElement(type);
   DCHECK_GE(8, bytes_per_element);
   int elements_per_group = ElementsPerGroup(format, type);
   DCHECK_GE(4, elements_per_group);
   return  bytes_per_element * elements_per_group;
 }
 
-bool GLES2Util::ComputeImageRowSizeHelper(
-    int width, uint32 bytes_per_group, int alignment,
-    uint32* rt_unpadded_row_size, uint32* rt_padded_row_size) {
+bool GLES2Util::ComputeImageRowSizeHelper(int width,
+                                          uint32_t bytes_per_group,
+                                          int alignment,
+                                          uint32_t* rt_unpadded_row_size,
+                                          uint32_t* rt_padded_row_size) {
   DCHECK(alignment == 1 || alignment == 2 ||
          alignment == 4 || alignment == 8);
-  uint32 unpadded_row_size;
+  uint32_t unpadded_row_size;
   if (!SafeMultiplyUint32(width, bytes_per_group, &unpadded_row_size)) {
     return false;
   }
-  uint32 temp;
+  uint32_t temp;
   if (!SafeAddUint32(unpadded_row_size, alignment - 1, &temp)) {
     return false;
   }
-  uint32 padded_row_size = (temp / alignment) * alignment;
+  uint32_t padded_row_size = (temp / alignment) * alignment;
   if (rt_unpadded_row_size)
     *rt_unpadded_row_size = unpadded_row_size;
   if (rt_padded_row_size)
     *rt_padded_row_size = padded_row_size;
   return true;
 }
 
-bool GLES2Util::ComputeImagePaddedRowSize(
-    int width, int format, int type, int alignment, uint32* padded_row_size) {
-  uint32 bytes_per_group = ComputeImageGroupSize(format, type);
+bool GLES2Util::ComputeImagePaddedRowSize(int width,
+                                          int format,
+                                          int type,
+                                          int alignment,
+                                          uint32_t* padded_row_size) {
+  uint32_t bytes_per_group = ComputeImageGroupSize(format, type);
   return ComputeImageRowSizeHelper(
       width, bytes_per_group, alignment, nullptr, padded_row_size);
 }
 
 // Returns the amount of data glTexImage*D or glTexSubImage*D will access.
-bool GLES2Util::ComputeImageDataSizes(
-    int width, int height, int depth, int format, int type,
-    int alignment, uint32* size, uint32* opt_unpadded_row_size,
-    uint32* opt_padded_row_size) {
+bool GLES2Util::ComputeImageDataSizes(int width,
+                                      int height,
+                                      int depth,
+                                      int format,
+                                      int type,
+                                      int alignment,
+                                      uint32_t* size,
+                                      uint32_t* opt_unpadded_row_size,
+                                      uint32_t* opt_padded_row_size) {
   PixelStoreParams params;
   params.alignment = alignment;
   return ComputeImageDataSizesES3(
       width, height, depth, format, type, params,
       size, opt_unpadded_row_size, opt_padded_row_size, nullptr);
 }
 
 bool GLES2Util::ComputeImageDataSizesES3(
     int width, int height, int depth, int format, int type,
     const PixelStoreParams& params,
     uint32_t* size, uint32_t* opt_unpadded_row_size,
     uint32_t* opt_padded_row_size, uint32_t* opt_skip_size) {
   DCHECK(width >= 0 && height >= 0 && depth >= 0);
 
-  uint32 bytes_per_group = ComputeImageGroupSize(format, type);
+  uint32_t bytes_per_group = ComputeImageGroupSize(format, type);
 
-  uint32 unpadded_row_size;
-  uint32 padded_row_size;
+  uint32_t unpadded_row_size;
+  uint32_t padded_row_size;
   if (!ComputeImageRowSizeHelper(width, bytes_per_group, params.alignment,
                                  &unpadded_row_size, &padded_row_size)) {
     return false;
   }
   if (params.row_length > 0 &&
       !ComputeImageRowSizeHelper(params.row_length, bytes_per_group,
                                  params.alignment, nullptr, &padded_row_size)) {
     // Here we re-compute the padded_row_size, but the unpadded_row_size
     // isn't affected. That is, the last row isn't affected by ROW_LENGTH.
     return false;
   }
 
   int image_height = params.image_height > 0 ? params.image_height : height;
-  uint32 num_of_rows;
+  uint32_t num_of_rows;
   if (depth > 0) {
     if (!SafeMultiplyUint32(image_height, depth - 1, &num_of_rows) ||
         !SafeAddUint32(num_of_rows, height, &num_of_rows)) {
       return false;
     }
   } else {
     num_of_rows = 0;
   }
 
   if (num_of_rows > 0) {
-    uint32 size_of_all_but_last_row;
+    uint32_t size_of_all_but_last_row;
     if (!SafeMultiplyUint32((num_of_rows - 1), padded_row_size,
                             &size_of_all_but_last_row)) {
       return false;
     }
     if (!SafeAddUint32(size_of_all_but_last_row, unpadded_row_size, size)) {
       return false;
     }
   } else {
     *size = 0;
   }
 
-  uint32 skip_size = 0;
+  uint32_t skip_size = 0;
   if (params.skip_images > 0) {
-    uint32 image_size;
+    uint32_t image_size;
     if (!SafeMultiplyUint32(image_height, padded_row_size, &image_size))
       return false;
     if (!SafeMultiplyUint32(image_size, params.skip_images, &skip_size))
       return false;
   }
   if (params.skip_rows > 0) {
-    uint32 temp;
+    uint32_t temp;
     if (!SafeMultiplyUint32(padded_row_size, params.skip_rows, &temp))
       return false;
     if (!SafeAddUint32(skip_size, temp, &skip_size))
       return false;
   }
   if (params.skip_pixels > 0) {
-    uint32 temp;
+    uint32_t temp;
     if (!SafeMultiplyUint32(bytes_per_group, params.skip_pixels, &temp))
       return false;
     if (!SafeAddUint32(skip_size, temp, &skip_size))
       return false;
   }
-  uint32 total_size;
+  uint32_t total_size;
   if (!SafeAddUint32(*size, skip_size, &total_size))
     return false;
 
   if (opt_padded_row_size) {
     *opt_padded_row_size = padded_row_size;
   }
   if (opt_unpadded_row_size) {
     *opt_unpadded_row_size = unpadded_row_size;
   }
   if (opt_skip_size)
@@ skipping 15 matching lines @@
     case GL_DEPTH24_STENCIL8_OES:
     case GL_RGB8_OES:
     case GL_RGBA8_OES:
     case GL_DEPTH_COMPONENT24_OES:
       return 4;
     default:
       return 0;
   }
 }
 
-uint32 GLES2Util::GetElementSizeForUniformType(int type) {
+uint32_t GLES2Util::GetElementSizeForUniformType(int type) {
   switch (type) {
     case GL_FLOAT:
     case GL_FLOAT_VEC2:
     case GL_FLOAT_VEC3:
     case GL_FLOAT_VEC4:
     case GL_FLOAT_MAT2:
     case GL_FLOAT_MAT3:
     case GL_FLOAT_MAT4:
       return sizeof(GLfloat);
     case GL_INT:
@@ skipping 36 matching lines @@
     case GL_FLOAT_MAT4x2:
     case GL_FLOAT_MAT3x4:
     case GL_FLOAT_MAT4x3:
       return sizeof(GLfloat);
 
     default:
       return 0;
   }
 }
 
-uint32 GLES2Util::GetElementCountForUniformType(int type) {
+uint32_t GLES2Util::GetElementCountForUniformType(int type) {
   switch (type) {
     case GL_FLOAT:
     case GL_INT:
     case GL_BOOL:
     case GL_SAMPLER_2D:
     case GL_SAMPLER_CUBE:
     case GL_SAMPLER_2D_RECT_ARB:  // extension.
     case GL_SAMPLER_EXTERNAL_OES:  // extension.
       return 1;
     case GL_FLOAT_VEC2:
@@ skipping 44 matching lines @@
       return 8;
     case GL_FLOAT_MAT3x4:
     case GL_FLOAT_MAT4x3:
       return 12;
 
     default:
       return 0;
   }
 }
 
-size_t GLES2Util::GetGLTypeSizeForTexturesAndBuffers(uint32 type) {
+size_t GLES2Util::GetGLTypeSizeForTexturesAndBuffers(uint32_t type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
     case GL_UNSIGNED_BYTE:
       return sizeof(GLubyte);  // NOLINT
     case GL_SHORT:
       return sizeof(GLshort);  // NOLINT
     case GL_UNSIGNED_SHORT:
       return sizeof(GLushort);  // NOLINT
     case GL_INT:
       return sizeof(GLint);  // NOLINT
     case GL_UNSIGNED_INT:
       return sizeof(GLuint);  // NOLINT
     case GL_FLOAT:
       return sizeof(GLfloat);  // NOLINT
     case GL_FIXED:
       return sizeof(GLfixed);  // NOLINT
     default:
       return 0;
   }
 }
 
-size_t GLES2Util::GetComponentCountForGLTransformType(uint32 type) {
+size_t GLES2Util::GetComponentCountForGLTransformType(uint32_t type) {
   switch (type) {
     case GL_TRANSLATE_X_CHROMIUM:
     case GL_TRANSLATE_Y_CHROMIUM:
       return 1;
     case GL_TRANSLATE_2D_CHROMIUM:
       return 2;
     case GL_TRANSLATE_3D_CHROMIUM:
       return 3;
     case GL_AFFINE_2D_CHROMIUM:
     case GL_TRANSPOSE_AFFINE_2D_CHROMIUM:
@@ skipping 13 matching lines @@
     case GL_OBJECT_LINEAR_CHROMIUM:
       return 3;
     case GL_CONSTANT_CHROMIUM:
       return 1;
     case GL_NONE:
     default:
       return 0;
   }
 }
 
-size_t GLES2Util::GetGLTypeSizeForPathCoordType(uint32 type) {
+size_t GLES2Util::GetGLTypeSizeForPathCoordType(uint32_t type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
     case GL_UNSIGNED_BYTE:
       return sizeof(GLubyte);  // NOLINT
     case GL_SHORT:
       return sizeof(GLshort);  // NOLINT
     case GL_UNSIGNED_SHORT:
       return sizeof(GLushort);  // NOLINT
     case GL_FLOAT:
       return sizeof(GLfloat);  // NOLINT
     default:
       return 0;
   }
 }
 
-size_t GLES2Util::GetGLTypeSizeForGLPathNameType(uint32 type) {
+size_t GLES2Util::GetGLTypeSizeForGLPathNameType(uint32_t type) {
   switch (type) {
     case GL_BYTE:
       return sizeof(GLbyte);  // NOLINT
     case GL_UNSIGNED_BYTE:
       return sizeof(GLubyte);  // NOLINT
     case GL_SHORT:
       return sizeof(GLshort);  // NOLINT
     case GL_UNSIGNED_SHORT:
       return sizeof(GLushort);  // NOLINT
     case GL_INT:
       return sizeof(GLint);  // NOLINT
     case GL_UNSIGNED_INT:
       return sizeof(GLuint);  // NOLINT
     default:
       return 0;
   }
 }
 
-uint32 GLES2Util::GLErrorToErrorBit(uint32 error) {
+uint32_t GLES2Util::GLErrorToErrorBit(uint32_t error) {
   switch (error) {
     case GL_INVALID_ENUM:
       return gl_error_bit::kInvalidEnum;
     case GL_INVALID_VALUE:
       return gl_error_bit::kInvalidValue;
     case GL_INVALID_OPERATION:
       return gl_error_bit::kInvalidOperation;
     case GL_OUT_OF_MEMORY:
       return gl_error_bit::kOutOfMemory;
     case GL_INVALID_FRAMEBUFFER_OPERATION:
       return gl_error_bit::kInvalidFrameBufferOperation;
     case GL_CONTEXT_LOST_KHR:
       return gl_error_bit::kContextLost;
     default:
       NOTREACHED();
       return gl_error_bit::kNoError;
   }
 }
 
-uint32 GLES2Util::GLErrorBitToGLError(uint32 error_bit) {
+uint32_t GLES2Util::GLErrorBitToGLError(uint32_t error_bit) {
   switch (error_bit) {
     case gl_error_bit::kInvalidEnum:
       return GL_INVALID_ENUM;
     case gl_error_bit::kInvalidValue:
       return GL_INVALID_VALUE;
     case gl_error_bit::kInvalidOperation:
       return GL_INVALID_OPERATION;
     case gl_error_bit::kOutOfMemory:
       return GL_OUT_OF_MEMORY;
     case gl_error_bit::kInvalidFrameBufferOperation:
       return GL_INVALID_FRAMEBUFFER_OPERATION;
     case gl_error_bit::kContextLost:
       return GL_CONTEXT_LOST_KHR;
     default:
       NOTREACHED();
       return GL_NO_ERROR;
   }
 }
 
-uint32 GLES2Util::IndexToGLFaceTarget(int index) {
-  static uint32 faces[] = {
-    GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-    GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
-    GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
-    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
-    GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
-    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
+uint32_t GLES2Util::IndexToGLFaceTarget(int index) {
+  static uint32_t faces[] = {
+      GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+      GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
   };
   return faces[index];
 }
 
-size_t GLES2Util::GLTargetToFaceIndex(uint32 target) {
+size_t GLES2Util::GLTargetToFaceIndex(uint32_t target) {
   switch (target) {
     case GL_TEXTURE_2D:
     case GL_TEXTURE_EXTERNAL_OES:
     case GL_TEXTURE_RECTANGLE_ARB:
     case GL_TEXTURE_3D:
     case GL_TEXTURE_2D_ARRAY:
       return 0;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
       return 0;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       return 1;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       return 2;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
       return 3;
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
       return 4;
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
       return 5;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
-uint32 GLES2Util::GetGLReadPixelsImplementationFormat(
-    uint32 internal_format) {
+uint32_t GLES2Util::GetGLReadPixelsImplementationFormat(
+    uint32_t internal_format) {
   switch (internal_format) {
     case GL_R8:
     case GL_R16F:
     case GL_R32F:
       return GL_RED;
     case GL_R8UI:
     case GL_R8I:
     case GL_R16UI:
     case GL_R16I:
     case GL_R32UI:
@@ skipping 23 matching lines @@
     case GL_RGBA16UI:
     case GL_RGBA16I:
     case GL_RGBA32UI:
     case GL_RGBA32I:
       return GL_RGBA_INTEGER;
     default:
       return GL_RGBA;
   }
 }
 
-uint32 GLES2Util::GetGLReadPixelsImplementationType(
-    uint32 internal_format, uint32 texture_type) {
+uint32_t GLES2Util::GetGLReadPixelsImplementationType(uint32_t internal_format,
+                                                      uint32_t texture_type) {
   switch (internal_format) {
     case GL_R16UI:
     case GL_RG16UI:
     case GL_RGBA16UI:
     case GL_RGB10_A2:
     case GL_RGB10_A2UI:
       return GL_UNSIGNED_SHORT;
     case GL_R32UI:
     case GL_RG32UI:
     case GL_RGBA32UI:
@@ skipping 34 matching lines @@
         // GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_5_5_5_1, and
         // GL_UNSIGNED_INT_2_10_10_10_REV.
         default:
           return GL_UNSIGNED_BYTE;
       }
     default:
       return GL_UNSIGNED_BYTE;
   }
 }
 
-uint32 GLES2Util::GetChannelsForFormat(int format) {
+uint32_t GLES2Util::GetChannelsForFormat(int format) {
   switch (format) {
     case GL_ALPHA:
     case GL_ALPHA16F_EXT:
     case GL_ALPHA32F_EXT:
       return kAlpha;
     case GL_LUMINANCE:
       return kRGB;
     case GL_LUMINANCE_ALPHA:
       return kRGBA;
     case GL_RGB:
@@ skipping 67 matching lines @@
     case GL_RG16UI:
     case GL_RG16I:
     case GL_RG32UI:
     case GL_RG32I:
       return kRed | kGreen;
     default:
       return 0x0000;
   }
 }
 
-uint32 GLES2Util::GetChannelsNeededForAttachmentType(
-    int type, uint32 max_color_attachments) {
+uint32_t GLES2Util::GetChannelsNeededForAttachmentType(
+    int type,
+    uint32_t max_color_attachments) {
   switch (type) {
     case GL_DEPTH_ATTACHMENT:
       return kDepth;
     case GL_STENCIL_ATTACHMENT:
       return kStencil;
     default:
       if (type >= GL_COLOR_ATTACHMENT0 &&
           type < static_cast<int>(
               GL_COLOR_ATTACHMENT0 + max_color_attachments)) {
         return kRGBA;
       }
       return 0x0000;
   }
 }
 
-std::string GLES2Util::GetStringEnum(uint32 value) {
+std::string GLES2Util::GetStringEnum(uint32_t value) {
   const EnumToString* entry = enum_to_string_table_;
   const EnumToString* end = entry + enum_to_string_table_len_;
   for (;entry < end; ++entry) {
     if (value == entry->value) {
       return entry->name;
     }
   }
   std::stringstream ss;
   ss.fill('0');
   ss.width(value < 0x10000 ? 4 : 8);
   ss << std::hex << value;
   return "0x" + ss.str();
 }
 
-std::string GLES2Util::GetStringError(uint32 value) {
+std::string GLES2Util::GetStringError(uint32_t value) {
   static EnumToString string_table[] = {
     { GL_NONE, "GL_NONE" },
   };
   return GLES2Util::GetQualifiedEnumString(
       string_table, arraysize(string_table), value);
 }
 
-std::string GLES2Util::GetStringBool(uint32 value) {
+std::string GLES2Util::GetStringBool(uint32_t value) {
   return value ? "GL_TRUE" : "GL_FALSE";
 }
 
-std::string GLES2Util::GetQualifiedEnumString(
-    const EnumToString* table, size_t count, uint32 value) {
+std::string GLES2Util::GetQualifiedEnumString(const EnumToString* table,
+                                              size_t count,
+                                              uint32_t value) {
   for (const EnumToString* end = table + count; table < end; ++table) {
     if (table->value == value) {
       return table->name;
     }
   }
   return GetStringEnum(value);
 }
 
 GLSLArrayName::GLSLArrayName(const std::string& name) : element_index_(-1) {
   if (name.size() < 4)
     return;
   if (name[name.size() - 1] != ']')
     return;
 
   size_t open_pos = name.find_last_of('[');
   if (open_pos >= name.size() - 2)
     return;
 
   base::CheckedNumeric<int> index = 0;
   size_t last = name.size() - 1;
   for (size_t pos = open_pos + 1; pos < last; ++pos) {
-    int8 digit = name[pos] - '0';
+    int8_t digit = name[pos] - '0';
     if (digit < 0 || digit > 9)
       return;
     index = index * 10 + digit;
   }
   if (!index.IsValid())
     return;
   element_index_ = index.ValueOrDie();
   base_name_ = name.substr(0, open_pos);
 }
 
@@ skipping 118 matching lines @@
   }
 }
 
 namespace {
 
 // WebGraphicsContext3DCommandBufferImpl configuration attributes. Those in
 // the 16-bit range are the same as used by EGL. Those outside the 16-bit range
 // are unique to Chromium. Attributes are matched using a closest fit algorithm.
 
 // From <EGL/egl.h>.
-const int32 kAlphaSize       = 0x3021;  // EGL_ALPHA_SIZE
-const int32 kBlueSize        = 0x3022;  // EGL_BLUE_SIZE
-const int32 kGreenSize       = 0x3023;  // EGL_GREEN_SIZE
-const int32 kRedSize         = 0x3024;  // EGL_RED_SIZE
-const int32 kDepthSize       = 0x3025;  // EGL_DEPTH_SIZE
-const int32 kStencilSize     = 0x3026;  // EGL_STENCIL_SIZE
-const int32 kSamples         = 0x3031;  // EGL_SAMPLES
-const int32 kSampleBuffers   = 0x3032;  // EGL_SAMPLE_BUFFERS
-const int32 kNone            = 0x3038;  // EGL_NONE
-const int32 kSwapBehavior    = 0x3093;  // EGL_SWAP_BEHAVIOR
-const int32 kBufferPreserved = 0x3094;  // EGL_BUFFER_PRESERVED
-const int32 kBufferDestroyed = 0x3095;  // EGL_BUFFER_DESTROYED
+#include <stddef.h>
+#include <stdint.h>
+const int32_t kAlphaSize = 0x3021;        // EGL_ALPHA_SIZE
+const int32_t kBlueSize = 0x3022;         // EGL_BLUE_SIZE
+const int32_t kGreenSize = 0x3023;        // EGL_GREEN_SIZE
+const int32_t kRedSize = 0x3024;          // EGL_RED_SIZE
+const int32_t kDepthSize = 0x3025;        // EGL_DEPTH_SIZE
+const int32_t kStencilSize = 0x3026;      // EGL_STENCIL_SIZE
+const int32_t kSamples = 0x3031;          // EGL_SAMPLES
+const int32_t kSampleBuffers = 0x3032;    // EGL_SAMPLE_BUFFERS
+const int32_t kNone = 0x3038;             // EGL_NONE
+const int32_t kSwapBehavior = 0x3093;     // EGL_SWAP_BEHAVIOR
+const int32_t kBufferPreserved = 0x3094;  // EGL_BUFFER_PRESERVED
+const int32_t kBufferDestroyed = 0x3095;  // EGL_BUFFER_DESTROYED
 
 // Chromium only.
-const int32 kBindGeneratesResource = 0x10000;
-const int32 kFailIfMajorPerfCaveat = 0x10001;
-const int32 kLoseContextWhenOutOfMemory = 0x10002;
-const int32 kContextType = 0x10003;
+const int32_t kBindGeneratesResource = 0x10000;
+const int32_t kFailIfMajorPerfCaveat = 0x10001;
+const int32_t kLoseContextWhenOutOfMemory = 0x10002;
+const int32_t kContextType = 0x10003;
 
 }  // namespace
 
 ContextCreationAttribHelper::ContextCreationAttribHelper()
     : alpha_size(-1),
       blue_size(-1),
       green_size(-1),
       red_size(-1),
       depth_size(-1),
       stencil_size(-1),
       samples(-1),
       sample_buffers(-1),
       buffer_preserved(true),
       bind_generates_resource(true),
       fail_if_major_perf_caveat(false),
       lose_context_when_out_of_memory(false),
       context_type(CONTEXT_TYPE_OPENGLES2) {}
 
-void ContextCreationAttribHelper::Serialize(std::vector<int32>* attribs) const {
+void ContextCreationAttribHelper::Serialize(
+    std::vector<int32_t>* attribs) const {
   if (alpha_size != -1) {
     attribs->push_back(kAlphaSize);
     attribs->push_back(alpha_size);
   }
   if (blue_size != -1) {
     attribs->push_back(kBlueSize);
     attribs->push_back(blue_size);
   }
   if (green_size != -1) {
     attribs->push_back(kGreenSize);
@@ skipping 25 matching lines @@
   attribs->push_back(bind_generates_resource ? 1 : 0);
   attribs->push_back(kFailIfMajorPerfCaveat);
   attribs->push_back(fail_if_major_perf_caveat ? 1 : 0);
   attribs->push_back(kLoseContextWhenOutOfMemory);
   attribs->push_back(lose_context_when_out_of_memory ? 1 : 0);
   attribs->push_back(kContextType);
   attribs->push_back(context_type);
   attribs->push_back(kNone);
 }
 
-bool ContextCreationAttribHelper::Parse(const std::vector<int32>& attribs) {
+bool ContextCreationAttribHelper::Parse(const std::vector<int32_t>& attribs) {
   for (size_t i = 0; i < attribs.size(); i += 2) {
-    const int32 attrib = attribs[i];
+    const int32_t attrib = attribs[i];
     if (i + 1 >= attribs.size()) {
       if (attrib == kNone) {
         return true;
       }
 
       DLOG(ERROR) << "Missing value after context creation attribute: "
                   << attrib;
       return false;
     }
 
-    const int32 value = attribs[i+1];
+    const int32_t value = attribs[i + 1];
     switch (attrib) {
       case kAlphaSize:
         alpha_size = value;
         break;
       case kBlueSize:
         blue_size = value;
         break;
       case kGreenSize:
         green_size = value;
         break;
@@ skipping 37 matching lines @@
   }
 
   return true;
 }
 
 #include "gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu