Switch to standard integer types in gpu/.

gpu/command_buffer/common/gles2_cmd_format_autogen.h

 // Copyright 2014 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 auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_
 
 #define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
 #define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
 
 struct ActiveTexture {
   typedef ActiveTexture ValueType;
   static const CommandId kCmdId = kActiveTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _texture) {
     SetHeader();
     texture = _texture;
@@ skipping 11 matching lines @@
 static_assert(sizeof(ActiveTexture) == 8, "size of ActiveTexture should be 8");
 static_assert(offsetof(ActiveTexture, header) == 0,
               "offset of ActiveTexture header should be 0");
 static_assert(offsetof(ActiveTexture, texture) == 4,
               "offset of ActiveTexture texture should be 4");
 
 struct AttachShader {
   typedef AttachShader ValueType;
   static const CommandId kCmdId = kAttachShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLuint _shader) {
     SetHeader();
     program = _program;
@@ skipping 15 matching lines @@
               "offset of AttachShader header should be 0");
 static_assert(offsetof(AttachShader, program) == 4,
               "offset of AttachShader program should be 4");
 static_assert(offsetof(AttachShader, shader) == 8,
               "offset of AttachShader shader should be 8");
 
 struct BindAttribLocationBucket {
   typedef BindAttribLocationBucket ValueType;
   static const CommandId kCmdId = kBindAttribLocationBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLuint _index, uint32_t _name_bucket_id) {
     SetHeader();
     program = _program;
@@ skipping 23 matching lines @@
               "offset of BindAttribLocationBucket program should be 4");
 static_assert(offsetof(BindAttribLocationBucket, index) == 8,
               "offset of BindAttribLocationBucket index should be 8");
 static_assert(offsetof(BindAttribLocationBucket, name_bucket_id) == 12,
               "offset of BindAttribLocationBucket name_bucket_id should be 12");
 
 struct BindBuffer {
   typedef BindBuffer ValueType;
   static const CommandId kCmdId = kBindBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _buffer) {
     SetHeader();
     target = _target;
@@ skipping 15 matching lines @@
               "offset of BindBuffer header should be 0");
 static_assert(offsetof(BindBuffer, target) == 4,
               "offset of BindBuffer target should be 4");
 static_assert(offsetof(BindBuffer, buffer) == 8,
               "offset of BindBuffer buffer should be 8");
 
 struct BindBufferBase {
   typedef BindBufferBase ValueType;
   static const CommandId kCmdId = kBindBufferBase;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _index, GLuint _buffer) {
     SetHeader();
     target = _target;
@@ skipping 20 matching lines @@
               "offset of BindBufferBase target should be 4");
 static_assert(offsetof(BindBufferBase, index) == 8,
               "offset of BindBufferBase index should be 8");
 static_assert(offsetof(BindBufferBase, buffer) == 12,
               "offset of BindBufferBase buffer should be 12");
 
 struct BindBufferRange {
   typedef BindBufferRange ValueType;
   static const CommandId kCmdId = kBindBufferRange;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLuint _index,
             GLuint _buffer,
@@ skipping 38 matching lines @@
               "offset of BindBufferRange buffer should be 12");
 static_assert(offsetof(BindBufferRange, offset) == 16,
               "offset of BindBufferRange offset should be 16");
 static_assert(offsetof(BindBufferRange, size) == 20,
               "offset of BindBufferRange size should be 20");
 
 struct BindFramebuffer {
   typedef BindFramebuffer ValueType;
   static const CommandId kCmdId = kBindFramebuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _framebuffer) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of BindFramebuffer header should be 0");
 static_assert(offsetof(BindFramebuffer, target) == 4,
               "offset of BindFramebuffer target should be 4");
 static_assert(offsetof(BindFramebuffer, framebuffer) == 8,
               "offset of BindFramebuffer framebuffer should be 8");
 
 struct BindRenderbuffer {
   typedef BindRenderbuffer ValueType;
   static const CommandId kCmdId = kBindRenderbuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _renderbuffer) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of BindRenderbuffer header should be 0");
 static_assert(offsetof(BindRenderbuffer, target) == 4,
               "offset of BindRenderbuffer target should be 4");
 static_assert(offsetof(BindRenderbuffer, renderbuffer) == 8,
               "offset of BindRenderbuffer renderbuffer should be 8");
 
 struct BindSampler {
   typedef BindSampler ValueType;
   static const CommandId kCmdId = kBindSampler;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _unit, GLuint _sampler) {
     SetHeader();
     unit = _unit;
@@ skipping 15 matching lines @@
               "offset of BindSampler header should be 0");
 static_assert(offsetof(BindSampler, unit) == 4,
               "offset of BindSampler unit should be 4");
 static_assert(offsetof(BindSampler, sampler) == 8,
               "offset of BindSampler sampler should be 8");
 
 struct BindTexture {
   typedef BindTexture ValueType;
   static const CommandId kCmdId = kBindTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _texture) {
     SetHeader();
     target = _target;
@@ skipping 15 matching lines @@
               "offset of BindTexture header should be 0");
 static_assert(offsetof(BindTexture, target) == 4,
               "offset of BindTexture target should be 4");
 static_assert(offsetof(BindTexture, texture) == 8,
               "offset of BindTexture texture should be 8");
 
 struct BindTransformFeedback {
   typedef BindTransformFeedback ValueType;
   static const CommandId kCmdId = kBindTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _transformfeedback) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of BindTransformFeedback header should be 0");
 static_assert(offsetof(BindTransformFeedback, target) == 4,
               "offset of BindTransformFeedback target should be 4");
 static_assert(offsetof(BindTransformFeedback, transformfeedback) == 8,
               "offset of BindTransformFeedback transformfeedback should be 8");
 
 struct BlendColor {
   typedef BlendColor ValueType;
   static const CommandId kCmdId = kBlendColor;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) {
     SetHeader();
     red = _red;
@@ skipping 27 matching lines @@
               "offset of BlendColor green should be 8");
 static_assert(offsetof(BlendColor, blue) == 12,
               "offset of BlendColor blue should be 12");
 static_assert(offsetof(BlendColor, alpha) == 16,
               "offset of BlendColor alpha should be 16");
 
 struct BlendEquation {
   typedef BlendEquation ValueType;
   static const CommandId kCmdId = kBlendEquation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode) {
     SetHeader();
     mode = _mode;
@@ skipping 11 matching lines @@
 static_assert(sizeof(BlendEquation) == 8, "size of BlendEquation should be 8");
 static_assert(offsetof(BlendEquation, header) == 0,
               "offset of BlendEquation header should be 0");
 static_assert(offsetof(BlendEquation, mode) == 4,
               "offset of BlendEquation mode should be 4");
 
 struct BlendEquationSeparate {
   typedef BlendEquationSeparate ValueType;
   static const CommandId kCmdId = kBlendEquationSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _modeRGB, GLenum _modeAlpha) {
     SetHeader();
     modeRGB = _modeRGB;
@@ skipping 16 matching lines @@
               "offset of BlendEquationSeparate header should be 0");
 static_assert(offsetof(BlendEquationSeparate, modeRGB) == 4,
               "offset of BlendEquationSeparate modeRGB should be 4");
 static_assert(offsetof(BlendEquationSeparate, modeAlpha) == 8,
               "offset of BlendEquationSeparate modeAlpha should be 8");
 
 struct BlendFunc {
   typedef BlendFunc ValueType;
   static const CommandId kCmdId = kBlendFunc;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _sfactor, GLenum _dfactor) {
     SetHeader();
     sfactor = _sfactor;
@@ skipping 15 matching lines @@
               "offset of BlendFunc header should be 0");
 static_assert(offsetof(BlendFunc, sfactor) == 4,
               "offset of BlendFunc sfactor should be 4");
 static_assert(offsetof(BlendFunc, dfactor) == 8,
               "offset of BlendFunc dfactor should be 8");
 
 struct BlendFuncSeparate {
   typedef BlendFuncSeparate ValueType;
   static const CommandId kCmdId = kBlendFuncSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _srcRGB,
             GLenum _dstRGB,
             GLenum _srcAlpha,
@@ skipping 31 matching lines @@
               "offset of BlendFuncSeparate dstRGB should be 8");
 static_assert(offsetof(BlendFuncSeparate, srcAlpha) == 12,
               "offset of BlendFuncSeparate srcAlpha should be 12");
 static_assert(offsetof(BlendFuncSeparate, dstAlpha) == 16,
               "offset of BlendFuncSeparate dstAlpha should be 16");
 
 struct BufferData {
   typedef BufferData ValueType;
   static const CommandId kCmdId = kBufferData;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLsizeiptr _size,
             uint32_t _data_shm_id,
@@ skipping 37 matching lines @@
               "offset of BufferData data_shm_id should be 12");
 static_assert(offsetof(BufferData, data_shm_offset) == 16,
               "offset of BufferData data_shm_offset should be 16");
 static_assert(offsetof(BufferData, usage) == 20,
               "offset of BufferData usage should be 20");
 
 struct BufferSubData {
   typedef BufferSubData ValueType;
   static const CommandId kCmdId = kBufferSubData;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLintptr _offset,
             GLsizeiptr _size,
@@ skipping 38 matching lines @@
               "offset of BufferSubData size should be 12");
 static_assert(offsetof(BufferSubData, data_shm_id) == 16,
               "offset of BufferSubData data_shm_id should be 16");
 static_assert(offsetof(BufferSubData, data_shm_offset) == 20,
               "offset of BufferSubData data_shm_offset should be 20");
 
 struct CheckFramebufferStatus {
   typedef CheckFramebufferStatus ValueType;
   static const CommandId kCmdId = kCheckFramebufferStatus;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLenum Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 29 matching lines @@
 static_assert(offsetof(CheckFramebufferStatus, result_shm_id) == 8,
               "offset of CheckFramebufferStatus result_shm_id should be 8");
 static_assert(
     offsetof(CheckFramebufferStatus, result_shm_offset) == 12,
     "offset of CheckFramebufferStatus result_shm_offset should be 12");
 
 struct Clear {
   typedef Clear ValueType;
   static const CommandId kCmdId = kClear;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLbitfield _mask) {
     SetHeader();
     mask = _mask;
@@ skipping 10 matching lines @@
 
 static_assert(sizeof(Clear) == 8, "size of Clear should be 8");
 static_assert(offsetof(Clear, header) == 0,
               "offset of Clear header should be 0");
 static_assert(offsetof(Clear, mask) == 4, "offset of Clear mask should be 4");
 
 struct ClearBufferfi {
   typedef ClearBufferfi ValueType;
   static const CommandId kCmdId = kClearBufferfi;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _buffer,
             GLint _drawbuffers,
             GLfloat _depth,
@@ skipping 31 matching lines @@
               "offset of ClearBufferfi drawbuffers should be 8");
 static_assert(offsetof(ClearBufferfi, depth) == 12,
               "offset of ClearBufferfi depth should be 12");
 static_assert(offsetof(ClearBufferfi, stencil) == 16,
               "offset of ClearBufferfi stencil should be 16");
 
 struct ClearBufferfvImmediate {
   typedef ClearBufferfvImmediate ValueType;
   static const CommandId kCmdId = kClearBufferfvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4);
   }
 
   static uint32_t ComputeEffectiveDataSize(GLenum buffer) {
     return static_cast<uint32_t>(sizeof(GLfloat) *
                                  GLES2Util::CalcClearBufferfvDataCount(buffer));
   }
 
@@ skipping 35 matching lines @@
               "offset of ClearBufferfvImmediate header should be 0");
 static_assert(offsetof(ClearBufferfvImmediate, buffer) == 4,
               "offset of ClearBufferfvImmediate buffer should be 4");
 static_assert(offsetof(ClearBufferfvImmediate, drawbuffers) == 8,
               "offset of ClearBufferfvImmediate drawbuffers should be 8");
 
 struct ClearBufferivImmediate {
   typedef ClearBufferivImmediate ValueType;
   static const CommandId kCmdId = kClearBufferivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 4);
   }
 
   static uint32_t ComputeEffectiveDataSize(GLenum buffer) {
     return static_cast<uint32_t>(sizeof(GLint) *
                                  GLES2Util::CalcClearBufferivDataCount(buffer));
   }
 
@@ skipping 35 matching lines @@
               "offset of ClearBufferivImmediate header should be 0");
 static_assert(offsetof(ClearBufferivImmediate, buffer) == 4,
               "offset of ClearBufferivImmediate buffer should be 4");
 static_assert(offsetof(ClearBufferivImmediate, drawbuffers) == 8,
               "offset of ClearBufferivImmediate drawbuffers should be 8");
 
 struct ClearBufferuivImmediate {
   typedef ClearBufferuivImmediate ValueType;
   static const CommandId kCmdId = kClearBufferuivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLuint) * 4);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 25 matching lines @@
               "offset of ClearBufferuivImmediate header should be 0");
 static_assert(offsetof(ClearBufferuivImmediate, buffer) == 4,
               "offset of ClearBufferuivImmediate buffer should be 4");
 static_assert(offsetof(ClearBufferuivImmediate, drawbuffers) == 8,
               "offset of ClearBufferuivImmediate drawbuffers should be 8");
 
 struct ClearColor {
   typedef ClearColor ValueType;
   static const CommandId kCmdId = kClearColor;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLclampf _red, GLclampf _green, GLclampf _blue, GLclampf _alpha) {
     SetHeader();
     red = _red;
@@ skipping 27 matching lines @@
               "offset of ClearColor green should be 8");
 static_assert(offsetof(ClearColor, blue) == 12,
               "offset of ClearColor blue should be 12");
 static_assert(offsetof(ClearColor, alpha) == 16,
               "offset of ClearColor alpha should be 16");
 
 struct ClearDepthf {
   typedef ClearDepthf ValueType;
   static const CommandId kCmdId = kClearDepthf;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLclampf _depth) {
     SetHeader();
     depth = _depth;
@@ skipping 11 matching lines @@
 static_assert(sizeof(ClearDepthf) == 8, "size of ClearDepthf should be 8");
 static_assert(offsetof(ClearDepthf, header) == 0,
               "offset of ClearDepthf header should be 0");
 static_assert(offsetof(ClearDepthf, depth) == 4,
               "offset of ClearDepthf depth should be 4");
 
 struct ClearStencil {
   typedef ClearStencil ValueType;
   static const CommandId kCmdId = kClearStencil;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _s) {
     SetHeader();
     s = _s;
@@ skipping 11 matching lines @@
 static_assert(sizeof(ClearStencil) == 8, "size of ClearStencil should be 8");
 static_assert(offsetof(ClearStencil, header) == 0,
               "offset of ClearStencil header should be 0");
 static_assert(offsetof(ClearStencil, s) == 4,
               "offset of ClearStencil s should be 4");
 
 struct ClientWaitSync {
   typedef ClientWaitSync ValueType;
   static const CommandId kCmdId = kClientWaitSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   typedef GLenum Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync,
@@ skipping 49 matching lines @@
               "offset of ClientWaitSync timeout_1 should be 16");
 static_assert(offsetof(ClientWaitSync, result_shm_id) == 20,
               "offset of ClientWaitSync result_shm_id should be 20");
 static_assert(offsetof(ClientWaitSync, result_shm_offset) == 24,
               "offset of ClientWaitSync result_shm_offset should be 24");
 
 struct ColorMask {
   typedef ColorMask ValueType;
   static const CommandId kCmdId = kColorMask;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLboolean _red,
             GLboolean _green,
             GLboolean _blue,
@@ skipping 30 matching lines @@
               "offset of ColorMask green should be 8");
 static_assert(offsetof(ColorMask, blue) == 12,
               "offset of ColorMask blue should be 12");
 static_assert(offsetof(ColorMask, alpha) == 16,
               "offset of ColorMask alpha should be 16");
 
 struct CompileShader {
   typedef CompileShader ValueType;
   static const CommandId kCmdId = kCompileShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader) {
     SetHeader();
     shader = _shader;
@@ skipping 11 matching lines @@
 static_assert(sizeof(CompileShader) == 8, "size of CompileShader should be 8");
 static_assert(offsetof(CompileShader, header) == 0,
               "offset of CompileShader header should be 0");
 static_assert(offsetof(CompileShader, shader) == 4,
               "offset of CompileShader shader should be 4");
 
 struct CompressedTexImage2DBucket {
   typedef CompressedTexImage2DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexImage2DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLenum _internalformat,
@@ skipping 46 matching lines @@
               "offset of CompressedTexImage2DBucket width should be 16");
 static_assert(offsetof(CompressedTexImage2DBucket, height) == 20,
               "offset of CompressedTexImage2DBucket height should be 20");
 static_assert(offsetof(CompressedTexImage2DBucket, bucket_id) == 24,
               "offset of CompressedTexImage2DBucket bucket_id should be 24");
 
 struct CompressedTexImage2D {
   typedef CompressedTexImage2D ValueType;
   static const CommandId kCmdId = kCompressedTexImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLenum _internalformat,
@@ skipping 58 matching lines @@
               "offset of CompressedTexImage2D imageSize should be 24");
 static_assert(offsetof(CompressedTexImage2D, data_shm_id) == 28,
               "offset of CompressedTexImage2D data_shm_id should be 28");
 static_assert(offsetof(CompressedTexImage2D, data_shm_offset) == 32,
               "offset of CompressedTexImage2D data_shm_offset should be 32");
 
 struct CompressedTexSubImage2DBucket {
   typedef CompressedTexSubImage2DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage2DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 56 matching lines @@
               "offset of CompressedTexSubImage2DBucket height should be 24");
 static_assert(offsetof(CompressedTexSubImage2DBucket, format) == 28,
               "offset of CompressedTexSubImage2DBucket format should be 28");
 static_assert(offsetof(CompressedTexSubImage2DBucket, bucket_id) == 32,
               "offset of CompressedTexSubImage2DBucket bucket_id should be 32");
 
 struct CompressedTexSubImage2D {
   typedef CompressedTexSubImage2D ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 69 matching lines @@
               "offset of CompressedTexSubImage2D imageSize should be 32");
 static_assert(offsetof(CompressedTexSubImage2D, data_shm_id) == 36,
               "offset of CompressedTexSubImage2D data_shm_id should be 36");
 static_assert(offsetof(CompressedTexSubImage2D, data_shm_offset) == 40,
               "offset of CompressedTexSubImage2D data_shm_offset should be 40");
 
 struct CompressedTexImage3DBucket {
   typedef CompressedTexImage3DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexImage3DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLenum _internalformat,
@@ skipping 52 matching lines @@
               "offset of CompressedTexImage3DBucket height should be 20");
 static_assert(offsetof(CompressedTexImage3DBucket, depth) == 24,
               "offset of CompressedTexImage3DBucket depth should be 24");
 static_assert(offsetof(CompressedTexImage3DBucket, bucket_id) == 28,
               "offset of CompressedTexImage3DBucket bucket_id should be 28");
 
 struct CompressedTexImage3D {
   typedef CompressedTexImage3D ValueType;
   static const CommandId kCmdId = kCompressedTexImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLenum _internalformat,
@@ skipping 64 matching lines @@
               "offset of CompressedTexImage3D imageSize should be 28");
 static_assert(offsetof(CompressedTexImage3D, data_shm_id) == 32,
               "offset of CompressedTexImage3D data_shm_id should be 32");
 static_assert(offsetof(CompressedTexImage3D, data_shm_offset) == 36,
               "offset of CompressedTexImage3D data_shm_offset should be 36");
 
 struct CompressedTexSubImage3DBucket {
   typedef CompressedTexSubImage3DBucket ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage3DBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 69 matching lines @@
               "offset of CompressedTexSubImage3DBucket depth should be 32");
 static_assert(offsetof(CompressedTexSubImage3DBucket, format) == 36,
               "offset of CompressedTexSubImage3DBucket format should be 36");
 static_assert(offsetof(CompressedTexSubImage3DBucket, bucket_id) == 40,
               "offset of CompressedTexSubImage3DBucket bucket_id should be 40");
 
 struct CompressedTexSubImage3D {
   typedef CompressedTexSubImage3D ValueType;
   static const CommandId kCmdId = kCompressedTexSubImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 81 matching lines @@
               "offset of CompressedTexSubImage3D imageSize should be 40");
 static_assert(offsetof(CompressedTexSubImage3D, data_shm_id) == 44,
               "offset of CompressedTexSubImage3D data_shm_id should be 44");
 static_assert(offsetof(CompressedTexSubImage3D, data_shm_offset) == 48,
               "offset of CompressedTexSubImage3D data_shm_offset should be 48");
 
 struct CopyBufferSubData {
   typedef CopyBufferSubData ValueType;
   static const CommandId kCmdId = kCopyBufferSubData;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _readtarget,
             GLenum _writetarget,
             GLintptr _readoffset,
@@ skipping 38 matching lines @@
               "offset of CopyBufferSubData readoffset should be 12");
 static_assert(offsetof(CopyBufferSubData, writeoffset) == 16,
               "offset of CopyBufferSubData writeoffset should be 16");
 static_assert(offsetof(CopyBufferSubData, size) == 20,
               "offset of CopyBufferSubData size should be 20");
 
 struct CopyTexImage2D {
   typedef CopyTexImage2D ValueType;
   static const CommandId kCmdId = kCopyTexImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLenum _internalformat,
@@ skipping 51 matching lines @@
               "offset of CopyTexImage2D y should be 20");
 static_assert(offsetof(CopyTexImage2D, width) == 24,
               "offset of CopyTexImage2D width should be 24");
 static_assert(offsetof(CopyTexImage2D, height) == 28,
               "offset of CopyTexImage2D height should be 28");
 
 struct CopyTexSubImage2D {
   typedef CopyTexSubImage2D ValueType;
   static const CommandId kCmdId = kCopyTexSubImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 56 matching lines @@
               "offset of CopyTexSubImage2D y should be 24");
 static_assert(offsetof(CopyTexSubImage2D, width) == 28,
               "offset of CopyTexSubImage2D width should be 28");
 static_assert(offsetof(CopyTexSubImage2D, height) == 32,
               "offset of CopyTexSubImage2D height should be 32");
 
 struct CopyTexSubImage3D {
   typedef CopyTexSubImage3D ValueType;
   static const CommandId kCmdId = kCopyTexSubImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 62 matching lines @@
               "offset of CopyTexSubImage3D y should be 28");
 static_assert(offsetof(CopyTexSubImage3D, width) == 32,
               "offset of CopyTexSubImage3D width should be 32");
 static_assert(offsetof(CopyTexSubImage3D, height) == 36,
               "offset of CopyTexSubImage3D height should be 36");
 
 struct CreateProgram {
   typedef CreateProgram ValueType;
   static const CommandId kCmdId = kCreateProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(uint32_t _client_id) {
     SetHeader();
     client_id = _client_id;
@@ skipping 11 matching lines @@
 static_assert(sizeof(CreateProgram) == 8, "size of CreateProgram should be 8");
 static_assert(offsetof(CreateProgram, header) == 0,
               "offset of CreateProgram header should be 0");
 static_assert(offsetof(CreateProgram, client_id) == 4,
               "offset of CreateProgram client_id should be 4");
 
 struct CreateShader {
   typedef CreateShader ValueType;
   static const CommandId kCmdId = kCreateShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _type, uint32_t _client_id) {
     SetHeader();
     type = _type;
@@ skipping 15 matching lines @@
               "offset of CreateShader header should be 0");
 static_assert(offsetof(CreateShader, type) == 4,
               "offset of CreateShader type should be 4");
 static_assert(offsetof(CreateShader, client_id) == 8,
               "offset of CreateShader client_id should be 8");
 
 struct CullFace {
   typedef CullFace ValueType;
   static const CommandId kCmdId = kCullFace;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode) {
     SetHeader();
     mode = _mode;
@@ skipping 11 matching lines @@
 static_assert(sizeof(CullFace) == 8, "size of CullFace should be 8");
 static_assert(offsetof(CullFace, header) == 0,
               "offset of CullFace header should be 0");
 static_assert(offsetof(CullFace, mode) == 4,
               "offset of CullFace mode should be 4");
 
 struct DeleteBuffersImmediate {
   typedef DeleteBuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteBuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteBuffersImmediate should be 8");
 static_assert(offsetof(DeleteBuffersImmediate, header) == 0,
               "offset of DeleteBuffersImmediate header should be 0");
 static_assert(offsetof(DeleteBuffersImmediate, n) == 4,
               "offset of DeleteBuffersImmediate n should be 4");
 
 struct DeleteFramebuffersImmediate {
   typedef DeleteFramebuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteFramebuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteFramebuffersImmediate should be 8");
 static_assert(offsetof(DeleteFramebuffersImmediate, header) == 0,
               "offset of DeleteFramebuffersImmediate header should be 0");
 static_assert(offsetof(DeleteFramebuffersImmediate, n) == 4,
               "offset of DeleteFramebuffersImmediate n should be 4");
 
 struct DeleteProgram {
   typedef DeleteProgram ValueType;
   static const CommandId kCmdId = kDeleteProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
@@ skipping 11 matching lines @@
 static_assert(sizeof(DeleteProgram) == 8, "size of DeleteProgram should be 8");
 static_assert(offsetof(DeleteProgram, header) == 0,
               "offset of DeleteProgram header should be 0");
 static_assert(offsetof(DeleteProgram, program) == 4,
               "offset of DeleteProgram program should be 4");
 
 struct DeleteRenderbuffersImmediate {
   typedef DeleteRenderbuffersImmediate ValueType;
   static const CommandId kCmdId = kDeleteRenderbuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteRenderbuffersImmediate should be 8");
 static_assert(offsetof(DeleteRenderbuffersImmediate, header) == 0,
               "offset of DeleteRenderbuffersImmediate header should be 0");
 static_assert(offsetof(DeleteRenderbuffersImmediate, n) == 4,
               "offset of DeleteRenderbuffersImmediate n should be 4");
 
 struct DeleteSamplersImmediate {
   typedef DeleteSamplersImmediate ValueType;
   static const CommandId kCmdId = kDeleteSamplersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteSamplersImmediate should be 8");
 static_assert(offsetof(DeleteSamplersImmediate, header) == 0,
               "offset of DeleteSamplersImmediate header should be 0");
 static_assert(offsetof(DeleteSamplersImmediate, n) == 4,
               "offset of DeleteSamplersImmediate n should be 4");
 
 struct DeleteSync {
   typedef DeleteSync ValueType;
   static const CommandId kCmdId = kDeleteSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync) {
     SetHeader();
     sync = _sync;
@@ skipping 11 matching lines @@
 static_assert(sizeof(DeleteSync) == 8, "size of DeleteSync should be 8");
 static_assert(offsetof(DeleteSync, header) == 0,
               "offset of DeleteSync header should be 0");
 static_assert(offsetof(DeleteSync, sync) == 4,
               "offset of DeleteSync sync should be 4");
 
 struct DeleteShader {
   typedef DeleteShader ValueType;
   static const CommandId kCmdId = kDeleteShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader) {
     SetHeader();
     shader = _shader;
@@ skipping 11 matching lines @@
 static_assert(sizeof(DeleteShader) == 8, "size of DeleteShader should be 8");
 static_assert(offsetof(DeleteShader, header) == 0,
               "offset of DeleteShader header should be 0");
 static_assert(offsetof(DeleteShader, shader) == 4,
               "offset of DeleteShader shader should be 4");
 
 struct DeleteTexturesImmediate {
   typedef DeleteTexturesImmediate ValueType;
   static const CommandId kCmdId = kDeleteTexturesImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteTexturesImmediate should be 8");
 static_assert(offsetof(DeleteTexturesImmediate, header) == 0,
               "offset of DeleteTexturesImmediate header should be 0");
 static_assert(offsetof(DeleteTexturesImmediate, n) == 4,
               "offset of DeleteTexturesImmediate n should be 4");
 
 struct DeleteTransformFeedbacksImmediate {
   typedef DeleteTransformFeedbacksImmediate ValueType;
   static const CommandId kCmdId = kDeleteTransformFeedbacksImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteTransformFeedbacksImmediate should be 8");
 static_assert(offsetof(DeleteTransformFeedbacksImmediate, header) == 0,
               "offset of DeleteTransformFeedbacksImmediate header should be 0");
 static_assert(offsetof(DeleteTransformFeedbacksImmediate, n) == 4,
               "offset of DeleteTransformFeedbacksImmediate n should be 4");
 
 struct DepthFunc {
   typedef DepthFunc ValueType;
   static const CommandId kCmdId = kDepthFunc;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _func) {
     SetHeader();
     func = _func;
@@ skipping 11 matching lines @@
 static_assert(sizeof(DepthFunc) == 8, "size of DepthFunc should be 8");
 static_assert(offsetof(DepthFunc, header) == 0,
               "offset of DepthFunc header should be 0");
 static_assert(offsetof(DepthFunc, func) == 4,
               "offset of DepthFunc func should be 4");
 
 struct DepthMask {
   typedef DepthMask ValueType;
   static const CommandId kCmdId = kDepthMask;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLboolean _flag) {
     SetHeader();
     flag = _flag;
@@ skipping 11 matching lines @@
 static_assert(sizeof(DepthMask) == 8, "size of DepthMask should be 8");
 static_assert(offsetof(DepthMask, header) == 0,
               "offset of DepthMask header should be 0");
 static_assert(offsetof(DepthMask, flag) == 4,
               "offset of DepthMask flag should be 4");
 
 struct DepthRangef {
   typedef DepthRangef ValueType;
   static const CommandId kCmdId = kDepthRangef;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLclampf _zNear, GLclampf _zFar) {
     SetHeader();
     zNear = _zNear;
@@ skipping 15 matching lines @@
               "offset of DepthRangef header should be 0");
 static_assert(offsetof(DepthRangef, zNear) == 4,
               "offset of DepthRangef zNear should be 4");
 static_assert(offsetof(DepthRangef, zFar) == 8,
               "offset of DepthRangef zFar should be 8");
 
 struct DetachShader {
   typedef DetachShader ValueType;
   static const CommandId kCmdId = kDetachShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLuint _shader) {
     SetHeader();
     program = _program;
@@ skipping 15 matching lines @@
               "offset of DetachShader header should be 0");
 static_assert(offsetof(DetachShader, program) == 4,
               "offset of DetachShader program should be 4");
 static_assert(offsetof(DetachShader, shader) == 8,
               "offset of DetachShader shader should be 8");
 
 struct Disable {
   typedef Disable ValueType;
   static const CommandId kCmdId = kDisable;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _cap) {
     SetHeader();
     cap = _cap;
@@ skipping 10 matching lines @@
 
 static_assert(sizeof(Disable) == 8, "size of Disable should be 8");
 static_assert(offsetof(Disable, header) == 0,
               "offset of Disable header should be 0");
 static_assert(offsetof(Disable, cap) == 4, "offset of Disable cap should be 4");
 
 struct DisableVertexAttribArray {
   typedef DisableVertexAttribArray ValueType;
   static const CommandId kCmdId = kDisableVertexAttribArray;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index) {
     SetHeader();
     index = _index;
@@ skipping 12 matching lines @@
               "size of DisableVertexAttribArray should be 8");
 static_assert(offsetof(DisableVertexAttribArray, header) == 0,
               "offset of DisableVertexAttribArray header should be 0");
 static_assert(offsetof(DisableVertexAttribArray, index) == 4,
               "offset of DisableVertexAttribArray index should be 4");
 
 struct DrawArrays {
   typedef DrawArrays ValueType;
   static const CommandId kCmdId = kDrawArrays;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode, GLint _first, GLsizei _count) {
     SetHeader();
     mode = _mode;
@@ skipping 19 matching lines @@
               "offset of DrawArrays mode should be 4");
 static_assert(offsetof(DrawArrays, first) == 8,
               "offset of DrawArrays first should be 8");
 static_assert(offsetof(DrawArrays, count) == 12,
               "offset of DrawArrays count should be 12");
 
 struct DrawElements {
   typedef DrawElements ValueType;
   static const CommandId kCmdId = kDrawElements;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode, GLsizei _count, GLenum _type, GLuint _index_offset) {
     SetHeader();
     mode = _mode;
@@ skipping 27 matching lines @@
               "offset of DrawElements count should be 8");
 static_assert(offsetof(DrawElements, type) == 12,
               "offset of DrawElements type should be 12");
 static_assert(offsetof(DrawElements, index_offset) == 16,
               "offset of DrawElements index_offset should be 16");
 
 struct Enable {
   typedef Enable ValueType;
   static const CommandId kCmdId = kEnable;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _cap) {
     SetHeader();
     cap = _cap;
@@ skipping 10 matching lines @@
 
 static_assert(sizeof(Enable) == 8, "size of Enable should be 8");
 static_assert(offsetof(Enable, header) == 0,
               "offset of Enable header should be 0");
 static_assert(offsetof(Enable, cap) == 4, "offset of Enable cap should be 4");
 
 struct EnableVertexAttribArray {
   typedef EnableVertexAttribArray ValueType;
   static const CommandId kCmdId = kEnableVertexAttribArray;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index) {
     SetHeader();
     index = _index;
@@ skipping 12 matching lines @@
               "size of EnableVertexAttribArray should be 8");
 static_assert(offsetof(EnableVertexAttribArray, header) == 0,
               "offset of EnableVertexAttribArray header should be 0");
 static_assert(offsetof(EnableVertexAttribArray, index) == 4,
               "offset of EnableVertexAttribArray index should be 4");
 
 struct FenceSync {
   typedef FenceSync ValueType;
   static const CommandId kCmdId = kFenceSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(uint32_t _client_id) {
     SetHeader();
     client_id = _client_id;
@@ skipping 13 matching lines @@
 static_assert(sizeof(FenceSync) == 8, "size of FenceSync should be 8");
 static_assert(offsetof(FenceSync, header) == 0,
               "offset of FenceSync header should be 0");
 static_assert(offsetof(FenceSync, client_id) == 4,
               "offset of FenceSync client_id should be 4");
 
 struct Finish {
   typedef Finish ValueType;
   static const CommandId kCmdId = kFinish;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(Finish) == 4, "size of Finish should be 4");
 static_assert(offsetof(Finish, header) == 0,
               "offset of Finish header should be 0");
 
 struct Flush {
   typedef Flush ValueType;
   static const CommandId kCmdId = kFlush;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(Flush) == 4, "size of Flush should be 4");
 static_assert(offsetof(Flush, header) == 0,
               "offset of Flush header should be 0");
 
 struct FramebufferRenderbuffer {
   typedef FramebufferRenderbuffer ValueType;
   static const CommandId kCmdId = kFramebufferRenderbuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _attachment,
             GLenum _renderbuffertarget,
@@ skipping 33 matching lines @@
 static_assert(
     offsetof(FramebufferRenderbuffer, renderbuffertarget) == 12,
     "offset of FramebufferRenderbuffer renderbuffertarget should be 12");
 static_assert(offsetof(FramebufferRenderbuffer, renderbuffer) == 16,
               "offset of FramebufferRenderbuffer renderbuffer should be 16");
 
 struct FramebufferTexture2D {
   typedef FramebufferTexture2D ValueType;
   static const CommandId kCmdId = kFramebufferTexture2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _attachment,
             GLenum _textarget,
@@ skipping 38 matching lines @@
               "offset of FramebufferTexture2D textarget should be 12");
 static_assert(offsetof(FramebufferTexture2D, texture) == 16,
               "offset of FramebufferTexture2D texture should be 16");
 static_assert(offsetof(FramebufferTexture2D, level) == 20,
               "offset of FramebufferTexture2D level should be 20");
 
 struct FramebufferTextureLayer {
   typedef FramebufferTextureLayer ValueType;
   static const CommandId kCmdId = kFramebufferTextureLayer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _attachment,
             GLuint _texture,
@@ skipping 38 matching lines @@
               "offset of FramebufferTextureLayer texture should be 12");
 static_assert(offsetof(FramebufferTextureLayer, level) == 16,
               "offset of FramebufferTextureLayer level should be 16");
 static_assert(offsetof(FramebufferTextureLayer, layer) == 20,
               "offset of FramebufferTextureLayer layer should be 20");
 
 struct FrontFace {
   typedef FrontFace ValueType;
   static const CommandId kCmdId = kFrontFace;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode) {
     SetHeader();
     mode = _mode;
@@ skipping 11 matching lines @@
 static_assert(sizeof(FrontFace) == 8, "size of FrontFace should be 8");
 static_assert(offsetof(FrontFace, header) == 0,
               "offset of FrontFace header should be 0");
 static_assert(offsetof(FrontFace, mode) == 4,
               "offset of FrontFace mode should be 4");
 
 struct GenBuffersImmediate {
   typedef GenBuffersImmediate ValueType;
   static const CommandId kCmdId = kGenBuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenBuffersImmediate should be 8");
 static_assert(offsetof(GenBuffersImmediate, header) == 0,
               "offset of GenBuffersImmediate header should be 0");
 static_assert(offsetof(GenBuffersImmediate, n) == 4,
               "offset of GenBuffersImmediate n should be 4");
 
 struct GenerateMipmap {
   typedef GenerateMipmap ValueType;
   static const CommandId kCmdId = kGenerateMipmap;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target) {
     SetHeader();
     target = _target;
@@ skipping 12 matching lines @@
               "size of GenerateMipmap should be 8");
 static_assert(offsetof(GenerateMipmap, header) == 0,
               "offset of GenerateMipmap header should be 0");
 static_assert(offsetof(GenerateMipmap, target) == 4,
               "offset of GenerateMipmap target should be 4");
 
 struct GenFramebuffersImmediate {
   typedef GenFramebuffersImmediate ValueType;
   static const CommandId kCmdId = kGenFramebuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenFramebuffersImmediate should be 8");
 static_assert(offsetof(GenFramebuffersImmediate, header) == 0,
               "offset of GenFramebuffersImmediate header should be 0");
 static_assert(offsetof(GenFramebuffersImmediate, n) == 4,
               "offset of GenFramebuffersImmediate n should be 4");
 
 struct GenRenderbuffersImmediate {
   typedef GenRenderbuffersImmediate ValueType;
   static const CommandId kCmdId = kGenRenderbuffersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenRenderbuffersImmediate should be 8");
 static_assert(offsetof(GenRenderbuffersImmediate, header) == 0,
               "offset of GenRenderbuffersImmediate header should be 0");
 static_assert(offsetof(GenRenderbuffersImmediate, n) == 4,
               "offset of GenRenderbuffersImmediate n should be 4");
 
 struct GenSamplersImmediate {
   typedef GenSamplersImmediate ValueType;
   static const CommandId kCmdId = kGenSamplersImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenSamplersImmediate should be 8");
 static_assert(offsetof(GenSamplersImmediate, header) == 0,
               "offset of GenSamplersImmediate header should be 0");
 static_assert(offsetof(GenSamplersImmediate, n) == 4,
               "offset of GenSamplersImmediate n should be 4");
 
 struct GenTexturesImmediate {
   typedef GenTexturesImmediate ValueType;
   static const CommandId kCmdId = kGenTexturesImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenTexturesImmediate should be 8");
 static_assert(offsetof(GenTexturesImmediate, header) == 0,
               "offset of GenTexturesImmediate header should be 0");
 static_assert(offsetof(GenTexturesImmediate, n) == 4,
               "offset of GenTexturesImmediate n should be 4");
 
 struct GenTransformFeedbacksImmediate {
   typedef GenTransformFeedbacksImmediate ValueType;
   static const CommandId kCmdId = kGenTransformFeedbacksImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenTransformFeedbacksImmediate should be 8");
 static_assert(offsetof(GenTransformFeedbacksImmediate, header) == 0,
               "offset of GenTransformFeedbacksImmediate header should be 0");
 static_assert(offsetof(GenTransformFeedbacksImmediate, n) == 4,
               "offset of GenTransformFeedbacksImmediate n should be 4");
 
 struct GetActiveAttrib {
   typedef GetActiveAttrib ValueType;
   static const CommandId kCmdId = kGetActiveAttrib;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
     int32_t size;
     uint32_t type;
   };
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
@@ skipping 53 matching lines @@
               "offset of GetActiveAttrib Result size should be "
               "4");
 static_assert(offsetof(GetActiveAttrib::Result, type) == 8,
               "offset of GetActiveAttrib Result type should be "
               "8");
 
 struct GetActiveUniform {
   typedef GetActiveUniform ValueType;
   static const CommandId kCmdId = kGetActiveUniform;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
     int32_t size;
     uint32_t type;
   };
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
@@ skipping 53 matching lines @@
               "offset of GetActiveUniform Result size should be "
               "4");
 static_assert(offsetof(GetActiveUniform::Result, type) == 8,
               "offset of GetActiveUniform Result type should be "
               "8");
 
 struct GetActiveUniformBlockiv {
   typedef GetActiveUniformBlockiv ValueType;
   static const CommandId kCmdId = kGetActiveUniformBlockiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 41 matching lines @@
 static_assert(offsetof(GetActiveUniformBlockiv, params_shm_id) == 16,
               "offset of GetActiveUniformBlockiv params_shm_id should be 16");
 static_assert(
     offsetof(GetActiveUniformBlockiv, params_shm_offset) == 20,
     "offset of GetActiveUniformBlockiv params_shm_offset should be 20");
 
 struct GetActiveUniformBlockName {
   typedef GetActiveUniformBlockName ValueType;
   static const CommandId kCmdId = kGetActiveUniformBlockName;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef int32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 42 matching lines @@
 static_assert(offsetof(GetActiveUniformBlockName, result_shm_id) == 16,
               "offset of GetActiveUniformBlockName result_shm_id should be 16");
 static_assert(
     offsetof(GetActiveUniformBlockName, result_shm_offset) == 20,
     "offset of GetActiveUniformBlockName result_shm_offset should be 20");
 
 struct GetActiveUniformsiv {
   typedef GetActiveUniformsiv ValueType;
   static const CommandId kCmdId = kGetActiveUniformsiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 40 matching lines @@
               "offset of GetActiveUniformsiv pname should be 12");
 static_assert(offsetof(GetActiveUniformsiv, params_shm_id) == 16,
               "offset of GetActiveUniformsiv params_shm_id should be 16");
 static_assert(offsetof(GetActiveUniformsiv, params_shm_offset) == 20,
               "offset of GetActiveUniformsiv params_shm_offset should be 20");
 
 struct GetAttachedShaders {
   typedef GetAttachedShaders ValueType;
   static const CommandId kCmdId = kGetAttachedShaders;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetAttachedShaders result_shm_id should be 8");
 static_assert(offsetof(GetAttachedShaders, result_shm_offset) == 12,
               "offset of GetAttachedShaders result_shm_offset should be 12");
 static_assert(offsetof(GetAttachedShaders, result_size) == 16,
               "offset of GetAttachedShaders result_size should be 16");
 
 struct GetAttribLocation {
   typedef GetAttribLocation ValueType;
   static const CommandId kCmdId = kGetAttribLocation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetAttribLocation name_bucket_id should be 8");
 static_assert(offsetof(GetAttribLocation, location_shm_id) == 12,
               "offset of GetAttribLocation location_shm_id should be 12");
 static_assert(offsetof(GetAttribLocation, location_shm_offset) == 16,
               "offset of GetAttribLocation location_shm_offset should be 16");
 
 struct GetBooleanv {
   typedef GetBooleanv ValueType;
   static const CommandId kCmdId = kGetBooleanv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLboolean> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname,
@@ skipping 27 matching lines @@
               "offset of GetBooleanv pname should be 4");
 static_assert(offsetof(GetBooleanv, params_shm_id) == 8,
               "offset of GetBooleanv params_shm_id should be 8");
 static_assert(offsetof(GetBooleanv, params_shm_offset) == 12,
               "offset of GetBooleanv params_shm_offset should be 12");
 
 struct GetBufferParameteri64v {
   typedef GetBufferParameteri64v ValueType;
   static const CommandId kCmdId = kGetBufferParameteri64v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint64> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 35 matching lines @@
 static_assert(offsetof(GetBufferParameteri64v, params_shm_id) == 12,
               "offset of GetBufferParameteri64v params_shm_id should be 12");
 static_assert(
     offsetof(GetBufferParameteri64v, params_shm_offset) == 16,
     "offset of GetBufferParameteri64v params_shm_offset should be 16");
 
 struct GetBufferParameteriv {
   typedef GetBufferParameteriv ValueType;
   static const CommandId kCmdId = kGetBufferParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 34 matching lines @@
               "offset of GetBufferParameteriv pname should be 8");
 static_assert(offsetof(GetBufferParameteriv, params_shm_id) == 12,
               "offset of GetBufferParameteriv params_shm_id should be 12");
 static_assert(offsetof(GetBufferParameteriv, params_shm_offset) == 16,
               "offset of GetBufferParameteriv params_shm_offset should be 16");
 
 struct GetError {
   typedef GetError ValueType;
   static const CommandId kCmdId = kGetError;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLenum Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(uint32_t _result_shm_id, uint32_t _result_shm_offset) {
@@ skipping 17 matching lines @@
               "offset of GetError header should be 0");
 static_assert(offsetof(GetError, result_shm_id) == 4,
               "offset of GetError result_shm_id should be 4");
 static_assert(offsetof(GetError, result_shm_offset) == 8,
               "offset of GetError result_shm_offset should be 8");
 
 struct GetFloatv {
   typedef GetFloatv ValueType;
   static const CommandId kCmdId = kGetFloatv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname,
@@ skipping 27 matching lines @@
               "offset of GetFloatv pname should be 4");
 static_assert(offsetof(GetFloatv, params_shm_id) == 8,
               "offset of GetFloatv params_shm_id should be 8");
 static_assert(offsetof(GetFloatv, params_shm_offset) == 12,
               "offset of GetFloatv params_shm_offset should be 12");
 
 struct GetFragDataLocation {
   typedef GetFragDataLocation ValueType;
   static const CommandId kCmdId = kGetFragDataLocation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetFragDataLocation name_bucket_id should be 8");
 static_assert(offsetof(GetFragDataLocation, location_shm_id) == 12,
               "offset of GetFragDataLocation location_shm_id should be 12");
 static_assert(offsetof(GetFragDataLocation, location_shm_offset) == 16,
               "offset of GetFragDataLocation location_shm_offset should be 16");
 
 struct GetFramebufferAttachmentParameteriv {
   typedef GetFramebufferAttachmentParameteriv ValueType;
   static const CommandId kCmdId = kGetFramebufferAttachmentParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 47 matching lines @@
     "offset of GetFramebufferAttachmentParameteriv params_shm_id should be 16");
 static_assert(offsetof(GetFramebufferAttachmentParameteriv,
                        params_shm_offset) == 20,
               "offset of GetFramebufferAttachmentParameteriv params_shm_offset "
               "should be 20");
 
 struct GetInteger64v {
   typedef GetInteger64v ValueType;
   static const CommandId kCmdId = kGetInteger64v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint64> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname,
@@ skipping 28 matching lines @@
               "offset of GetInteger64v pname should be 4");
 static_assert(offsetof(GetInteger64v, params_shm_id) == 8,
               "offset of GetInteger64v params_shm_id should be 8");
 static_assert(offsetof(GetInteger64v, params_shm_offset) == 12,
               "offset of GetInteger64v params_shm_offset should be 12");
 
 struct GetIntegeri_v {
   typedef GetIntegeri_v ValueType;
   static const CommandId kCmdId = kGetIntegeri_v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname,
@@ skipping 34 matching lines @@
               "offset of GetIntegeri_v index should be 8");
 static_assert(offsetof(GetIntegeri_v, data_shm_id) == 12,
               "offset of GetIntegeri_v data_shm_id should be 12");
 static_assert(offsetof(GetIntegeri_v, data_shm_offset) == 16,
               "offset of GetIntegeri_v data_shm_offset should be 16");
 
 struct GetInteger64i_v {
   typedef GetInteger64i_v ValueType;
   static const CommandId kCmdId = kGetInteger64i_v;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint64> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname,
@@ skipping 34 matching lines @@
               "offset of GetInteger64i_v index should be 8");
 static_assert(offsetof(GetInteger64i_v, data_shm_id) == 12,
               "offset of GetInteger64i_v data_shm_id should be 12");
 static_assert(offsetof(GetInteger64i_v, data_shm_offset) == 16,
               "offset of GetInteger64i_v data_shm_offset should be 16");
 
 struct GetIntegerv {
   typedef GetIntegerv ValueType;
   static const CommandId kCmdId = kGetIntegerv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname,
@@ skipping 27 matching lines @@
               "offset of GetIntegerv pname should be 4");
 static_assert(offsetof(GetIntegerv, params_shm_id) == 8,
               "offset of GetIntegerv params_shm_id should be 8");
 static_assert(offsetof(GetIntegerv, params_shm_offset) == 12,
               "offset of GetIntegerv params_shm_offset should be 12");
 
 struct GetInternalformativ {
   typedef GetInternalformativ ValueType;
   static const CommandId kCmdId = kGetInternalformativ;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 40 matching lines @@
               "offset of GetInternalformativ pname should be 12");
 static_assert(offsetof(GetInternalformativ, params_shm_id) == 16,
               "offset of GetInternalformativ params_shm_id should be 16");
 static_assert(offsetof(GetInternalformativ, params_shm_offset) == 20,
               "offset of GetInternalformativ params_shm_offset should be 20");
 
 struct GetProgramiv {
   typedef GetProgramiv ValueType;
   static const CommandId kCmdId = kGetProgramiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 33 matching lines @@
               "offset of GetProgramiv pname should be 8");
 static_assert(offsetof(GetProgramiv, params_shm_id) == 12,
               "offset of GetProgramiv params_shm_id should be 12");
 static_assert(offsetof(GetProgramiv, params_shm_offset) == 16,
               "offset of GetProgramiv params_shm_offset should be 16");
 
 struct GetProgramInfoLog {
   typedef GetProgramInfoLog ValueType;
   static const CommandId kCmdId = kGetProgramInfoLog;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, uint32_t _bucket_id) {
     SetHeader();
     program = _program;
@@ skipping 16 matching lines @@
               "offset of GetProgramInfoLog header should be 0");
 static_assert(offsetof(GetProgramInfoLog, program) == 4,
               "offset of GetProgramInfoLog program should be 4");
 static_assert(offsetof(GetProgramInfoLog, bucket_id) == 8,
               "offset of GetProgramInfoLog bucket_id should be 8");
 
 struct GetRenderbufferParameteriv {
   typedef GetRenderbufferParameteriv ValueType;
   static const CommandId kCmdId = kGetRenderbufferParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 36 matching lines @@
     offsetof(GetRenderbufferParameteriv, params_shm_id) == 12,
     "offset of GetRenderbufferParameteriv params_shm_id should be 12");
 static_assert(
     offsetof(GetRenderbufferParameteriv, params_shm_offset) == 16,
     "offset of GetRenderbufferParameteriv params_shm_offset should be 16");
 
 struct GetSamplerParameterfv {
   typedef GetSamplerParameterfv ValueType;
   static const CommandId kCmdId = kGetSamplerParameterfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sampler,
@@ skipping 34 matching lines @@
               "offset of GetSamplerParameterfv pname should be 8");
 static_assert(offsetof(GetSamplerParameterfv, params_shm_id) == 12,
               "offset of GetSamplerParameterfv params_shm_id should be 12");
 static_assert(offsetof(GetSamplerParameterfv, params_shm_offset) == 16,
               "offset of GetSamplerParameterfv params_shm_offset should be 16");
 
 struct GetSamplerParameteriv {
   typedef GetSamplerParameteriv ValueType;
   static const CommandId kCmdId = kGetSamplerParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sampler,
@@ skipping 34 matching lines @@
               "offset of GetSamplerParameteriv pname should be 8");
 static_assert(offsetof(GetSamplerParameteriv, params_shm_id) == 12,
               "offset of GetSamplerParameteriv params_shm_id should be 12");
 static_assert(offsetof(GetSamplerParameteriv, params_shm_offset) == 16,
               "offset of GetSamplerParameteriv params_shm_offset should be 16");
 
 struct GetShaderiv {
   typedef GetShaderiv ValueType;
   static const CommandId kCmdId = kGetShaderiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader,
@@ skipping 33 matching lines @@
               "offset of GetShaderiv pname should be 8");
 static_assert(offsetof(GetShaderiv, params_shm_id) == 12,
               "offset of GetShaderiv params_shm_id should be 12");
 static_assert(offsetof(GetShaderiv, params_shm_offset) == 16,
               "offset of GetShaderiv params_shm_offset should be 16");
 
 struct GetShaderInfoLog {
   typedef GetShaderInfoLog ValueType;
   static const CommandId kCmdId = kGetShaderInfoLog;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader, uint32_t _bucket_id) {
     SetHeader();
     shader = _shader;
@@ skipping 16 matching lines @@
               "offset of GetShaderInfoLog header should be 0");
 static_assert(offsetof(GetShaderInfoLog, shader) == 4,
               "offset of GetShaderInfoLog shader should be 4");
 static_assert(offsetof(GetShaderInfoLog, bucket_id) == 8,
               "offset of GetShaderInfoLog bucket_id should be 8");
 
 struct GetShaderPrecisionFormat {
   typedef GetShaderPrecisionFormat ValueType;
   static const CommandId kCmdId = kGetShaderPrecisionFormat;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
     int32_t min_range;
     int32_t max_range;
     int32_t precision;
   };
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
@@ skipping 52 matching lines @@
               "offset of GetShaderPrecisionFormat Result max_range should be "
               "8");
 static_assert(offsetof(GetShaderPrecisionFormat::Result, precision) == 12,
               "offset of GetShaderPrecisionFormat Result precision should be "
               "12");
 
 struct GetShaderSource {
   typedef GetShaderSource ValueType;
   static const CommandId kCmdId = kGetShaderSource;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader, uint32_t _bucket_id) {
     SetHeader();
     shader = _shader;
@@ skipping 16 matching lines @@
               "offset of GetShaderSource header should be 0");
 static_assert(offsetof(GetShaderSource, shader) == 4,
               "offset of GetShaderSource shader should be 4");
 static_assert(offsetof(GetShaderSource, bucket_id) == 8,
               "offset of GetShaderSource bucket_id should be 8");
 
 struct GetString {
   typedef GetString ValueType;
   static const CommandId kCmdId = kGetString;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _name, uint32_t _bucket_id) {
     SetHeader();
     name = _name;
@@ skipping 15 matching lines @@
               "offset of GetString header should be 0");
 static_assert(offsetof(GetString, name) == 4,
               "offset of GetString name should be 4");
 static_assert(offsetof(GetString, bucket_id) == 8,
               "offset of GetString bucket_id should be 8");
 
 struct GetSynciv {
   typedef GetSynciv ValueType;
   static const CommandId kCmdId = kGetSynciv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync,
@@ skipping 33 matching lines @@
               "offset of GetSynciv pname should be 8");
 static_assert(offsetof(GetSynciv, values_shm_id) == 12,
               "offset of GetSynciv values_shm_id should be 12");
 static_assert(offsetof(GetSynciv, values_shm_offset) == 16,
               "offset of GetSynciv values_shm_offset should be 16");
 
 struct GetTexParameterfv {
   typedef GetTexParameterfv ValueType;
   static const CommandId kCmdId = kGetTexParameterfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 34 matching lines @@
               "offset of GetTexParameterfv pname should be 8");
 static_assert(offsetof(GetTexParameterfv, params_shm_id) == 12,
               "offset of GetTexParameterfv params_shm_id should be 12");
 static_assert(offsetof(GetTexParameterfv, params_shm_offset) == 16,
               "offset of GetTexParameterfv params_shm_offset should be 16");
 
 struct GetTexParameteriv {
   typedef GetTexParameteriv ValueType;
   static const CommandId kCmdId = kGetTexParameteriv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 34 matching lines @@
               "offset of GetTexParameteriv pname should be 8");
 static_assert(offsetof(GetTexParameteriv, params_shm_id) == 12,
               "offset of GetTexParameteriv params_shm_id should be 12");
 static_assert(offsetof(GetTexParameteriv, params_shm_offset) == 16,
               "offset of GetTexParameteriv params_shm_offset should be 16");
 
 struct GetTransformFeedbackVarying {
   typedef GetTransformFeedbackVarying ValueType;
   static const CommandId kCmdId = kGetTransformFeedbackVarying;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     int32_t success;
     int32_t size;
     uint32_t type;
   };
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
@@ skipping 56 matching lines @@
               "offset of GetTransformFeedbackVarying Result size should be "
               "4");
 static_assert(offsetof(GetTransformFeedbackVarying::Result, type) == 8,
               "offset of GetTransformFeedbackVarying Result type should be "
               "8");
 
 struct GetUniformBlockIndex {
   typedef GetUniformBlockIndex ValueType;
   static const CommandId kCmdId = kGetUniformBlockIndex;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLuint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetUniformBlockIndex name_bucket_id should be 8");
 static_assert(offsetof(GetUniformBlockIndex, index_shm_id) == 12,
               "offset of GetUniformBlockIndex index_shm_id should be 12");
 static_assert(offsetof(GetUniformBlockIndex, index_shm_offset) == 16,
               "offset of GetUniformBlockIndex index_shm_offset should be 16");
 
 struct GetUniformfv {
   typedef GetUniformfv ValueType;
   static const CommandId kCmdId = kGetUniformfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 33 matching lines @@
               "offset of GetUniformfv location should be 8");
 static_assert(offsetof(GetUniformfv, params_shm_id) == 12,
               "offset of GetUniformfv params_shm_id should be 12");
 static_assert(offsetof(GetUniformfv, params_shm_offset) == 16,
               "offset of GetUniformfv params_shm_offset should be 16");
 
 struct GetUniformiv {
   typedef GetUniformiv ValueType;
   static const CommandId kCmdId = kGetUniformiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 33 matching lines @@
               "offset of GetUniformiv location should be 8");
 static_assert(offsetof(GetUniformiv, params_shm_id) == 12,
               "offset of GetUniformiv params_shm_id should be 12");
 static_assert(offsetof(GetUniformiv, params_shm_offset) == 16,
               "offset of GetUniformiv params_shm_offset should be 16");
 
 struct GetUniformuiv {
   typedef GetUniformuiv ValueType;
   static const CommandId kCmdId = kGetUniformuiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetUniformuiv location should be 8");
 static_assert(offsetof(GetUniformuiv, params_shm_id) == 12,
               "offset of GetUniformuiv params_shm_id should be 12");
 static_assert(offsetof(GetUniformuiv, params_shm_offset) == 16,
               "offset of GetUniformuiv params_shm_offset should be 16");
 
 struct GetUniformIndices {
   typedef GetUniformIndices ValueType;
   static const CommandId kCmdId = kGetUniformIndices;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetUniformIndices names_bucket_id should be 8");
 static_assert(offsetof(GetUniformIndices, indices_shm_id) == 12,
               "offset of GetUniformIndices indices_shm_id should be 12");
 static_assert(offsetof(GetUniformIndices, indices_shm_offset) == 16,
               "offset of GetUniformIndices indices_shm_offset should be 16");
 
 struct GetUniformLocation {
   typedef GetUniformLocation ValueType;
   static const CommandId kCmdId = kGetUniformLocation;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 34 matching lines @@
               "offset of GetUniformLocation name_bucket_id should be 8");
 static_assert(offsetof(GetUniformLocation, location_shm_id) == 12,
               "offset of GetUniformLocation location_shm_id should be 12");
 static_assert(offsetof(GetUniformLocation, location_shm_offset) == 16,
               "offset of GetUniformLocation location_shm_offset should be 16");
 
 struct GetVertexAttribfv {
   typedef GetVertexAttribfv ValueType;
   static const CommandId kCmdId = kGetVertexAttribfv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLfloat> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index,
@@ skipping 34 matching lines @@
               "offset of GetVertexAttribfv pname should be 8");
 static_assert(offsetof(GetVertexAttribfv, params_shm_id) == 12,
               "offset of GetVertexAttribfv params_shm_id should be 12");
 static_assert(offsetof(GetVertexAttribfv, params_shm_offset) == 16,
               "offset of GetVertexAttribfv params_shm_offset should be 16");
 
 struct GetVertexAttribiv {
   typedef GetVertexAttribiv ValueType;
   static const CommandId kCmdId = kGetVertexAttribiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index,
@@ skipping 34 matching lines @@
               "offset of GetVertexAttribiv pname should be 8");
 static_assert(offsetof(GetVertexAttribiv, params_shm_id) == 12,
               "offset of GetVertexAttribiv params_shm_id should be 12");
 static_assert(offsetof(GetVertexAttribiv, params_shm_offset) == 16,
               "offset of GetVertexAttribiv params_shm_offset should be 16");
 
 struct GetVertexAttribIiv {
   typedef GetVertexAttribIiv ValueType;
   static const CommandId kCmdId = kGetVertexAttribIiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index,
@@ skipping 34 matching lines @@
               "offset of GetVertexAttribIiv pname should be 8");
 static_assert(offsetof(GetVertexAttribIiv, params_shm_id) == 12,
               "offset of GetVertexAttribIiv params_shm_id should be 12");
 static_assert(offsetof(GetVertexAttribIiv, params_shm_offset) == 16,
               "offset of GetVertexAttribIiv params_shm_offset should be 16");
 
 struct GetVertexAttribIuiv {
   typedef GetVertexAttribIuiv ValueType;
   static const CommandId kCmdId = kGetVertexAttribIuiv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index,
@@ skipping 34 matching lines @@
               "offset of GetVertexAttribIuiv pname should be 8");
 static_assert(offsetof(GetVertexAttribIuiv, params_shm_id) == 12,
               "offset of GetVertexAttribIuiv params_shm_id should be 12");
 static_assert(offsetof(GetVertexAttribIuiv, params_shm_offset) == 16,
               "offset of GetVertexAttribIuiv params_shm_offset should be 16");
 
 struct GetVertexAttribPointerv {
   typedef GetVertexAttribPointerv ValueType;
   static const CommandId kCmdId = kGetVertexAttribPointerv;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef SizedResult<GLuint> Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index,
@@ skipping 35 matching lines @@
 static_assert(offsetof(GetVertexAttribPointerv, pointer_shm_id) == 12,
               "offset of GetVertexAttribPointerv pointer_shm_id should be 12");
 static_assert(
     offsetof(GetVertexAttribPointerv, pointer_shm_offset) == 16,
     "offset of GetVertexAttribPointerv pointer_shm_offset should be 16");
 
 struct Hint {
   typedef Hint ValueType;
   static const CommandId kCmdId = kHint;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLenum _mode) {
     SetHeader();
     target = _target;
@@ skipping 12 matching lines @@
 
 static_assert(sizeof(Hint) == 12, "size of Hint should be 12");
 static_assert(offsetof(Hint, header) == 0, "offset of Hint header should be 0");
 static_assert(offsetof(Hint, target) == 4, "offset of Hint target should be 4");
 static_assert(offsetof(Hint, mode) == 8, "offset of Hint mode should be 8");
 
 struct InvalidateFramebufferImmediate {
   typedef InvalidateFramebufferImmediate ValueType;
   static const CommandId kCmdId = kInvalidateFramebufferImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 28 matching lines @@
               "offset of InvalidateFramebufferImmediate header should be 0");
 static_assert(offsetof(InvalidateFramebufferImmediate, target) == 4,
               "offset of InvalidateFramebufferImmediate target should be 4");
 static_assert(offsetof(InvalidateFramebufferImmediate, count) == 8,
               "offset of InvalidateFramebufferImmediate count should be 8");
 
 struct InvalidateSubFramebufferImmediate {
   typedef InvalidateSubFramebufferImmediate ValueType;
   static const CommandId kCmdId = kInvalidateSubFramebufferImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 56 matching lines @@
 static_assert(offsetof(InvalidateSubFramebufferImmediate, width) == 20,
               "offset of InvalidateSubFramebufferImmediate width should be 20");
 static_assert(
     offsetof(InvalidateSubFramebufferImmediate, height) == 24,
     "offset of InvalidateSubFramebufferImmediate height should be 24");
 
 struct IsBuffer {
   typedef IsBuffer ValueType;
   static const CommandId kCmdId = kIsBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _buffer,
@@ skipping 27 matching lines @@
               "offset of IsBuffer buffer should be 4");
 static_assert(offsetof(IsBuffer, result_shm_id) == 8,
               "offset of IsBuffer result_shm_id should be 8");
 static_assert(offsetof(IsBuffer, result_shm_offset) == 12,
               "offset of IsBuffer result_shm_offset should be 12");
 
 struct IsEnabled {
   typedef IsEnabled ValueType;
   static const CommandId kCmdId = kIsEnabled;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _cap, uint32_t _result_shm_id, uint32_t _result_shm_offset) {
@@ skipping 25 matching lines @@
               "offset of IsEnabled cap should be 4");
 static_assert(offsetof(IsEnabled, result_shm_id) == 8,
               "offset of IsEnabled result_shm_id should be 8");
 static_assert(offsetof(IsEnabled, result_shm_offset) == 12,
               "offset of IsEnabled result_shm_offset should be 12");
 
 struct IsFramebuffer {
   typedef IsFramebuffer ValueType;
   static const CommandId kCmdId = kIsFramebuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _framebuffer,
@@ skipping 28 matching lines @@
               "offset of IsFramebuffer framebuffer should be 4");
 static_assert(offsetof(IsFramebuffer, result_shm_id) == 8,
               "offset of IsFramebuffer result_shm_id should be 8");
 static_assert(offsetof(IsFramebuffer, result_shm_offset) == 12,
               "offset of IsFramebuffer result_shm_offset should be 12");
 
 struct IsProgram {
   typedef IsProgram ValueType;
   static const CommandId kCmdId = kIsProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 27 matching lines @@
               "offset of IsProgram program should be 4");
 static_assert(offsetof(IsProgram, result_shm_id) == 8,
               "offset of IsProgram result_shm_id should be 8");
 static_assert(offsetof(IsProgram, result_shm_offset) == 12,
               "offset of IsProgram result_shm_offset should be 12");
 
 struct IsRenderbuffer {
   typedef IsRenderbuffer ValueType;
   static const CommandId kCmdId = kIsRenderbuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _renderbuffer,
@@ skipping 28 matching lines @@
               "offset of IsRenderbuffer renderbuffer should be 4");
 static_assert(offsetof(IsRenderbuffer, result_shm_id) == 8,
               "offset of IsRenderbuffer result_shm_id should be 8");
 static_assert(offsetof(IsRenderbuffer, result_shm_offset) == 12,
               "offset of IsRenderbuffer result_shm_offset should be 12");
 
 struct IsSampler {
   typedef IsSampler ValueType;
   static const CommandId kCmdId = kIsSampler;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sampler,
@@ skipping 27 matching lines @@
               "offset of IsSampler sampler should be 4");
 static_assert(offsetof(IsSampler, result_shm_id) == 8,
               "offset of IsSampler result_shm_id should be 8");
 static_assert(offsetof(IsSampler, result_shm_offset) == 12,
               "offset of IsSampler result_shm_offset should be 12");
 
 struct IsShader {
   typedef IsShader ValueType;
   static const CommandId kCmdId = kIsShader;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader,
@@ skipping 27 matching lines @@
               "offset of IsShader shader should be 4");
 static_assert(offsetof(IsShader, result_shm_id) == 8,
               "offset of IsShader result_shm_id should be 8");
 static_assert(offsetof(IsShader, result_shm_offset) == 12,
               "offset of IsShader result_shm_offset should be 12");
 
 struct IsSync {
   typedef IsSync ValueType;
   static const CommandId kCmdId = kIsSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync,
@@ skipping 26 matching lines @@
 static_assert(offsetof(IsSync, sync) == 4, "offset of IsSync sync should be 4");
 static_assert(offsetof(IsSync, result_shm_id) == 8,
               "offset of IsSync result_shm_id should be 8");
 static_assert(offsetof(IsSync, result_shm_offset) == 12,
               "offset of IsSync result_shm_offset should be 12");
 
 struct IsTexture {
   typedef IsTexture ValueType;
   static const CommandId kCmdId = kIsTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _texture,
@@ skipping 27 matching lines @@
               "offset of IsTexture texture should be 4");
 static_assert(offsetof(IsTexture, result_shm_id) == 8,
               "offset of IsTexture result_shm_id should be 8");
 static_assert(offsetof(IsTexture, result_shm_offset) == 12,
               "offset of IsTexture result_shm_offset should be 12");
 
 struct IsTransformFeedback {
   typedef IsTransformFeedback ValueType;
   static const CommandId kCmdId = kIsTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _transformfeedback,
@@ skipping 28 matching lines @@
               "offset of IsTransformFeedback transformfeedback should be 4");
 static_assert(offsetof(IsTransformFeedback, result_shm_id) == 8,
               "offset of IsTransformFeedback result_shm_id should be 8");
 static_assert(offsetof(IsTransformFeedback, result_shm_offset) == 12,
               "offset of IsTransformFeedback result_shm_offset should be 12");
 
 struct LineWidth {
   typedef LineWidth ValueType;
   static const CommandId kCmdId = kLineWidth;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLfloat _width) {
     SetHeader();
     width = _width;
@@ skipping 11 matching lines @@
 static_assert(sizeof(LineWidth) == 8, "size of LineWidth should be 8");
 static_assert(offsetof(LineWidth, header) == 0,
               "offset of LineWidth header should be 0");
 static_assert(offsetof(LineWidth, width) == 4,
               "offset of LineWidth width should be 4");
 
 struct LinkProgram {
   typedef LinkProgram ValueType;
   static const CommandId kCmdId = kLinkProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
@@ skipping 11 matching lines @@
 static_assert(sizeof(LinkProgram) == 8, "size of LinkProgram should be 8");
 static_assert(offsetof(LinkProgram, header) == 0,
               "offset of LinkProgram header should be 0");
 static_assert(offsetof(LinkProgram, program) == 4,
               "offset of LinkProgram program should be 4");
 
 struct PauseTransformFeedback {
   typedef PauseTransformFeedback ValueType;
   static const CommandId kCmdId = kPauseTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(PauseTransformFeedback) == 4,
               "size of PauseTransformFeedback should be 4");
 static_assert(offsetof(PauseTransformFeedback, header) == 0,
               "offset of PauseTransformFeedback header should be 0");
 
 struct PixelStorei {
   typedef PixelStorei ValueType;
   static const CommandId kCmdId = kPixelStorei;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _pname, GLint _param) {
     SetHeader();
     pname = _pname;
@@ skipping 15 matching lines @@
               "offset of PixelStorei header should be 0");
 static_assert(offsetof(PixelStorei, pname) == 4,
               "offset of PixelStorei pname should be 4");
 static_assert(offsetof(PixelStorei, param) == 8,
               "offset of PixelStorei param should be 8");
 
 struct PolygonOffset {
   typedef PolygonOffset ValueType;
   static const CommandId kCmdId = kPolygonOffset;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLfloat _factor, GLfloat _units) {
     SetHeader();
     factor = _factor;
@@ skipping 16 matching lines @@
               "offset of PolygonOffset header should be 0");
 static_assert(offsetof(PolygonOffset, factor) == 4,
               "offset of PolygonOffset factor should be 4");
 static_assert(offsetof(PolygonOffset, units) == 8,
               "offset of PolygonOffset units should be 8");
 
 struct ReadBuffer {
   typedef ReadBuffer ValueType;
   static const CommandId kCmdId = kReadBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _src) {
     SetHeader();
     src = _src;
@@ skipping 14 matching lines @@
 static_assert(offsetof(ReadBuffer, src) == 4,
               "offset of ReadBuffer src should be 4");
 
 // ReadPixels has the result separated from the pixel buffer so that
 // it is easier to specify the result going to some specific place
 // that exactly fits the rectangle of pixels.
 struct ReadPixels {
   typedef ReadPixels ValueType;
   static const CommandId kCmdId = kReadPixels;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _x,
@@ skipping 76 matching lines @@
               "offset of ReadPixels result_shm_id should be 36");
 static_assert(offsetof(ReadPixels, result_shm_offset) == 40,
               "offset of ReadPixels result_shm_offset should be 40");
 static_assert(offsetof(ReadPixels, async) == 44,
               "offset of ReadPixels async should be 44");
 
 struct ReleaseShaderCompiler {
   typedef ReleaseShaderCompiler ValueType;
   static const CommandId kCmdId = kReleaseShaderCompiler;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(ReleaseShaderCompiler) == 4,
               "size of ReleaseShaderCompiler should be 4");
 static_assert(offsetof(ReleaseShaderCompiler, header) == 0,
               "offset of ReleaseShaderCompiler header should be 0");
 
 struct RenderbufferStorage {
   typedef RenderbufferStorage ValueType;
   static const CommandId kCmdId = kRenderbufferStorage;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _internalformat,
             GLsizei _width,
@@ skipping 32 matching lines @@
               "offset of RenderbufferStorage internalformat should be 8");
 static_assert(offsetof(RenderbufferStorage, width) == 12,
               "offset of RenderbufferStorage width should be 12");
 static_assert(offsetof(RenderbufferStorage, height) == 16,
               "offset of RenderbufferStorage height should be 16");
 
 struct ResumeTransformFeedback {
   typedef ResumeTransformFeedback ValueType;
   static const CommandId kCmdId = kResumeTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(ResumeTransformFeedback) == 4,
               "size of ResumeTransformFeedback should be 4");
 static_assert(offsetof(ResumeTransformFeedback, header) == 0,
               "offset of ResumeTransformFeedback header should be 0");
 
 struct SampleCoverage {
   typedef SampleCoverage ValueType;
   static const CommandId kCmdId = kSampleCoverage;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLclampf _value, GLboolean _invert) {
     SetHeader();
     value = _value;
@@ skipping 16 matching lines @@
               "offset of SampleCoverage header should be 0");
 static_assert(offsetof(SampleCoverage, value) == 4,
               "offset of SampleCoverage value should be 4");
 static_assert(offsetof(SampleCoverage, invert) == 8,
               "offset of SampleCoverage invert should be 8");
 
 struct SamplerParameterf {
   typedef SamplerParameterf ValueType;
   static const CommandId kCmdId = kSamplerParameterf;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sampler, GLenum _pname, GLfloat _param) {
     SetHeader();
     sampler = _sampler;
@@ skipping 20 matching lines @@
               "offset of SamplerParameterf sampler should be 4");
 static_assert(offsetof(SamplerParameterf, pname) == 8,
               "offset of SamplerParameterf pname should be 8");
 static_assert(offsetof(SamplerParameterf, param) == 12,
               "offset of SamplerParameterf param should be 12");
 
 struct SamplerParameterfvImmediate {
   typedef SamplerParameterfvImmediate ValueType;
   static const CommandId kCmdId = kSamplerParameterfvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 22 matching lines @@
               "offset of SamplerParameterfvImmediate header should be 0");
 static_assert(offsetof(SamplerParameterfvImmediate, sampler) == 4,
               "offset of SamplerParameterfvImmediate sampler should be 4");
 static_assert(offsetof(SamplerParameterfvImmediate, pname) == 8,
               "offset of SamplerParameterfvImmediate pname should be 8");
 
 struct SamplerParameteri {
   typedef SamplerParameteri ValueType;
   static const CommandId kCmdId = kSamplerParameteri;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sampler, GLenum _pname, GLint _param) {
     SetHeader();
     sampler = _sampler;
@@ skipping 20 matching lines @@
               "offset of SamplerParameteri sampler should be 4");
 static_assert(offsetof(SamplerParameteri, pname) == 8,
               "offset of SamplerParameteri pname should be 8");
 static_assert(offsetof(SamplerParameteri, param) == 12,
               "offset of SamplerParameteri param should be 12");
 
 struct SamplerParameterivImmediate {
   typedef SamplerParameterivImmediate ValueType;
   static const CommandId kCmdId = kSamplerParameterivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 1);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 22 matching lines @@
               "offset of SamplerParameterivImmediate header should be 0");
 static_assert(offsetof(SamplerParameterivImmediate, sampler) == 4,
               "offset of SamplerParameterivImmediate sampler should be 4");
 static_assert(offsetof(SamplerParameterivImmediate, pname) == 8,
               "offset of SamplerParameterivImmediate pname should be 8");
 
 struct Scissor {
   typedef Scissor ValueType;
   static const CommandId kCmdId = kScissor;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     SetHeader();
     x = _x;
@@ skipping 21 matching lines @@
 static_assert(offsetof(Scissor, y) == 8, "offset of Scissor y should be 8");
 static_assert(offsetof(Scissor, width) == 12,
               "offset of Scissor width should be 12");
 static_assert(offsetof(Scissor, height) == 16,
               "offset of Scissor height should be 16");
 
 struct ShaderBinary {
   typedef ShaderBinary ValueType;
   static const CommandId kCmdId = kShaderBinary;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _n,
             uint32_t _shaders_shm_id,
             uint32_t _shaders_shm_offset,
@@ skipping 50 matching lines @@
               "offset of ShaderBinary binary_shm_id should be 20");
 static_assert(offsetof(ShaderBinary, binary_shm_offset) == 24,
               "offset of ShaderBinary binary_shm_offset should be 24");
 static_assert(offsetof(ShaderBinary, length) == 28,
               "offset of ShaderBinary length should be 28");
 
 struct ShaderSourceBucket {
   typedef ShaderSourceBucket ValueType;
   static const CommandId kCmdId = kShaderSourceBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader, uint32_t _str_bucket_id) {
     SetHeader();
     shader = _shader;
@@ skipping 16 matching lines @@
               "offset of ShaderSourceBucket header should be 0");
 static_assert(offsetof(ShaderSourceBucket, shader) == 4,
               "offset of ShaderSourceBucket shader should be 4");
 static_assert(offsetof(ShaderSourceBucket, str_bucket_id) == 8,
               "offset of ShaderSourceBucket str_bucket_id should be 8");
 
 struct StencilFunc {
   typedef StencilFunc ValueType;
   static const CommandId kCmdId = kStencilFunc;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _func, GLint _ref, GLuint _mask) {
     SetHeader();
     func = _func;
@@ skipping 19 matching lines @@
               "offset of StencilFunc func should be 4");
 static_assert(offsetof(StencilFunc, ref) == 8,
               "offset of StencilFunc ref should be 8");
 static_assert(offsetof(StencilFunc, mask) == 12,
               "offset of StencilFunc mask should be 12");
 
 struct StencilFuncSeparate {
   typedef StencilFuncSeparate ValueType;
   static const CommandId kCmdId = kStencilFuncSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _face, GLenum _func, GLint _ref, GLuint _mask) {
     SetHeader();
     face = _face;
@@ skipping 24 matching lines @@
               "offset of StencilFuncSeparate func should be 8");
 static_assert(offsetof(StencilFuncSeparate, ref) == 12,
               "offset of StencilFuncSeparate ref should be 12");
 static_assert(offsetof(StencilFuncSeparate, mask) == 16,
               "offset of StencilFuncSeparate mask should be 16");
 
 struct StencilMask {
   typedef StencilMask ValueType;
   static const CommandId kCmdId = kStencilMask;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _mask) {
     SetHeader();
     mask = _mask;
@@ skipping 11 matching lines @@
 static_assert(sizeof(StencilMask) == 8, "size of StencilMask should be 8");
 static_assert(offsetof(StencilMask, header) == 0,
               "offset of StencilMask header should be 0");
 static_assert(offsetof(StencilMask, mask) == 4,
               "offset of StencilMask mask should be 4");
 
 struct StencilMaskSeparate {
   typedef StencilMaskSeparate ValueType;
   static const CommandId kCmdId = kStencilMaskSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _face, GLuint _mask) {
     SetHeader();
     face = _face;
@@ skipping 16 matching lines @@
               "offset of StencilMaskSeparate header should be 0");
 static_assert(offsetof(StencilMaskSeparate, face) == 4,
               "offset of StencilMaskSeparate face should be 4");
 static_assert(offsetof(StencilMaskSeparate, mask) == 8,
               "offset of StencilMaskSeparate mask should be 8");
 
 struct StencilOp {
   typedef StencilOp ValueType;
   static const CommandId kCmdId = kStencilOp;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _fail, GLenum _zfail, GLenum _zpass) {
     SetHeader();
     fail = _fail;
@@ skipping 19 matching lines @@
               "offset of StencilOp fail should be 4");
 static_assert(offsetof(StencilOp, zfail) == 8,
               "offset of StencilOp zfail should be 8");
 static_assert(offsetof(StencilOp, zpass) == 12,
               "offset of StencilOp zpass should be 12");
 
 struct StencilOpSeparate {
   typedef StencilOpSeparate ValueType;
   static const CommandId kCmdId = kStencilOpSeparate;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) {
     SetHeader();
     face = _face;
@@ skipping 28 matching lines @@
               "offset of StencilOpSeparate fail should be 8");
 static_assert(offsetof(StencilOpSeparate, zfail) == 12,
               "offset of StencilOpSeparate zfail should be 12");
 static_assert(offsetof(StencilOpSeparate, zpass) == 16,
               "offset of StencilOpSeparate zpass should be 16");
 
 struct TexImage2D {
   typedef TexImage2D ValueType;
   static const CommandId kCmdId = kTexImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _internalformat,
@@ skipping 63 matching lines @@
               "offset of TexImage2D type should be 28");
 static_assert(offsetof(TexImage2D, pixels_shm_id) == 32,
               "offset of TexImage2D pixels_shm_id should be 32");
 static_assert(offsetof(TexImage2D, pixels_shm_offset) == 36,
               "offset of TexImage2D pixels_shm_offset should be 36");
 
 struct TexImage3D {
   typedef TexImage3D ValueType;
   static const CommandId kCmdId = kTexImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _internalformat,
@@ skipping 69 matching lines @@
               "offset of TexImage3D type should be 32");
 static_assert(offsetof(TexImage3D, pixels_shm_id) == 36,
               "offset of TexImage3D pixels_shm_id should be 36");
 static_assert(offsetof(TexImage3D, pixels_shm_offset) == 40,
               "offset of TexImage3D pixels_shm_offset should be 40");
 
 struct TexParameterf {
   typedef TexParameterf ValueType;
   static const CommandId kCmdId = kTexParameterf;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLenum _pname, GLfloat _param) {
     SetHeader();
     target = _target;
@@ skipping 20 matching lines @@
               "offset of TexParameterf target should be 4");
 static_assert(offsetof(TexParameterf, pname) == 8,
               "offset of TexParameterf pname should be 8");
 static_assert(offsetof(TexParameterf, param) == 12,
               "offset of TexParameterf param should be 12");
 
 struct TexParameterfvImmediate {
   typedef TexParameterfvImmediate ValueType;
   static const CommandId kCmdId = kTexParameterfvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 22 matching lines @@
               "offset of TexParameterfvImmediate header should be 0");
 static_assert(offsetof(TexParameterfvImmediate, target) == 4,
               "offset of TexParameterfvImmediate target should be 4");
 static_assert(offsetof(TexParameterfvImmediate, pname) == 8,
               "offset of TexParameterfvImmediate pname should be 8");
 
 struct TexParameteri {
   typedef TexParameteri ValueType;
   static const CommandId kCmdId = kTexParameteri;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLenum _pname, GLint _param) {
     SetHeader();
     target = _target;
@@ skipping 20 matching lines @@
               "offset of TexParameteri target should be 4");
 static_assert(offsetof(TexParameteri, pname) == 8,
               "offset of TexParameteri pname should be 8");
 static_assert(offsetof(TexParameteri, param) == 12,
               "offset of TexParameteri param should be 12");
 
 struct TexParameterivImmediate {
   typedef TexParameterivImmediate ValueType;
   static const CommandId kCmdId = kTexParameterivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 1);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 22 matching lines @@
               "offset of TexParameterivImmediate header should be 0");
 static_assert(offsetof(TexParameterivImmediate, target) == 4,
               "offset of TexParameterivImmediate target should be 4");
 static_assert(offsetof(TexParameterivImmediate, pname) == 8,
               "offset of TexParameterivImmediate pname should be 8");
 
 struct TexStorage3D {
   typedef TexStorage3D ValueType;
   static const CommandId kCmdId = kTexStorage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLsizei _levels,
             GLenum _internalFormat,
@@ skipping 43 matching lines @@
               "offset of TexStorage3D width should be 16");
 static_assert(offsetof(TexStorage3D, height) == 20,
               "offset of TexStorage3D height should be 20");
 static_assert(offsetof(TexStorage3D, depth) == 24,
               "offset of TexStorage3D depth should be 24");
 
 struct TexSubImage2D {
   typedef TexSubImage2D ValueType;
   static const CommandId kCmdId = kTexSubImage2D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 75 matching lines @@
               "offset of TexSubImage2D pixels_shm_id should be 36");
 static_assert(offsetof(TexSubImage2D, pixels_shm_offset) == 40,
               "offset of TexSubImage2D pixels_shm_offset should be 40");
 static_assert(offsetof(TexSubImage2D, internal) == 44,
               "offset of TexSubImage2D internal should be 44");
 
 struct TexSubImage3D {
   typedef TexSubImage3D ValueType;
   static const CommandId kCmdId = kTexSubImage3D;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLint _level,
             GLint _xoffset,
@@ skipping 87 matching lines @@
               "offset of TexSubImage3D pixels_shm_id should be 44");
 static_assert(offsetof(TexSubImage3D, pixels_shm_offset) == 48,
               "offset of TexSubImage3D pixels_shm_offset should be 48");
 static_assert(offsetof(TexSubImage3D, internal) == 52,
               "offset of TexSubImage3D internal should be 52");
 
 struct TransformFeedbackVaryingsBucket {
   typedef TransformFeedbackVaryingsBucket ValueType;
   static const CommandId kCmdId = kTransformFeedbackVaryingsBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, uint32_t _varyings_bucket_id, GLenum _buffermode) {
     SetHeader();
     program = _program;
@@ skipping 26 matching lines @@
     offsetof(TransformFeedbackVaryingsBucket, varyings_bucket_id) == 8,
     "offset of TransformFeedbackVaryingsBucket varyings_bucket_id should be 8");
 static_assert(
     offsetof(TransformFeedbackVaryingsBucket, buffermode) == 12,
     "offset of TransformFeedbackVaryingsBucket buffermode should be 12");
 
 struct Uniform1f {
   typedef Uniform1f ValueType;
   static const CommandId kCmdId = kUniform1f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLfloat _x) {
     SetHeader();
     location = _location;
@@ skipping 14 matching lines @@
 static_assert(offsetof(Uniform1f, header) == 0,
               "offset of Uniform1f header should be 0");
 static_assert(offsetof(Uniform1f, location) == 4,
               "offset of Uniform1f location should be 4");
 static_assert(offsetof(Uniform1f, x) == 8, "offset of Uniform1f x should be 8");
 
 struct Uniform1fvImmediate {
   typedef Uniform1fvImmediate ValueType;
   static const CommandId kCmdId = kUniform1fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform1fvImmediate header should be 0");
 static_assert(offsetof(Uniform1fvImmediate, location) == 4,
               "offset of Uniform1fvImmediate location should be 4");
 static_assert(offsetof(Uniform1fvImmediate, count) == 8,
               "offset of Uniform1fvImmediate count should be 8");
 
 struct Uniform1i {
   typedef Uniform1i ValueType;
   static const CommandId kCmdId = kUniform1i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLint _x) {
     SetHeader();
     location = _location;
@@ skipping 14 matching lines @@
 static_assert(offsetof(Uniform1i, header) == 0,
               "offset of Uniform1i header should be 0");
 static_assert(offsetof(Uniform1i, location) == 4,
               "offset of Uniform1i location should be 4");
 static_assert(offsetof(Uniform1i, x) == 8, "offset of Uniform1i x should be 8");
 
 struct Uniform1ivImmediate {
   typedef Uniform1ivImmediate ValueType;
   static const CommandId kCmdId = kUniform1ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform1ivImmediate header should be 0");
 static_assert(offsetof(Uniform1ivImmediate, location) == 4,
               "offset of Uniform1ivImmediate location should be 4");
 static_assert(offsetof(Uniform1ivImmediate, count) == 8,
               "offset of Uniform1ivImmediate count should be 8");
 
 struct Uniform1ui {
   typedef Uniform1ui ValueType;
   static const CommandId kCmdId = kUniform1ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLuint _x) {
     SetHeader();
     location = _location;
@@ skipping 15 matching lines @@
               "offset of Uniform1ui header should be 0");
 static_assert(offsetof(Uniform1ui, location) == 4,
               "offset of Uniform1ui location should be 4");
 static_assert(offsetof(Uniform1ui, x) == 8,
               "offset of Uniform1ui x should be 8");
 
 struct Uniform1uivImmediate {
   typedef Uniform1uivImmediate ValueType;
   static const CommandId kCmdId = kUniform1uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform1uivImmediate header should be 0");
 static_assert(offsetof(Uniform1uivImmediate, location) == 4,
               "offset of Uniform1uivImmediate location should be 4");
 static_assert(offsetof(Uniform1uivImmediate, count) == 8,
               "offset of Uniform1uivImmediate count should be 8");
 
 struct Uniform2f {
   typedef Uniform2f ValueType;
   static const CommandId kCmdId = kUniform2f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLfloat _x, GLfloat _y) {
     SetHeader();
     location = _location;
@@ skipping 18 matching lines @@
 static_assert(offsetof(Uniform2f, location) == 4,
               "offset of Uniform2f location should be 4");
 static_assert(offsetof(Uniform2f, x) == 8, "offset of Uniform2f x should be 8");
 static_assert(offsetof(Uniform2f, y) == 12,
               "offset of Uniform2f y should be 12");
 
 struct Uniform2fvImmediate {
   typedef Uniform2fvImmediate ValueType;
   static const CommandId kCmdId = kUniform2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 2 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform2fvImmediate header should be 0");
 static_assert(offsetof(Uniform2fvImmediate, location) == 4,
               "offset of Uniform2fvImmediate location should be 4");
 static_assert(offsetof(Uniform2fvImmediate, count) == 8,
               "offset of Uniform2fvImmediate count should be 8");
 
 struct Uniform2i {
   typedef Uniform2i ValueType;
   static const CommandId kCmdId = kUniform2i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLint _x, GLint _y) {
     SetHeader();
     location = _location;
@@ skipping 18 matching lines @@
 static_assert(offsetof(Uniform2i, location) == 4,
               "offset of Uniform2i location should be 4");
 static_assert(offsetof(Uniform2i, x) == 8, "offset of Uniform2i x should be 8");
 static_assert(offsetof(Uniform2i, y) == 12,
               "offset of Uniform2i y should be 12");
 
 struct Uniform2ivImmediate {
   typedef Uniform2ivImmediate ValueType;
   static const CommandId kCmdId = kUniform2ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 2 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform2ivImmediate header should be 0");
 static_assert(offsetof(Uniform2ivImmediate, location) == 4,
               "offset of Uniform2ivImmediate location should be 4");
 static_assert(offsetof(Uniform2ivImmediate, count) == 8,
               "offset of Uniform2ivImmediate count should be 8");
 
 struct Uniform2ui {
   typedef Uniform2ui ValueType;
   static const CommandId kCmdId = kUniform2ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLuint _x, GLuint _y) {
     SetHeader();
     location = _location;
@@ skipping 19 matching lines @@
               "offset of Uniform2ui location should be 4");
 static_assert(offsetof(Uniform2ui, x) == 8,
               "offset of Uniform2ui x should be 8");
 static_assert(offsetof(Uniform2ui, y) == 12,
               "offset of Uniform2ui y should be 12");
 
 struct Uniform2uivImmediate {
   typedef Uniform2uivImmediate ValueType;
   static const CommandId kCmdId = kUniform2uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 2 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform2uivImmediate header should be 0");
 static_assert(offsetof(Uniform2uivImmediate, location) == 4,
               "offset of Uniform2uivImmediate location should be 4");
 static_assert(offsetof(Uniform2uivImmediate, count) == 8,
               "offset of Uniform2uivImmediate count should be 8");
 
 struct Uniform3f {
   typedef Uniform3f ValueType;
   static const CommandId kCmdId = kUniform3f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) {
     SetHeader();
     location = _location;
@@ skipping 22 matching lines @@
 static_assert(offsetof(Uniform3f, x) == 8, "offset of Uniform3f x should be 8");
 static_assert(offsetof(Uniform3f, y) == 12,
               "offset of Uniform3f y should be 12");
 static_assert(offsetof(Uniform3f, z) == 16,
               "offset of Uniform3f z should be 16");
 
 struct Uniform3fvImmediate {
   typedef Uniform3fvImmediate ValueType;
   static const CommandId kCmdId = kUniform3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 3 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform3fvImmediate header should be 0");
 static_assert(offsetof(Uniform3fvImmediate, location) == 4,
               "offset of Uniform3fvImmediate location should be 4");
 static_assert(offsetof(Uniform3fvImmediate, count) == 8,
               "offset of Uniform3fvImmediate count should be 8");
 
 struct Uniform3i {
   typedef Uniform3i ValueType;
   static const CommandId kCmdId = kUniform3i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLint _x, GLint _y, GLint _z) {
     SetHeader();
     location = _location;
@@ skipping 22 matching lines @@
 static_assert(offsetof(Uniform3i, x) == 8, "offset of Uniform3i x should be 8");
 static_assert(offsetof(Uniform3i, y) == 12,
               "offset of Uniform3i y should be 12");
 static_assert(offsetof(Uniform3i, z) == 16,
               "offset of Uniform3i z should be 16");
 
 struct Uniform3ivImmediate {
   typedef Uniform3ivImmediate ValueType;
   static const CommandId kCmdId = kUniform3ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 3 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform3ivImmediate header should be 0");
 static_assert(offsetof(Uniform3ivImmediate, location) == 4,
               "offset of Uniform3ivImmediate location should be 4");
 static_assert(offsetof(Uniform3ivImmediate, count) == 8,
               "offset of Uniform3ivImmediate count should be 8");
 
 struct Uniform3ui {
   typedef Uniform3ui ValueType;
   static const CommandId kCmdId = kUniform3ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLuint _x, GLuint _y, GLuint _z) {
     SetHeader();
     location = _location;
@@ skipping 23 matching lines @@
               "offset of Uniform3ui x should be 8");
 static_assert(offsetof(Uniform3ui, y) == 12,
               "offset of Uniform3ui y should be 12");
 static_assert(offsetof(Uniform3ui, z) == 16,
               "offset of Uniform3ui z should be 16");
 
 struct Uniform3uivImmediate {
   typedef Uniform3uivImmediate ValueType;
   static const CommandId kCmdId = kUniform3uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 3 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform3uivImmediate header should be 0");
 static_assert(offsetof(Uniform3uivImmediate, location) == 4,
               "offset of Uniform3uivImmediate location should be 4");
 static_assert(offsetof(Uniform3uivImmediate, count) == 8,
               "offset of Uniform3uivImmediate count should be 8");
 
 struct Uniform4f {
   typedef Uniform4f ValueType;
   static const CommandId kCmdId = kUniform4f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
     SetHeader();
     location = _location;
@@ skipping 31 matching lines @@
               "offset of Uniform4f y should be 12");
 static_assert(offsetof(Uniform4f, z) == 16,
               "offset of Uniform4f z should be 16");
 static_assert(offsetof(Uniform4f, w) == 20,
               "offset of Uniform4f w should be 20");
 
 struct Uniform4fvImmediate {
   typedef Uniform4fvImmediate ValueType;
   static const CommandId kCmdId = kUniform4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform4fvImmediate header should be 0");
 static_assert(offsetof(Uniform4fvImmediate, location) == 4,
               "offset of Uniform4fvImmediate location should be 4");
 static_assert(offsetof(Uniform4fvImmediate, count) == 8,
               "offset of Uniform4fvImmediate count should be 8");
 
 struct Uniform4i {
   typedef Uniform4i ValueType;
   static const CommandId kCmdId = kUniform4i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) {
     SetHeader();
     location = _location;
@@ skipping 31 matching lines @@
               "offset of Uniform4i y should be 12");
 static_assert(offsetof(Uniform4i, z) == 16,
               "offset of Uniform4i z should be 16");
 static_assert(offsetof(Uniform4i, w) == 20,
               "offset of Uniform4i w should be 20");
 
 struct Uniform4ivImmediate {
   typedef Uniform4ivImmediate ValueType;
   static const CommandId kCmdId = kUniform4ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLint) * 4 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform4ivImmediate header should be 0");
 static_assert(offsetof(Uniform4ivImmediate, location) == 4,
               "offset of Uniform4ivImmediate location should be 4");
 static_assert(offsetof(Uniform4ivImmediate, count) == 8,
               "offset of Uniform4ivImmediate count should be 8");
 
 struct Uniform4ui {
   typedef Uniform4ui ValueType;
   static const CommandId kCmdId = kUniform4ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLuint _x, GLuint _y, GLuint _z, GLuint _w) {
     SetHeader();
     location = _location;
@@ skipping 32 matching lines @@
               "offset of Uniform4ui y should be 12");
 static_assert(offsetof(Uniform4ui, z) == 16,
               "offset of Uniform4ui z should be 16");
 static_assert(offsetof(Uniform4ui, w) == 20,
               "offset of Uniform4ui w should be 20");
 
 struct Uniform4uivImmediate {
   typedef Uniform4uivImmediate ValueType;
   static const CommandId kCmdId = kUniform4uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLuint) * 4 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 25 matching lines @@
               "offset of Uniform4uivImmediate header should be 0");
 static_assert(offsetof(Uniform4uivImmediate, location) == 4,
               "offset of Uniform4uivImmediate location should be 4");
 static_assert(offsetof(Uniform4uivImmediate, count) == 8,
               "offset of Uniform4uivImmediate count should be 8");
 
 struct UniformBlockBinding {
   typedef UniformBlockBinding ValueType;
   static const CommandId kCmdId = kUniformBlockBinding;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLuint _index, GLuint _binding) {
     SetHeader();
     program = _program;
@@ skipping 20 matching lines @@
               "offset of UniformBlockBinding program should be 4");
 static_assert(offsetof(UniformBlockBinding, index) == 8,
               "offset of UniformBlockBinding index should be 8");
 static_assert(offsetof(UniformBlockBinding, binding) == 12,
               "offset of UniformBlockBinding binding should be 12");
 
 struct UniformMatrix2fvImmediate {
   typedef UniformMatrix2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix2fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix2fvImmediate, location) == 4,
               "offset of UniformMatrix2fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix2fvImmediate, count) == 8,
               "offset of UniformMatrix2fvImmediate count should be 8");
 
 struct UniformMatrix2x3fvImmediate {
   typedef UniformMatrix2x3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2x3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 6 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix2x3fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix2x3fvImmediate, location) == 4,
               "offset of UniformMatrix2x3fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix2x3fvImmediate, count) == 8,
               "offset of UniformMatrix2x3fvImmediate count should be 8");
 
 struct UniformMatrix2x4fvImmediate {
   typedef UniformMatrix2x4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix2x4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 8 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix2x4fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix2x4fvImmediate, location) == 4,
               "offset of UniformMatrix2x4fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix2x4fvImmediate, count) == 8,
               "offset of UniformMatrix2x4fvImmediate count should be 8");
 
 struct UniformMatrix3fvImmediate {
   typedef UniformMatrix3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 9 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix3fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix3fvImmediate, location) == 4,
               "offset of UniformMatrix3fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix3fvImmediate, count) == 8,
               "offset of UniformMatrix3fvImmediate count should be 8");
 
 struct UniformMatrix3x2fvImmediate {
   typedef UniformMatrix3x2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3x2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 6 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix3x2fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix3x2fvImmediate, location) == 4,
               "offset of UniformMatrix3x2fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix3x2fvImmediate, count) == 8,
               "offset of UniformMatrix3x2fvImmediate count should be 8");
 
 struct UniformMatrix3x4fvImmediate {
   typedef UniformMatrix3x4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix3x4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 12 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix3x4fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix3x4fvImmediate, location) == 4,
               "offset of UniformMatrix3x4fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix3x4fvImmediate, count) == 8,
               "offset of UniformMatrix3x4fvImmediate count should be 8");
 
 struct UniformMatrix4fvImmediate {
   typedef UniformMatrix4fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 16 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix4fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix4fvImmediate, location) == 4,
               "offset of UniformMatrix4fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix4fvImmediate, count) == 8,
               "offset of UniformMatrix4fvImmediate count should be 8");
 
 struct UniformMatrix4x2fvImmediate {
   typedef UniformMatrix4x2fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4x2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 8 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix4x2fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix4x2fvImmediate, location) == 4,
               "offset of UniformMatrix4x2fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix4x2fvImmediate, count) == 8,
               "offset of UniformMatrix4x2fvImmediate count should be 8");
 
 struct UniformMatrix4x3fvImmediate {
   typedef UniformMatrix4x3fvImmediate ValueType;
   static const CommandId kCmdId = kUniformMatrix4x3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLfloat) * 12 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 26 matching lines @@
               "offset of UniformMatrix4x3fvImmediate header should be 0");
 static_assert(offsetof(UniformMatrix4x3fvImmediate, location) == 4,
               "offset of UniformMatrix4x3fvImmediate location should be 4");
 static_assert(offsetof(UniformMatrix4x3fvImmediate, count) == 8,
               "offset of UniformMatrix4x3fvImmediate count should be 8");
 
 struct UseProgram {
   typedef UseProgram ValueType;
   static const CommandId kCmdId = kUseProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
@@ skipping 11 matching lines @@
 static_assert(sizeof(UseProgram) == 8, "size of UseProgram should be 8");
 static_assert(offsetof(UseProgram, header) == 0,
               "offset of UseProgram header should be 0");
 static_assert(offsetof(UseProgram, program) == 4,
               "offset of UseProgram program should be 4");
 
 struct ValidateProgram {
   typedef ValidateProgram ValueType;
   static const CommandId kCmdId = kValidateProgram;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
@@ skipping 12 matching lines @@
               "size of ValidateProgram should be 8");
 static_assert(offsetof(ValidateProgram, header) == 0,
               "offset of ValidateProgram header should be 0");
 static_assert(offsetof(ValidateProgram, program) == 4,
               "offset of ValidateProgram program should be 4");
 
 struct VertexAttrib1f {
   typedef VertexAttrib1f ValueType;
   static const CommandId kCmdId = kVertexAttrib1f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx, GLfloat _x) {
     SetHeader();
     indx = _indx;
@@ skipping 16 matching lines @@
               "offset of VertexAttrib1f header should be 0");
 static_assert(offsetof(VertexAttrib1f, indx) == 4,
               "offset of VertexAttrib1f indx should be 4");
 static_assert(offsetof(VertexAttrib1f, x) == 8,
               "offset of VertexAttrib1f x should be 8");
 
 struct VertexAttrib1fvImmediate {
   typedef VertexAttrib1fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib1fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 1);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of VertexAttrib1fvImmediate should be 8");
 static_assert(offsetof(VertexAttrib1fvImmediate, header) == 0,
               "offset of VertexAttrib1fvImmediate header should be 0");
 static_assert(offsetof(VertexAttrib1fvImmediate, indx) == 4,
               "offset of VertexAttrib1fvImmediate indx should be 4");
 
 struct VertexAttrib2f {
   typedef VertexAttrib2f ValueType;
   static const CommandId kCmdId = kVertexAttrib2f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx, GLfloat _x, GLfloat _y) {
     SetHeader();
     indx = _indx;
@@ skipping 20 matching lines @@
               "offset of VertexAttrib2f indx should be 4");
 static_assert(offsetof(VertexAttrib2f, x) == 8,
               "offset of VertexAttrib2f x should be 8");
 static_assert(offsetof(VertexAttrib2f, y) == 12,
               "offset of VertexAttrib2f y should be 12");
 
 struct VertexAttrib2fvImmediate {
   typedef VertexAttrib2fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib2fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 2);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of VertexAttrib2fvImmediate should be 8");
 static_assert(offsetof(VertexAttrib2fvImmediate, header) == 0,
               "offset of VertexAttrib2fvImmediate header should be 0");
 static_assert(offsetof(VertexAttrib2fvImmediate, indx) == 4,
               "offset of VertexAttrib2fvImmediate indx should be 4");
 
 struct VertexAttrib3f {
   typedef VertexAttrib3f ValueType;
   static const CommandId kCmdId = kVertexAttrib3f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) {
     SetHeader();
     indx = _indx;
@@ skipping 24 matching lines @@
               "offset of VertexAttrib3f x should be 8");
 static_assert(offsetof(VertexAttrib3f, y) == 12,
               "offset of VertexAttrib3f y should be 12");
 static_assert(offsetof(VertexAttrib3f, z) == 16,
               "offset of VertexAttrib3f z should be 16");
 
 struct VertexAttrib3fvImmediate {
   typedef VertexAttrib3fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib3fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 3);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of VertexAttrib3fvImmediate should be 8");
 static_assert(offsetof(VertexAttrib3fvImmediate, header) == 0,
               "offset of VertexAttrib3fvImmediate header should be 0");
 static_assert(offsetof(VertexAttrib3fvImmediate, indx) == 4,
               "offset of VertexAttrib3fvImmediate indx should be 4");
 
 struct VertexAttrib4f {
   typedef VertexAttrib4f ValueType;
   static const CommandId kCmdId = kVertexAttrib4f;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z, GLfloat _w) {
     SetHeader();
     indx = _indx;
@@ skipping 33 matching lines @@
               "offset of VertexAttrib4f y should be 12");
 static_assert(offsetof(VertexAttrib4f, z) == 16,
               "offset of VertexAttrib4f z should be 16");
 static_assert(offsetof(VertexAttrib4f, w) == 20,
               "offset of VertexAttrib4f w should be 20");
 
 struct VertexAttrib4fvImmediate {
   typedef VertexAttrib4fvImmediate ValueType;
   static const CommandId kCmdId = kVertexAttrib4fvImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 4);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of VertexAttrib4fvImmediate should be 8");
 static_assert(offsetof(VertexAttrib4fvImmediate, header) == 0,
               "offset of VertexAttrib4fvImmediate header should be 0");
 static_assert(offsetof(VertexAttrib4fvImmediate, indx) == 4,
               "offset of VertexAttrib4fvImmediate indx should be 4");
 
 struct VertexAttribI4i {
   typedef VertexAttribI4i ValueType;
   static const CommandId kCmdId = kVertexAttribI4i;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx, GLint _x, GLint _y, GLint _z, GLint _w) {
     SetHeader();
     indx = _indx;
@@ skipping 28 matching lines @@
               "offset of VertexAttribI4i y should be 12");
 static_assert(offsetof(VertexAttribI4i, z) == 16,
               "offset of VertexAttribI4i z should be 16");
 static_assert(offsetof(VertexAttribI4i, w) == 20,
               "offset of VertexAttribI4i w should be 20");
 
 struct VertexAttribI4ivImmediate {
   typedef VertexAttribI4ivImmediate ValueType;
   static const CommandId kCmdId = kVertexAttribI4ivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLint) * 4);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of VertexAttribI4ivImmediate should be 8");
 static_assert(offsetof(VertexAttribI4ivImmediate, header) == 0,
               "offset of VertexAttribI4ivImmediate header should be 0");
 static_assert(offsetof(VertexAttribI4ivImmediate, indx) == 4,
               "offset of VertexAttribI4ivImmediate indx should be 4");
 
 struct VertexAttribI4ui {
   typedef VertexAttribI4ui ValueType;
   static const CommandId kCmdId = kVertexAttribI4ui;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx, GLuint _x, GLuint _y, GLuint _z, GLuint _w) {
     SetHeader();
     indx = _indx;
@@ skipping 33 matching lines @@
               "offset of VertexAttribI4ui y should be 12");
 static_assert(offsetof(VertexAttribI4ui, z) == 16,
               "offset of VertexAttribI4ui z should be 16");
 static_assert(offsetof(VertexAttribI4ui, w) == 20,
               "offset of VertexAttribI4ui w should be 20");
 
 struct VertexAttribI4uivImmediate {
   typedef VertexAttribI4uivImmediate ValueType;
   static const CommandId kCmdId = kVertexAttribI4uivImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLuint) * 4);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of VertexAttribI4uivImmediate should be 8");
 static_assert(offsetof(VertexAttribI4uivImmediate, header) == 0,
               "offset of VertexAttribI4uivImmediate header should be 0");
 static_assert(offsetof(VertexAttribI4uivImmediate, indx) == 4,
               "offset of VertexAttribI4uivImmediate indx should be 4");
 
 struct VertexAttribIPointer {
   typedef VertexAttribIPointer ValueType;
   static const CommandId kCmdId = kVertexAttribIPointer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx,
             GLint _size,
             GLenum _type,
@@ skipping 37 matching lines @@
               "offset of VertexAttribIPointer type should be 12");
 static_assert(offsetof(VertexAttribIPointer, stride) == 16,
               "offset of VertexAttribIPointer stride should be 16");
 static_assert(offsetof(VertexAttribIPointer, offset) == 20,
               "offset of VertexAttribIPointer offset should be 20");
 
 struct VertexAttribPointer {
   typedef VertexAttribPointer ValueType;
   static const CommandId kCmdId = kVertexAttribPointer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _indx,
             GLint _size,
             GLenum _type,
@@ skipping 44 matching lines @@
               "offset of VertexAttribPointer normalized should be 16");
 static_assert(offsetof(VertexAttribPointer, stride) == 20,
               "offset of VertexAttribPointer stride should be 20");
 static_assert(offsetof(VertexAttribPointer, offset) == 24,
               "offset of VertexAttribPointer offset should be 24");
 
 struct Viewport {
   typedef Viewport ValueType;
   static const CommandId kCmdId = kViewport;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     SetHeader();
     x = _x;
@@ skipping 21 matching lines @@
 static_assert(offsetof(Viewport, y) == 8, "offset of Viewport y should be 8");
 static_assert(offsetof(Viewport, width) == 12,
               "offset of Viewport width should be 12");
 static_assert(offsetof(Viewport, height) == 16,
               "offset of Viewport height should be 16");
 
 struct WaitSync {
   typedef WaitSync ValueType;
   static const CommandId kCmdId = kWaitSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync, GLbitfield _flags, GLuint64 _timeout) {
     SetHeader();
     sync = _sync;
@@ skipping 28 matching lines @@
               "offset of WaitSync flags should be 8");
 static_assert(offsetof(WaitSync, timeout_0) == 12,
               "offset of WaitSync timeout_0 should be 12");
 static_assert(offsetof(WaitSync, timeout_1) == 16,
               "offset of WaitSync timeout_1 should be 16");
 
 struct BlitFramebufferCHROMIUM {
   typedef BlitFramebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kBlitFramebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _srcX0,
             GLint _srcY0,
             GLint _srcX1,
@@ skipping 69 matching lines @@
 static_assert(offsetof(BlitFramebufferCHROMIUM, mask) == 36,
               "offset of BlitFramebufferCHROMIUM mask should be 36");
 static_assert(offsetof(BlitFramebufferCHROMIUM, filter) == 40,
               "offset of BlitFramebufferCHROMIUM filter should be 40");
 
 // GL_CHROMIUM_framebuffer_multisample
 struct RenderbufferStorageMultisampleCHROMIUM {
   typedef RenderbufferStorageMultisampleCHROMIUM ValueType;
   static const CommandId kCmdId = kRenderbufferStorageMultisampleCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLsizei _samples,
             GLenum _internalformat,
@@ skipping 46 matching lines @@
     "offset of RenderbufferStorageMultisampleCHROMIUM width should be 16");
 static_assert(
     offsetof(RenderbufferStorageMultisampleCHROMIUM, height) == 20,
     "offset of RenderbufferStorageMultisampleCHROMIUM height should be 20");
 
 // GL_EXT_multisampled_render_to_texture
 struct RenderbufferStorageMultisampleEXT {
   typedef RenderbufferStorageMultisampleEXT ValueType;
   static const CommandId kCmdId = kRenderbufferStorageMultisampleEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLsizei _samples,
             GLenum _internalformat,
@@ skipping 41 matching lines @@
 static_assert(offsetof(RenderbufferStorageMultisampleEXT, width) == 16,
               "offset of RenderbufferStorageMultisampleEXT width should be 16");
 static_assert(
     offsetof(RenderbufferStorageMultisampleEXT, height) == 20,
     "offset of RenderbufferStorageMultisampleEXT height should be 20");
 
 struct FramebufferTexture2DMultisampleEXT {
   typedef FramebufferTexture2DMultisampleEXT ValueType;
   static const CommandId kCmdId = kFramebufferTexture2DMultisampleEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _attachment,
             GLenum _textarget,
@@ skipping 51 matching lines @@
     offsetof(FramebufferTexture2DMultisampleEXT, level) == 20,
     "offset of FramebufferTexture2DMultisampleEXT level should be 20");
 static_assert(
     offsetof(FramebufferTexture2DMultisampleEXT, samples) == 24,
     "offset of FramebufferTexture2DMultisampleEXT samples should be 24");
 
 struct TexStorage2DEXT {
   typedef TexStorage2DEXT ValueType;
   static const CommandId kCmdId = kTexStorage2DEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLsizei _levels,
             GLenum _internalFormat,
@@ skipping 38 matching lines @@
               "offset of TexStorage2DEXT internalFormat should be 12");
 static_assert(offsetof(TexStorage2DEXT, width) == 16,
               "offset of TexStorage2DEXT width should be 16");
 static_assert(offsetof(TexStorage2DEXT, height) == 20,
               "offset of TexStorage2DEXT height should be 20");
 
 struct GenQueriesEXTImmediate {
   typedef GenQueriesEXTImmediate ValueType;
   static const CommandId kCmdId = kGenQueriesEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenQueriesEXTImmediate should be 8");
 static_assert(offsetof(GenQueriesEXTImmediate, header) == 0,
               "offset of GenQueriesEXTImmediate header should be 0");
 static_assert(offsetof(GenQueriesEXTImmediate, n) == 4,
               "offset of GenQueriesEXTImmediate n should be 4");
 
 struct DeleteQueriesEXTImmediate {
   typedef DeleteQueriesEXTImmediate ValueType;
   static const CommandId kCmdId = kDeleteQueriesEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteQueriesEXTImmediate should be 8");
 static_assert(offsetof(DeleteQueriesEXTImmediate, header) == 0,
               "offset of DeleteQueriesEXTImmediate header should be 0");
 static_assert(offsetof(DeleteQueriesEXTImmediate, n) == 4,
               "offset of DeleteQueriesEXTImmediate n should be 4");
 
 struct QueryCounterEXT {
   typedef QueryCounterEXT ValueType;
   static const CommandId kCmdId = kQueryCounterEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _id,
             GLenum _target,
             uint32_t _sync_data_shm_id,
@@ skipping 38 matching lines @@
               "offset of QueryCounterEXT sync_data_shm_id should be 12");
 static_assert(offsetof(QueryCounterEXT, sync_data_shm_offset) == 16,
               "offset of QueryCounterEXT sync_data_shm_offset should be 16");
 static_assert(offsetof(QueryCounterEXT, submit_count) == 20,
               "offset of QueryCounterEXT submit_count should be 20");
 
 struct BeginQueryEXT {
   typedef BeginQueryEXT ValueType;
   static const CommandId kCmdId = kBeginQueryEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLuint _id,
             uint32_t _sync_data_shm_id,
@@ skipping 32 matching lines @@
               "offset of BeginQueryEXT id should be 8");
 static_assert(offsetof(BeginQueryEXT, sync_data_shm_id) == 12,
               "offset of BeginQueryEXT sync_data_shm_id should be 12");
 static_assert(offsetof(BeginQueryEXT, sync_data_shm_offset) == 16,
               "offset of BeginQueryEXT sync_data_shm_offset should be 16");
 
 struct BeginTransformFeedback {
   typedef BeginTransformFeedback ValueType;
   static const CommandId kCmdId = kBeginTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _primitivemode) {
     SetHeader();
     primitivemode = _primitivemode;
@@ skipping 12 matching lines @@
               "size of BeginTransformFeedback should be 8");
 static_assert(offsetof(BeginTransformFeedback, header) == 0,
               "offset of BeginTransformFeedback header should be 0");
 static_assert(offsetof(BeginTransformFeedback, primitivemode) == 4,
               "offset of BeginTransformFeedback primitivemode should be 4");
 
 struct EndQueryEXT {
   typedef EndQueryEXT ValueType;
   static const CommandId kCmdId = kEndQueryEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _submit_count) {
     SetHeader();
     target = _target;
@@ skipping 15 matching lines @@
               "offset of EndQueryEXT header should be 0");
 static_assert(offsetof(EndQueryEXT, target) == 4,
               "offset of EndQueryEXT target should be 4");
 static_assert(offsetof(EndQueryEXT, submit_count) == 8,
               "offset of EndQueryEXT submit_count should be 8");
 
 struct EndTransformFeedback {
   typedef EndTransformFeedback ValueType;
   static const CommandId kCmdId = kEndTransformFeedback;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(EndTransformFeedback) == 4,
               "size of EndTransformFeedback should be 4");
 static_assert(offsetof(EndTransformFeedback, header) == 0,
               "offset of EndTransformFeedback header should be 0");
 
 struct SetDisjointValueSyncCHROMIUM {
   typedef SetDisjointValueSyncCHROMIUM ValueType;
   static const CommandId kCmdId = kSetDisjointValueSyncCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(uint32_t _sync_data_shm_id, uint32_t _sync_data_shm_offset) {
     SetHeader();
     sync_data_shm_id = _sync_data_shm_id;
@@ skipping 21 matching lines @@
     offsetof(SetDisjointValueSyncCHROMIUM, sync_data_shm_id) == 4,
     "offset of SetDisjointValueSyncCHROMIUM sync_data_shm_id should be 4");
 static_assert(
     offsetof(SetDisjointValueSyncCHROMIUM, sync_data_shm_offset) == 8,
     "offset of SetDisjointValueSyncCHROMIUM sync_data_shm_offset should be 8");
 
 struct InsertEventMarkerEXT {
   typedef InsertEventMarkerEXT ValueType;
   static const CommandId kCmdId = kInsertEventMarkerEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _bucket_id) {
     SetHeader();
     bucket_id = _bucket_id;
@@ skipping 12 matching lines @@
               "size of InsertEventMarkerEXT should be 8");
 static_assert(offsetof(InsertEventMarkerEXT, header) == 0,
               "offset of InsertEventMarkerEXT header should be 0");
 static_assert(offsetof(InsertEventMarkerEXT, bucket_id) == 4,
               "offset of InsertEventMarkerEXT bucket_id should be 4");
 
 struct PushGroupMarkerEXT {
   typedef PushGroupMarkerEXT ValueType;
   static const CommandId kCmdId = kPushGroupMarkerEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _bucket_id) {
     SetHeader();
     bucket_id = _bucket_id;
@@ skipping 12 matching lines @@
               "size of PushGroupMarkerEXT should be 8");
 static_assert(offsetof(PushGroupMarkerEXT, header) == 0,
               "offset of PushGroupMarkerEXT header should be 0");
 static_assert(offsetof(PushGroupMarkerEXT, bucket_id) == 4,
               "offset of PushGroupMarkerEXT bucket_id should be 4");
 
 struct PopGroupMarkerEXT {
   typedef PopGroupMarkerEXT ValueType;
   static const CommandId kCmdId = kPopGroupMarkerEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(PopGroupMarkerEXT) == 4,
               "size of PopGroupMarkerEXT should be 4");
 static_assert(offsetof(PopGroupMarkerEXT, header) == 0,
               "offset of PopGroupMarkerEXT header should be 0");
 
 struct GenVertexArraysOESImmediate {
   typedef GenVertexArraysOESImmediate ValueType;
   static const CommandId kCmdId = kGenVertexArraysOESImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenVertexArraysOESImmediate should be 8");
 static_assert(offsetof(GenVertexArraysOESImmediate, header) == 0,
               "offset of GenVertexArraysOESImmediate header should be 0");
 static_assert(offsetof(GenVertexArraysOESImmediate, n) == 4,
               "offset of GenVertexArraysOESImmediate n should be 4");
 
 struct DeleteVertexArraysOESImmediate {
   typedef DeleteVertexArraysOESImmediate ValueType;
   static const CommandId kCmdId = kDeleteVertexArraysOESImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DeleteVertexArraysOESImmediate should be 8");
 static_assert(offsetof(DeleteVertexArraysOESImmediate, header) == 0,
               "offset of DeleteVertexArraysOESImmediate header should be 0");
 static_assert(offsetof(DeleteVertexArraysOESImmediate, n) == 4,
               "offset of DeleteVertexArraysOESImmediate n should be 4");
 
 struct IsVertexArrayOES {
   typedef IsVertexArrayOES ValueType;
   static const CommandId kCmdId = kIsVertexArrayOES;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _array,
@@ skipping 28 matching lines @@
               "offset of IsVertexArrayOES array should be 4");
 static_assert(offsetof(IsVertexArrayOES, result_shm_id) == 8,
               "offset of IsVertexArrayOES result_shm_id should be 8");
 static_assert(offsetof(IsVertexArrayOES, result_shm_offset) == 12,
               "offset of IsVertexArrayOES result_shm_offset should be 12");
 
 struct BindVertexArrayOES {
   typedef BindVertexArrayOES ValueType;
   static const CommandId kCmdId = kBindVertexArrayOES;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _array) {
     SetHeader();
     array = _array;
@@ skipping 12 matching lines @@
               "size of BindVertexArrayOES should be 8");
 static_assert(offsetof(BindVertexArrayOES, header) == 0,
               "offset of BindVertexArrayOES header should be 0");
 static_assert(offsetof(BindVertexArrayOES, array) == 4,
               "offset of BindVertexArrayOES array should be 4");
 
 struct SwapBuffers {
   typedef SwapBuffers ValueType;
   static const CommandId kCmdId = kSwapBuffers;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(SwapBuffers) == 4, "size of SwapBuffers should be 4");
 static_assert(offsetof(SwapBuffers, header) == 0,
               "offset of SwapBuffers header should be 0");
 
 struct GetMaxValueInBufferCHROMIUM {
   typedef GetMaxValueInBufferCHROMIUM ValueType;
   static const CommandId kCmdId = kGetMaxValueInBufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLuint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _buffer_id,
@@ skipping 48 matching lines @@
     offsetof(GetMaxValueInBufferCHROMIUM, result_shm_id) == 20,
     "offset of GetMaxValueInBufferCHROMIUM result_shm_id should be 20");
 static_assert(
     offsetof(GetMaxValueInBufferCHROMIUM, result_shm_offset) == 24,
     "offset of GetMaxValueInBufferCHROMIUM result_shm_offset should be 24");
 
 struct EnableFeatureCHROMIUM {
   typedef EnableFeatureCHROMIUM ValueType;
   static const CommandId kCmdId = kEnableFeatureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _bucket_id,
@@ skipping 28 matching lines @@
               "offset of EnableFeatureCHROMIUM bucket_id should be 4");
 static_assert(offsetof(EnableFeatureCHROMIUM, result_shm_id) == 8,
               "offset of EnableFeatureCHROMIUM result_shm_id should be 8");
 static_assert(offsetof(EnableFeatureCHROMIUM, result_shm_offset) == 12,
               "offset of EnableFeatureCHROMIUM result_shm_offset should be 12");
 
 struct MapBufferRange {
   typedef MapBufferRange ValueType;
   static const CommandId kCmdId = kMapBufferRange;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
@@ skipping 59 matching lines @@
               "offset of MapBufferRange data_shm_offset should be 24");
 static_assert(offsetof(MapBufferRange, result_shm_id) == 28,
               "offset of MapBufferRange result_shm_id should be 28");
 static_assert(offsetof(MapBufferRange, result_shm_offset) == 32,
               "offset of MapBufferRange result_shm_offset should be 32");
 
 struct UnmapBuffer {
   typedef UnmapBuffer ValueType;
   static const CommandId kCmdId = kUnmapBuffer;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target) {
     SetHeader();
     target = _target;
@@ skipping 11 matching lines @@
 static_assert(sizeof(UnmapBuffer) == 8, "size of UnmapBuffer should be 8");
 static_assert(offsetof(UnmapBuffer, header) == 0,
               "offset of UnmapBuffer header should be 0");
 static_assert(offsetof(UnmapBuffer, target) == 4,
               "offset of UnmapBuffer target should be 4");
 
 struct ResizeCHROMIUM {
   typedef ResizeCHROMIUM ValueType;
   static const CommandId kCmdId = kResizeCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _width,
             GLuint _height,
             GLfloat _scale_factor,
@@ skipping 31 matching lines @@
               "offset of ResizeCHROMIUM height should be 8");
 static_assert(offsetof(ResizeCHROMIUM, scale_factor) == 12,
               "offset of ResizeCHROMIUM scale_factor should be 12");
 static_assert(offsetof(ResizeCHROMIUM, alpha) == 16,
               "offset of ResizeCHROMIUM alpha should be 16");
 
 struct GetRequestableExtensionsCHROMIUM {
   typedef GetRequestableExtensionsCHROMIUM ValueType;
   static const CommandId kCmdId = kGetRequestableExtensionsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(uint32_t _bucket_id) {
     SetHeader();
     bucket_id = _bucket_id;
@@ skipping 13 matching lines @@
 static_assert(offsetof(GetRequestableExtensionsCHROMIUM, header) == 0,
               "offset of GetRequestableExtensionsCHROMIUM header should be 0");
 static_assert(
     offsetof(GetRequestableExtensionsCHROMIUM, bucket_id) == 4,
     "offset of GetRequestableExtensionsCHROMIUM bucket_id should be 4");
 
 struct RequestExtensionCHROMIUM {
   typedef RequestExtensionCHROMIUM ValueType;
   static const CommandId kCmdId = kRequestExtensionCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(uint32_t _bucket_id) {
     SetHeader();
     bucket_id = _bucket_id;
@@ skipping 12 matching lines @@
               "size of RequestExtensionCHROMIUM should be 8");
 static_assert(offsetof(RequestExtensionCHROMIUM, header) == 0,
               "offset of RequestExtensionCHROMIUM header should be 0");
 static_assert(offsetof(RequestExtensionCHROMIUM, bucket_id) == 4,
               "offset of RequestExtensionCHROMIUM bucket_id should be 4");
 
 struct GetProgramInfoCHROMIUM {
   typedef GetProgramInfoCHROMIUM ValueType;
   static const CommandId kCmdId = kGetProgramInfoCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   struct Result {
     uint32_t link_status;
     uint32_t num_attribs;
     uint32_t num_uniforms;
   };
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
@@ skipping 31 matching lines @@
               "offset of GetProgramInfoCHROMIUM Result num_attribs should be "
               "4");
 static_assert(offsetof(GetProgramInfoCHROMIUM::Result, num_uniforms) == 8,
               "offset of GetProgramInfoCHROMIUM Result num_uniforms should be "
               "8");
 
 struct GetUniformBlocksCHROMIUM {
   typedef GetUniformBlocksCHROMIUM ValueType;
   static const CommandId kCmdId = kGetUniformBlocksCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, uint32_t _bucket_id) {
@@ skipping 18 matching lines @@
               "offset of GetUniformBlocksCHROMIUM header should be 0");
 static_assert(offsetof(GetUniformBlocksCHROMIUM, program) == 4,
               "offset of GetUniformBlocksCHROMIUM program should be 4");
 static_assert(offsetof(GetUniformBlocksCHROMIUM, bucket_id) == 8,
               "offset of GetUniformBlocksCHROMIUM bucket_id should be 8");
 
 struct GetTransformFeedbackVaryingsCHROMIUM {
   typedef GetTransformFeedbackVaryingsCHROMIUM ValueType;
   static const CommandId kCmdId = kGetTransformFeedbackVaryingsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, uint32_t _bucket_id) {
@@ skipping 21 matching lines @@
     offsetof(GetTransformFeedbackVaryingsCHROMIUM, program) == 4,
     "offset of GetTransformFeedbackVaryingsCHROMIUM program should be 4");
 static_assert(
     offsetof(GetTransformFeedbackVaryingsCHROMIUM, bucket_id) == 8,
     "offset of GetTransformFeedbackVaryingsCHROMIUM bucket_id should be 8");
 
 struct GetUniformsES3CHROMIUM {
   typedef GetUniformsES3CHROMIUM ValueType;
   static const CommandId kCmdId = kGetUniformsES3CHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, uint32_t _bucket_id) {
@@ skipping 18 matching lines @@
               "offset of GetUniformsES3CHROMIUM header should be 0");
 static_assert(offsetof(GetUniformsES3CHROMIUM, program) == 4,
               "offset of GetUniformsES3CHROMIUM program should be 4");
 static_assert(offsetof(GetUniformsES3CHROMIUM, bucket_id) == 8,
               "offset of GetUniformsES3CHROMIUM bucket_id should be 8");
 
 struct GetTranslatedShaderSourceANGLE {
   typedef GetTranslatedShaderSourceANGLE ValueType;
   static const CommandId kCmdId = kGetTranslatedShaderSourceANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _shader, uint32_t _bucket_id) {
     SetHeader();
     shader = _shader;
@@ skipping 16 matching lines @@
               "offset of GetTranslatedShaderSourceANGLE header should be 0");
 static_assert(offsetof(GetTranslatedShaderSourceANGLE, shader) == 4,
               "offset of GetTranslatedShaderSourceANGLE shader should be 4");
 static_assert(offsetof(GetTranslatedShaderSourceANGLE, bucket_id) == 8,
               "offset of GetTranslatedShaderSourceANGLE bucket_id should be 8");
 
 struct PostSubBufferCHROMIUM {
   typedef PostSubBufferCHROMIUM ValueType;
   static const CommandId kCmdId = kPostSubBufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _x, GLint _y, GLint _width, GLint _height) {
     SetHeader();
     x = _x;
@@ skipping 24 matching lines @@
               "offset of PostSubBufferCHROMIUM y should be 8");
 static_assert(offsetof(PostSubBufferCHROMIUM, width) == 12,
               "offset of PostSubBufferCHROMIUM width should be 12");
 static_assert(offsetof(PostSubBufferCHROMIUM, height) == 16,
               "offset of PostSubBufferCHROMIUM height should be 16");
 
 struct TexImageIOSurface2DCHROMIUM {
   typedef TexImageIOSurface2DCHROMIUM ValueType;
   static const CommandId kCmdId = kTexImageIOSurface2DCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLsizei _width,
             GLsizei _height,
@@ skipping 38 matching lines @@
               "offset of TexImageIOSurface2DCHROMIUM height should be 12");
 static_assert(offsetof(TexImageIOSurface2DCHROMIUM, ioSurfaceId) == 16,
               "offset of TexImageIOSurface2DCHROMIUM ioSurfaceId should be 16");
 static_assert(offsetof(TexImageIOSurface2DCHROMIUM, plane) == 20,
               "offset of TexImageIOSurface2DCHROMIUM plane should be 20");
 
 struct CopyTextureCHROMIUM {
   typedef CopyTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCopyTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _source_id,
             GLenum _dest_id,
@@ skipping 59 matching lines @@
     offsetof(CopyTextureCHROMIUM, unpack_premultiply_alpha) == 28,
     "offset of CopyTextureCHROMIUM unpack_premultiply_alpha should be 28");
 static_assert(
     offsetof(CopyTextureCHROMIUM, unpack_unmultiply_alpha) == 32,
     "offset of CopyTextureCHROMIUM unpack_unmultiply_alpha should be 32");
 
 struct CopySubTextureCHROMIUM {
   typedef CopySubTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCopySubTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _source_id,
             GLenum _dest_id,
@@ skipping 84 matching lines @@
     offsetof(CopySubTextureCHROMIUM, unpack_premultiply_alpha) == 44,
     "offset of CopySubTextureCHROMIUM unpack_premultiply_alpha should be 44");
 static_assert(
     offsetof(CopySubTextureCHROMIUM, unpack_unmultiply_alpha) == 48,
     "offset of CopySubTextureCHROMIUM unpack_unmultiply_alpha should be 48");
 
 struct CompressedCopyTextureCHROMIUM {
   typedef CompressedCopyTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCompressedCopyTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLenum _source_id, GLenum _dest_id) {
     SetHeader();
     target = _target;
@@ skipping 20 matching lines @@
               "offset of CompressedCopyTextureCHROMIUM target should be 4");
 static_assert(offsetof(CompressedCopyTextureCHROMIUM, source_id) == 8,
               "offset of CompressedCopyTextureCHROMIUM source_id should be 8");
 static_assert(offsetof(CompressedCopyTextureCHROMIUM, dest_id) == 12,
               "offset of CompressedCopyTextureCHROMIUM dest_id should be 12");
 
 struct CompressedCopySubTextureCHROMIUM {
   typedef CompressedCopySubTextureCHROMIUM ValueType;
   static const CommandId kCmdId = kCompressedCopySubTextureCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target,
             GLenum _source_id,
             GLenum _dest_id,
@@ skipping 66 matching lines @@
               "offset of CompressedCopySubTextureCHROMIUM y should be 28");
 static_assert(offsetof(CompressedCopySubTextureCHROMIUM, width) == 32,
               "offset of CompressedCopySubTextureCHROMIUM width should be 32");
 static_assert(offsetof(CompressedCopySubTextureCHROMIUM, height) == 36,
               "offset of CompressedCopySubTextureCHROMIUM height should be 36");
 
 struct DrawArraysInstancedANGLE {
   typedef DrawArraysInstancedANGLE ValueType;
   static const CommandId kCmdId = kDrawArraysInstancedANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode, GLint _first, GLsizei _count, GLsizei _primcount) {
     SetHeader();
     mode = _mode;
@@ skipping 28 matching lines @@
               "offset of DrawArraysInstancedANGLE first should be 8");
 static_assert(offsetof(DrawArraysInstancedANGLE, count) == 12,
               "offset of DrawArraysInstancedANGLE count should be 12");
 static_assert(offsetof(DrawArraysInstancedANGLE, primcount) == 16,
               "offset of DrawArraysInstancedANGLE primcount should be 16");
 
 struct DrawElementsInstancedANGLE {
   typedef DrawElementsInstancedANGLE ValueType;
   static const CommandId kCmdId = kDrawElementsInstancedANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _mode,
             GLsizei _count,
             GLenum _type,
@@ skipping 38 matching lines @@
               "offset of DrawElementsInstancedANGLE type should be 12");
 static_assert(offsetof(DrawElementsInstancedANGLE, index_offset) == 16,
               "offset of DrawElementsInstancedANGLE index_offset should be 16");
 static_assert(offsetof(DrawElementsInstancedANGLE, primcount) == 20,
               "offset of DrawElementsInstancedANGLE primcount should be 20");
 
 struct VertexAttribDivisorANGLE {
   typedef VertexAttribDivisorANGLE ValueType;
   static const CommandId kCmdId = kVertexAttribDivisorANGLE;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _index, GLuint _divisor) {
     SetHeader();
     index = _index;
@@ skipping 16 matching lines @@
               "offset of VertexAttribDivisorANGLE header should be 0");
 static_assert(offsetof(VertexAttribDivisorANGLE, index) == 4,
               "offset of VertexAttribDivisorANGLE index should be 4");
 static_assert(offsetof(VertexAttribDivisorANGLE, divisor) == 8,
               "offset of VertexAttribDivisorANGLE divisor should be 8");
 
 struct ProduceTextureCHROMIUMImmediate {
   typedef ProduceTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kProduceTextureCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of ProduceTextureCHROMIUMImmediate should be 8");
 static_assert(offsetof(ProduceTextureCHROMIUMImmediate, header) == 0,
               "offset of ProduceTextureCHROMIUMImmediate header should be 0");
 static_assert(offsetof(ProduceTextureCHROMIUMImmediate, target) == 4,
               "offset of ProduceTextureCHROMIUMImmediate target should be 4");
 
 struct ProduceTextureDirectCHROMIUMImmediate {
   typedef ProduceTextureDirectCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kProduceTextureDirectCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 28 matching lines @@
     offsetof(ProduceTextureDirectCHROMIUMImmediate, texture) == 4,
     "offset of ProduceTextureDirectCHROMIUMImmediate texture should be 4");
 static_assert(
     offsetof(ProduceTextureDirectCHROMIUMImmediate, target) == 8,
     "offset of ProduceTextureDirectCHROMIUMImmediate target should be 8");
 
 struct ConsumeTextureCHROMIUMImmediate {
   typedef ConsumeTextureCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kConsumeTextureCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLbyte) * 64);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of ConsumeTextureCHROMIUMImmediate should be 8");
 static_assert(offsetof(ConsumeTextureCHROMIUMImmediate, header) == 0,
               "offset of ConsumeTextureCHROMIUMImmediate header should be 0");
 static_assert(offsetof(ConsumeTextureCHROMIUMImmediate, target) == 4,
               "offset of ConsumeTextureCHROMIUMImmediate target should be 4");
 
 struct BindUniformLocationCHROMIUMBucket {
   typedef BindUniformLocationCHROMIUMBucket ValueType;
   static const CommandId kCmdId = kBindUniformLocationCHROMIUMBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLint _location, uint32_t _name_bucket_id) {
     SetHeader();
     program = _program;
@@ skipping 26 matching lines @@
     offsetof(BindUniformLocationCHROMIUMBucket, location) == 8,
     "offset of BindUniformLocationCHROMIUMBucket location should be 8");
 static_assert(
     offsetof(BindUniformLocationCHROMIUMBucket, name_bucket_id) == 12,
     "offset of BindUniformLocationCHROMIUMBucket name_bucket_id should be 12");
 
 struct GenValuebuffersCHROMIUMImmediate {
   typedef GenValuebuffersCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenValuebuffersCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of GenValuebuffersCHROMIUMImmediate should be 8");
 static_assert(offsetof(GenValuebuffersCHROMIUMImmediate, header) == 0,
               "offset of GenValuebuffersCHROMIUMImmediate header should be 0");
 static_assert(offsetof(GenValuebuffersCHROMIUMImmediate, n) == 4,
               "offset of GenValuebuffersCHROMIUMImmediate n should be 4");
 
 struct DeleteValuebuffersCHROMIUMImmediate {
   typedef DeleteValuebuffersCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kDeleteValuebuffersCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(GLuint) * n);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei n) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(n));  // NOLINT
   }
 
@@ skipping 22 matching lines @@
 static_assert(
     offsetof(DeleteValuebuffersCHROMIUMImmediate, header) == 0,
     "offset of DeleteValuebuffersCHROMIUMImmediate header should be 0");
 static_assert(offsetof(DeleteValuebuffersCHROMIUMImmediate, n) == 4,
               "offset of DeleteValuebuffersCHROMIUMImmediate n should be 4");
 
 struct IsValuebufferCHROMIUM {
   typedef IsValuebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kIsValuebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _valuebuffer,
@@ skipping 28 matching lines @@
               "offset of IsValuebufferCHROMIUM valuebuffer should be 4");
 static_assert(offsetof(IsValuebufferCHROMIUM, result_shm_id) == 8,
               "offset of IsValuebufferCHROMIUM result_shm_id should be 8");
 static_assert(offsetof(IsValuebufferCHROMIUM, result_shm_offset) == 12,
               "offset of IsValuebufferCHROMIUM result_shm_offset should be 12");
 
 struct BindValuebufferCHROMIUM {
   typedef BindValuebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kBindValuebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLuint _valuebuffer) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of BindValuebufferCHROMIUM header should be 0");
 static_assert(offsetof(BindValuebufferCHROMIUM, target) == 4,
               "offset of BindValuebufferCHROMIUM target should be 4");
 static_assert(offsetof(BindValuebufferCHROMIUM, valuebuffer) == 8,
               "offset of BindValuebufferCHROMIUM valuebuffer should be 8");
 
 struct SubscribeValueCHROMIUM {
   typedef SubscribeValueCHROMIUM ValueType;
   static const CommandId kCmdId = kSubscribeValueCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLenum _subscription) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of SubscribeValueCHROMIUM header should be 0");
 static_assert(offsetof(SubscribeValueCHROMIUM, target) == 4,
               "offset of SubscribeValueCHROMIUM target should be 4");
 static_assert(offsetof(SubscribeValueCHROMIUM, subscription) == 8,
               "offset of SubscribeValueCHROMIUM subscription should be 8");
 
 struct PopulateSubscribedValuesCHROMIUM {
   typedef PopulateSubscribedValuesCHROMIUM ValueType;
   static const CommandId kCmdId = kPopulateSubscribedValuesCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target) {
     SetHeader();
     target = _target;
@@ skipping 12 matching lines @@
               "size of PopulateSubscribedValuesCHROMIUM should be 8");
 static_assert(offsetof(PopulateSubscribedValuesCHROMIUM, header) == 0,
               "offset of PopulateSubscribedValuesCHROMIUM header should be 0");
 static_assert(offsetof(PopulateSubscribedValuesCHROMIUM, target) == 4,
               "offset of PopulateSubscribedValuesCHROMIUM target should be 4");
 
 struct UniformValuebufferCHROMIUM {
   typedef UniformValuebufferCHROMIUM ValueType;
   static const CommandId kCmdId = kUniformValuebufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _location, GLenum _target, GLenum _subscription) {
     SetHeader();
     location = _location;
@@ skipping 20 matching lines @@
               "offset of UniformValuebufferCHROMIUM location should be 4");
 static_assert(offsetof(UniformValuebufferCHROMIUM, target) == 8,
               "offset of UniformValuebufferCHROMIUM target should be 8");
 static_assert(offsetof(UniformValuebufferCHROMIUM, subscription) == 12,
               "offset of UniformValuebufferCHROMIUM subscription should be 12");
 
 struct BindTexImage2DCHROMIUM {
   typedef BindTexImage2DCHROMIUM ValueType;
   static const CommandId kCmdId = kBindTexImage2DCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLint _imageId) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of BindTexImage2DCHROMIUM header should be 0");
 static_assert(offsetof(BindTexImage2DCHROMIUM, target) == 4,
               "offset of BindTexImage2DCHROMIUM target should be 4");
 static_assert(offsetof(BindTexImage2DCHROMIUM, imageId) == 8,
               "offset of BindTexImage2DCHROMIUM imageId should be 8");
 
 struct ReleaseTexImage2DCHROMIUM {
   typedef ReleaseTexImage2DCHROMIUM ValueType;
   static const CommandId kCmdId = kReleaseTexImage2DCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _target, GLint _imageId) {
     SetHeader();
     target = _target;
@@ skipping 16 matching lines @@
               "offset of ReleaseTexImage2DCHROMIUM header should be 0");
 static_assert(offsetof(ReleaseTexImage2DCHROMIUM, target) == 4,
               "offset of ReleaseTexImage2DCHROMIUM target should be 4");
 static_assert(offsetof(ReleaseTexImage2DCHROMIUM, imageId) == 8,
               "offset of ReleaseTexImage2DCHROMIUM imageId should be 8");
 
 struct TraceBeginCHROMIUM {
   typedef TraceBeginCHROMIUM ValueType;
   static const CommandId kCmdId = kTraceBeginCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _category_bucket_id, GLuint _name_bucket_id) {
     SetHeader();
     category_bucket_id = _category_bucket_id;
@@ skipping 16 matching lines @@
               "offset of TraceBeginCHROMIUM header should be 0");
 static_assert(offsetof(TraceBeginCHROMIUM, category_bucket_id) == 4,
               "offset of TraceBeginCHROMIUM category_bucket_id should be 4");
 static_assert(offsetof(TraceBeginCHROMIUM, name_bucket_id) == 8,
               "offset of TraceBeginCHROMIUM name_bucket_id should be 8");
 
 struct TraceEndCHROMIUM {
   typedef TraceEndCHROMIUM ValueType;
   static const CommandId kCmdId = kTraceEndCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(TraceEndCHROMIUM) == 4,
               "size of TraceEndCHROMIUM should be 4");
 static_assert(offsetof(TraceEndCHROMIUM, header) == 0,
               "offset of TraceEndCHROMIUM header should be 0");
 
 struct DiscardFramebufferEXTImmediate {
   typedef DiscardFramebufferEXTImmediate ValueType;
   static const CommandId kCmdId = kDiscardFramebufferEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 28 matching lines @@
               "offset of DiscardFramebufferEXTImmediate header should be 0");
 static_assert(offsetof(DiscardFramebufferEXTImmediate, target) == 4,
               "offset of DiscardFramebufferEXTImmediate target should be 4");
 static_assert(offsetof(DiscardFramebufferEXTImmediate, count) == 8,
               "offset of DiscardFramebufferEXTImmediate count should be 8");
 
 struct LoseContextCHROMIUM {
   typedef LoseContextCHROMIUM ValueType;
   static const CommandId kCmdId = kLoseContextCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _current, GLenum _other) {
     SetHeader();
     current = _current;
@@ skipping 16 matching lines @@
               "offset of LoseContextCHROMIUM header should be 0");
 static_assert(offsetof(LoseContextCHROMIUM, current) == 4,
               "offset of LoseContextCHROMIUM current should be 4");
 static_assert(offsetof(LoseContextCHROMIUM, other) == 8,
               "offset of LoseContextCHROMIUM other should be 8");
 
 struct WaitSyncPointCHROMIUM {
   typedef WaitSyncPointCHROMIUM ValueType;
   static const CommandId kCmdId = kWaitSyncPointCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync_point) {
     SetHeader();
     sync_point = _sync_point;
@@ skipping 12 matching lines @@
               "size of WaitSyncPointCHROMIUM should be 8");
 static_assert(offsetof(WaitSyncPointCHROMIUM, header) == 0,
               "offset of WaitSyncPointCHROMIUM header should be 0");
 static_assert(offsetof(WaitSyncPointCHROMIUM, sync_point) == 4,
               "offset of WaitSyncPointCHROMIUM sync_point should be 4");
 
 struct InsertFenceSyncCHROMIUM {
   typedef InsertFenceSyncCHROMIUM ValueType;
   static const CommandId kCmdId = kInsertFenceSyncCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint64 _release_count) {
     SetHeader();
     GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_release_count),
@@ skipping 21 matching lines @@
               "offset of InsertFenceSyncCHROMIUM header should be 0");
 static_assert(offsetof(InsertFenceSyncCHROMIUM, release_count_0) == 4,
               "offset of InsertFenceSyncCHROMIUM release_count_0 should be 4");
 static_assert(offsetof(InsertFenceSyncCHROMIUM, release_count_1) == 8,
               "offset of InsertFenceSyncCHROMIUM release_count_1 should be 8");
 
 struct GenSyncTokenCHROMIUMImmediate {
   typedef GenSyncTokenCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenSyncTokenCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
                                  RoundSizeToMultipleOfEntries(size_in_bytes));
   }
 
   void SetHeader(uint32_t size_in_bytes) {
     header.SetCmdByTotalSize<ValueType>(size_in_bytes);
   }
 
@@ skipping 28 matching lines @@
     offsetof(GenSyncTokenCHROMIUMImmediate, fence_sync_0) == 4,
     "offset of GenSyncTokenCHROMIUMImmediate fence_sync_0 should be 4");
 static_assert(
     offsetof(GenSyncTokenCHROMIUMImmediate, fence_sync_1) == 8,
     "offset of GenSyncTokenCHROMIUMImmediate fence_sync_1 should be 8");
 
 struct GenUnverifiedSyncTokenCHROMIUMImmediate {
   typedef GenUnverifiedSyncTokenCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenUnverifiedSyncTokenCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
                                  RoundSizeToMultipleOfEntries(size_in_bytes));
   }
 
   void SetHeader(uint32_t size_in_bytes) {
     header.SetCmdByTotalSize<ValueType>(size_in_bytes);
   }
 
@@ skipping 31 matching lines @@
               "should be 4");
 static_assert(offsetof(GenUnverifiedSyncTokenCHROMIUMImmediate, fence_sync_1) ==
                   8,
               "offset of GenUnverifiedSyncTokenCHROMIUMImmediate fence_sync_1 "
               "should be 8");
 
 struct VerifySyncTokensCHROMIUMImmediate {
   typedef VerifySyncTokensCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kVerifySyncTokensCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
                                  RoundSizeToMultipleOfEntries(size_in_bytes));
   }
 
   void SetHeader(uint32_t size_in_bytes) {
     header.SetCmdByTotalSize<ValueType>(size_in_bytes);
   }
 
@@ skipping 17 matching lines @@
               "size of VerifySyncTokensCHROMIUMImmediate should be 8");
 static_assert(offsetof(VerifySyncTokensCHROMIUMImmediate, header) == 0,
               "offset of VerifySyncTokensCHROMIUMImmediate header should be 0");
 static_assert(offsetof(VerifySyncTokensCHROMIUMImmediate, count) == 4,
               "offset of VerifySyncTokensCHROMIUMImmediate count should be 4");
 
 struct WaitSyncTokenCHROMIUM {
   typedef WaitSyncTokenCHROMIUM ValueType;
   static const CommandId kCmdId = kWaitSyncTokenCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _namespace_id,
             GLuint64 _command_buffer_id,
             GLuint64 _release_count) {
@@ skipping 46 matching lines @@
     "offset of WaitSyncTokenCHROMIUM command_buffer_id_1 should be 12");
 static_assert(offsetof(WaitSyncTokenCHROMIUM, release_count_0) == 16,
               "offset of WaitSyncTokenCHROMIUM release_count_0 should be 16");
 static_assert(offsetof(WaitSyncTokenCHROMIUM, release_count_1) == 20,
               "offset of WaitSyncTokenCHROMIUM release_count_1 should be 20");
 
 struct DrawBuffersEXTImmediate {
   typedef DrawBuffersEXTImmediate ValueType;
   static const CommandId kCmdId = kDrawBuffersEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
   }
 
   static uint32_t ComputeSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(ValueType) +
                                  ComputeDataSize(count));  // NOLINT
   }
 
@@ skipping 21 matching lines @@
               "size of DrawBuffersEXTImmediate should be 8");
 static_assert(offsetof(DrawBuffersEXTImmediate, header) == 0,
               "offset of DrawBuffersEXTImmediate header should be 0");
 static_assert(offsetof(DrawBuffersEXTImmediate, count) == 4,
               "offset of DrawBuffersEXTImmediate count should be 4");
 
 struct DiscardBackbufferCHROMIUM {
   typedef DiscardBackbufferCHROMIUM ValueType;
   static const CommandId kCmdId = kDiscardBackbufferCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(DiscardBackbufferCHROMIUM) == 4,
               "size of DiscardBackbufferCHROMIUM should be 4");
 static_assert(offsetof(DiscardBackbufferCHROMIUM, header) == 0,
               "offset of DiscardBackbufferCHROMIUM header should be 0");
 
 struct ScheduleOverlayPlaneCHROMIUM {
   typedef ScheduleOverlayPlaneCHROMIUM ValueType;
   static const CommandId kCmdId = kScheduleOverlayPlaneCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _plane_z_order,
             GLenum _plane_transform,
             GLuint _overlay_texture_id,
@@ skipping 81 matching lines @@
               "offset of ScheduleOverlayPlaneCHROMIUM uv_y should be 36");
 static_assert(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_width) == 40,
               "offset of ScheduleOverlayPlaneCHROMIUM uv_width should be 40");
 static_assert(offsetof(ScheduleOverlayPlaneCHROMIUM, uv_height) == 44,
               "offset of ScheduleOverlayPlaneCHROMIUM uv_height should be 44");
 
 struct ScheduleCALayerCHROMIUM {
   typedef ScheduleCALayerCHROMIUM ValueType;
   static const CommandId kCmdId = kScheduleCALayerCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _contents_texture_id,
             GLfloat _opacity,
             GLuint _background_color,
@@ skipping 60 matching lines @@
     "offset of ScheduleCALayerCHROMIUM sorting_context_id should be 24");
 static_assert(offsetof(ScheduleCALayerCHROMIUM, shm_id) == 28,
               "offset of ScheduleCALayerCHROMIUM shm_id should be 28");
 static_assert(offsetof(ScheduleCALayerCHROMIUM, shm_offset) == 32,
               "offset of ScheduleCALayerCHROMIUM shm_offset should be 32");
 
 struct CommitOverlayPlanesCHROMIUM {
   typedef CommitOverlayPlanesCHROMIUM ValueType;
   static const CommandId kCmdId = kCommitOverlayPlanesCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(CommitOverlayPlanesCHROMIUM) == 4,
               "size of CommitOverlayPlanesCHROMIUM should be 4");
 static_assert(offsetof(CommitOverlayPlanesCHROMIUM, header) == 0,
               "offset of CommitOverlayPlanesCHROMIUM header should be 0");
 
 struct SwapInterval {
   typedef SwapInterval ValueType;
   static const CommandId kCmdId = kSwapInterval;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _interval) {
     SetHeader();
     interval = _interval;
@@ skipping 11 matching lines @@
 static_assert(sizeof(SwapInterval) == 8, "size of SwapInterval should be 8");
 static_assert(offsetof(SwapInterval, header) == 0,
               "offset of SwapInterval header should be 0");
 static_assert(offsetof(SwapInterval, interval) == 4,
               "offset of SwapInterval interval should be 4");
 
 struct FlushDriverCachesCHROMIUM {
   typedef FlushDriverCachesCHROMIUM ValueType;
   static const CommandId kCmdId = kFlushDriverCachesCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(FlushDriverCachesCHROMIUM) == 4,
               "size of FlushDriverCachesCHROMIUM should be 4");
 static_assert(offsetof(FlushDriverCachesCHROMIUM, header) == 0,
               "offset of FlushDriverCachesCHROMIUM header should be 0");
 
 struct MatrixLoadfCHROMIUMImmediate {
   typedef MatrixLoadfCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kMatrixLoadfCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeDataSize() {
     return static_cast<uint32_t>(sizeof(GLfloat) * 16);
   }
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType) + ComputeDataSize());
   }
 
   void SetHeader() { header.SetCmdByTotalSize<ValueType>(ComputeSize()); }
@@ skipping 18 matching lines @@
               "size of MatrixLoadfCHROMIUMImmediate should be 8");
 static_assert(offsetof(MatrixLoadfCHROMIUMImmediate, header) == 0,
               "offset of MatrixLoadfCHROMIUMImmediate header should be 0");
 static_assert(offsetof(MatrixLoadfCHROMIUMImmediate, matrixMode) == 4,
               "offset of MatrixLoadfCHROMIUMImmediate matrixMode should be 4");
 
 struct MatrixLoadIdentityCHROMIUM {
   typedef MatrixLoadIdentityCHROMIUM ValueType;
   static const CommandId kCmdId = kMatrixLoadIdentityCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _matrixMode) {
     SetHeader();
     matrixMode = _matrixMode;
@@ skipping 12 matching lines @@
               "size of MatrixLoadIdentityCHROMIUM should be 8");
 static_assert(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0,
               "offset of MatrixLoadIdentityCHROMIUM header should be 0");
 static_assert(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4,
               "offset of MatrixLoadIdentityCHROMIUM matrixMode should be 4");
 
 struct GenPathsCHROMIUM {
   typedef GenPathsCHROMIUM ValueType;
   static const CommandId kCmdId = kGenPathsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _first_client_id, GLsizei _range) {
     SetHeader();
     first_client_id = _first_client_id;
@@ skipping 16 matching lines @@
               "offset of GenPathsCHROMIUM header should be 0");
 static_assert(offsetof(GenPathsCHROMIUM, first_client_id) == 4,
               "offset of GenPathsCHROMIUM first_client_id should be 4");
 static_assert(offsetof(GenPathsCHROMIUM, range) == 8,
               "offset of GenPathsCHROMIUM range should be 8");
 
 struct DeletePathsCHROMIUM {
   typedef DeletePathsCHROMIUM ValueType;
   static const CommandId kCmdId = kDeletePathsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _first_client_id, GLsizei _range) {
     SetHeader();
     first_client_id = _first_client_id;
@@ skipping 16 matching lines @@
               "offset of DeletePathsCHROMIUM header should be 0");
 static_assert(offsetof(DeletePathsCHROMIUM, first_client_id) == 4,
               "offset of DeletePathsCHROMIUM first_client_id should be 4");
 static_assert(offsetof(DeletePathsCHROMIUM, range) == 8,
               "offset of DeletePathsCHROMIUM range should be 8");
 
 struct IsPathCHROMIUM {
   typedef IsPathCHROMIUM ValueType;
   static const CommandId kCmdId = kIsPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef uint32_t Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path,
@@ skipping 28 matching lines @@
               "offset of IsPathCHROMIUM path should be 4");
 static_assert(offsetof(IsPathCHROMIUM, result_shm_id) == 8,
               "offset of IsPathCHROMIUM result_shm_id should be 8");
 static_assert(offsetof(IsPathCHROMIUM, result_shm_offset) == 12,
               "offset of IsPathCHROMIUM result_shm_offset should be 12");
 
 struct PathCommandsCHROMIUM {
   typedef PathCommandsCHROMIUM ValueType;
   static const CommandId kCmdId = kPathCommandsCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path,
             GLsizei _numCommands,
             uint32_t _commands_shm_id,
@@ skipping 58 matching lines @@
               "offset of PathCommandsCHROMIUM coordType should be 24");
 static_assert(offsetof(PathCommandsCHROMIUM, coords_shm_id) == 28,
               "offset of PathCommandsCHROMIUM coords_shm_id should be 28");
 static_assert(offsetof(PathCommandsCHROMIUM, coords_shm_offset) == 32,
               "offset of PathCommandsCHROMIUM coords_shm_offset should be 32");
 
 struct PathParameterfCHROMIUM {
   typedef PathParameterfCHROMIUM ValueType;
   static const CommandId kCmdId = kPathParameterfCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLenum _pname, GLfloat _value) {
     SetHeader();
     path = _path;
@@ skipping 20 matching lines @@
               "offset of PathParameterfCHROMIUM path should be 4");
 static_assert(offsetof(PathParameterfCHROMIUM, pname) == 8,
               "offset of PathParameterfCHROMIUM pname should be 8");
 static_assert(offsetof(PathParameterfCHROMIUM, value) == 12,
               "offset of PathParameterfCHROMIUM value should be 12");
 
 struct PathParameteriCHROMIUM {
   typedef PathParameteriCHROMIUM ValueType;
   static const CommandId kCmdId = kPathParameteriCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLenum _pname, GLint _value) {
     SetHeader();
     path = _path;
@@ skipping 20 matching lines @@
               "offset of PathParameteriCHROMIUM path should be 4");
 static_assert(offsetof(PathParameteriCHROMIUM, pname) == 8,
               "offset of PathParameteriCHROMIUM pname should be 8");
 static_assert(offsetof(PathParameteriCHROMIUM, value) == 12,
               "offset of PathParameteriCHROMIUM value should be 12");
 
 struct PathStencilFuncCHROMIUM {
   typedef PathStencilFuncCHROMIUM ValueType;
   static const CommandId kCmdId = kPathStencilFuncCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLenum _func, GLint _ref, GLuint _mask) {
     SetHeader();
     func = _func;
@@ skipping 20 matching lines @@
               "offset of PathStencilFuncCHROMIUM func should be 4");
 static_assert(offsetof(PathStencilFuncCHROMIUM, ref) == 8,
               "offset of PathStencilFuncCHROMIUM ref should be 8");
 static_assert(offsetof(PathStencilFuncCHROMIUM, mask) == 12,
               "offset of PathStencilFuncCHROMIUM mask should be 12");
 
 struct StencilFillPathCHROMIUM {
   typedef StencilFillPathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilFillPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLenum _fillMode, GLuint _mask) {
     SetHeader();
     path = _path;
@@ skipping 20 matching lines @@
               "offset of StencilFillPathCHROMIUM path should be 4");
 static_assert(offsetof(StencilFillPathCHROMIUM, fillMode) == 8,
               "offset of StencilFillPathCHROMIUM fillMode should be 8");
 static_assert(offsetof(StencilFillPathCHROMIUM, mask) == 12,
               "offset of StencilFillPathCHROMIUM mask should be 12");
 
 struct StencilStrokePathCHROMIUM {
   typedef StencilStrokePathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilStrokePathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLint _reference, GLuint _mask) {
     SetHeader();
     path = _path;
@@ skipping 20 matching lines @@
               "offset of StencilStrokePathCHROMIUM path should be 4");
 static_assert(offsetof(StencilStrokePathCHROMIUM, reference) == 8,
               "offset of StencilStrokePathCHROMIUM reference should be 8");
 static_assert(offsetof(StencilStrokePathCHROMIUM, mask) == 12,
               "offset of StencilStrokePathCHROMIUM mask should be 12");
 
 struct CoverFillPathCHROMIUM {
   typedef CoverFillPathCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverFillPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLenum _coverMode) {
     SetHeader();
     path = _path;
@@ skipping 16 matching lines @@
               "offset of CoverFillPathCHROMIUM header should be 0");
 static_assert(offsetof(CoverFillPathCHROMIUM, path) == 4,
               "offset of CoverFillPathCHROMIUM path should be 4");
 static_assert(offsetof(CoverFillPathCHROMIUM, coverMode) == 8,
               "offset of CoverFillPathCHROMIUM coverMode should be 8");
 
 struct CoverStrokePathCHROMIUM {
   typedef CoverStrokePathCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverStrokePathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLenum _coverMode) {
     SetHeader();
     path = _path;
@@ skipping 16 matching lines @@
               "offset of CoverStrokePathCHROMIUM header should be 0");
 static_assert(offsetof(CoverStrokePathCHROMIUM, path) == 4,
               "offset of CoverStrokePathCHROMIUM path should be 4");
 static_assert(offsetof(CoverStrokePathCHROMIUM, coverMode) == 8,
               "offset of CoverStrokePathCHROMIUM coverMode should be 8");
 
 struct StencilThenCoverFillPathCHROMIUM {
   typedef StencilThenCoverFillPathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverFillPathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLenum _fillMode, GLuint _mask, GLenum _coverMode) {
     SetHeader();
     path = _path;
@@ skipping 30 matching lines @@
 static_assert(offsetof(StencilThenCoverFillPathCHROMIUM, mask) == 12,
               "offset of StencilThenCoverFillPathCHROMIUM mask should be 12");
 static_assert(
     offsetof(StencilThenCoverFillPathCHROMIUM, coverMode) == 16,
     "offset of StencilThenCoverFillPathCHROMIUM coverMode should be 16");
 
 struct StencilThenCoverStrokePathCHROMIUM {
   typedef StencilThenCoverStrokePathCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverStrokePathCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _path, GLint _reference, GLuint _mask, GLenum _coverMode) {
     SetHeader();
     path = _path;
@@ skipping 31 matching lines @@
 static_assert(offsetof(StencilThenCoverStrokePathCHROMIUM, mask) == 12,
               "offset of StencilThenCoverStrokePathCHROMIUM mask should be 12");
 static_assert(
     offsetof(StencilThenCoverStrokePathCHROMIUM, coverMode) == 16,
     "offset of StencilThenCoverStrokePathCHROMIUM coverMode should be 16");
 
 struct StencilFillPathInstancedCHROMIUM {
   typedef StencilFillPathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilFillPathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _numPaths,
             GLenum _pathNameType,
             uint32_t _paths_shm_id,
@@ skipping 81 matching lines @@
               "transformValues_shm_id should be 36");
 static_assert(offsetof(StencilFillPathInstancedCHROMIUM,
                        transformValues_shm_offset) == 40,
               "offset of StencilFillPathInstancedCHROMIUM "
               "transformValues_shm_offset should be 40");
 
 struct StencilStrokePathInstancedCHROMIUM {
   typedef StencilStrokePathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilStrokePathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _numPaths,
             GLenum _pathNameType,
             uint32_t _paths_shm_id,
@@ skipping 83 matching lines @@
               "transformValues_shm_id should be 36");
 static_assert(offsetof(StencilStrokePathInstancedCHROMIUM,
                        transformValues_shm_offset) == 40,
               "offset of StencilStrokePathInstancedCHROMIUM "
               "transformValues_shm_offset should be 40");
 
 struct CoverFillPathInstancedCHROMIUM {
   typedef CoverFillPathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverFillPathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _numPaths,
             GLenum _pathNameType,
             uint32_t _paths_shm_id,
@@ skipping 73 matching lines @@
               "should be 32");
 static_assert(offsetof(CoverFillPathInstancedCHROMIUM,
                        transformValues_shm_offset) == 36,
               "offset of CoverFillPathInstancedCHROMIUM "
               "transformValues_shm_offset should be 36");
 
 struct CoverStrokePathInstancedCHROMIUM {
   typedef CoverStrokePathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kCoverStrokePathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _numPaths,
             GLenum _pathNameType,
             uint32_t _paths_shm_id,
@@ skipping 75 matching lines @@
               "transformValues_shm_id should be 32");
 static_assert(offsetof(CoverStrokePathInstancedCHROMIUM,
                        transformValues_shm_offset) == 36,
               "offset of CoverStrokePathInstancedCHROMIUM "
               "transformValues_shm_offset should be 36");
 
 struct StencilThenCoverFillPathInstancedCHROMIUM {
   typedef StencilThenCoverFillPathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverFillPathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _numPaths,
             GLenum _pathNameType,
             uint32_t _paths_shm_id,
@@ skipping 97 matching lines @@
               "transformValues_shm_id should be 40");
 static_assert(offsetof(StencilThenCoverFillPathInstancedCHROMIUM,
                        transformValues_shm_offset) == 44,
               "offset of StencilThenCoverFillPathInstancedCHROMIUM "
               "transformValues_shm_offset should be 44");
 
 struct StencilThenCoverStrokePathInstancedCHROMIUM {
   typedef StencilThenCoverStrokePathInstancedCHROMIUM ValueType;
   static const CommandId kCmdId = kStencilThenCoverStrokePathInstancedCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLsizei _numPaths,
             GLenum _pathNameType,
             uint32_t _paths_shm_id,
@@ skipping 99 matching lines @@
               "transformValues_shm_id should be 40");
 static_assert(offsetof(StencilThenCoverStrokePathInstancedCHROMIUM,
                        transformValues_shm_offset) == 44,
               "offset of StencilThenCoverStrokePathInstancedCHROMIUM "
               "transformValues_shm_offset should be 44");
 
 struct BindFragmentInputLocationCHROMIUMBucket {
   typedef BindFragmentInputLocationCHROMIUMBucket ValueType;
   static const CommandId kCmdId = kBindFragmentInputLocationCHROMIUMBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLint _location, uint32_t _name_bucket_id) {
     SetHeader();
     program = _program;
@@ skipping 28 matching lines @@
     "offset of BindFragmentInputLocationCHROMIUMBucket location should be 8");
 static_assert(offsetof(BindFragmentInputLocationCHROMIUMBucket,
                        name_bucket_id) == 12,
               "offset of BindFragmentInputLocationCHROMIUMBucket "
               "name_bucket_id should be 12");
 
 struct ProgramPathFragmentInputGenCHROMIUM {
   typedef ProgramPathFragmentInputGenCHROMIUM ValueType;
   static const CommandId kCmdId = kProgramPathFragmentInputGenCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
             GLint _location,
             GLenum _genMode,
@@ skipping 53 matching lines @@
     "offset of ProgramPathFragmentInputGenCHROMIUM coeffs_shm_id should be 20");
 static_assert(offsetof(ProgramPathFragmentInputGenCHROMIUM,
                        coeffs_shm_offset) == 24,
               "offset of ProgramPathFragmentInputGenCHROMIUM coeffs_shm_offset "
               "should be 24");
 
 struct BlendBarrierKHR {
   typedef BlendBarrierKHR ValueType;
   static const CommandId kCmdId = kBlendBarrierKHR;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(BlendBarrierKHR) == 4,
               "size of BlendBarrierKHR should be 4");
 static_assert(offsetof(BlendBarrierKHR, header) == 0,
               "offset of BlendBarrierKHR header should be 0");
 
 struct ApplyScreenSpaceAntialiasingCHROMIUM {
   typedef ApplyScreenSpaceAntialiasingCHROMIUM ValueType;
   static const CommandId kCmdId = kApplyScreenSpaceAntialiasingCHROMIUM;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init() { SetHeader(); }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
   gpu::CommandHeader header;
 };
 
 static_assert(sizeof(ApplyScreenSpaceAntialiasingCHROMIUM) == 4,
               "size of ApplyScreenSpaceAntialiasingCHROMIUM should be 4");
 static_assert(
     offsetof(ApplyScreenSpaceAntialiasingCHROMIUM, header) == 0,
     "offset of ApplyScreenSpaceAntialiasingCHROMIUM header should be 0");
 
 struct BindFragDataLocationIndexedEXTBucket {
   typedef BindFragDataLocationIndexedEXTBucket ValueType;
   static const CommandId kCmdId = kBindFragDataLocationIndexedEXTBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
             GLuint _colorNumber,
             GLuint _index,
@@ skipping 38 matching lines @@
     "offset of BindFragDataLocationIndexedEXTBucket index should be 12");
 static_assert(offsetof(BindFragDataLocationIndexedEXTBucket, name_bucket_id) ==
                   16,
               "offset of BindFragDataLocationIndexedEXTBucket name_bucket_id "
               "should be 16");
 
 struct BindFragDataLocationEXTBucket {
   typedef BindFragDataLocationEXTBucket ValueType;
   static const CommandId kCmdId = kBindFragDataLocationEXTBucket;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program, GLuint _colorNumber, uint32_t _name_bucket_id) {
     SetHeader();
     program = _program;
@@ skipping 25 matching lines @@
     offsetof(BindFragDataLocationEXTBucket, colorNumber) == 8,
     "offset of BindFragDataLocationEXTBucket colorNumber should be 8");
 static_assert(
     offsetof(BindFragDataLocationEXTBucket, name_bucket_id) == 12,
     "offset of BindFragDataLocationEXTBucket name_bucket_id should be 12");
 
 struct GetFragDataIndexEXT {
   typedef GetFragDataIndexEXT ValueType;
   static const CommandId kCmdId = kGetFragDataIndexEXT;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
-  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+  static const uint8_t cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   typedef GLint Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _program,
@@ skipping 31 matching lines @@
 static_assert(offsetof(GetFragDataIndexEXT, program) == 4,
               "offset of GetFragDataIndexEXT program should be 4");
 static_assert(offsetof(GetFragDataIndexEXT, name_bucket_id) == 8,
               "offset of GetFragDataIndexEXT name_bucket_id should be 8");
 static_assert(offsetof(GetFragDataIndexEXT, index_shm_id) == 12,
               "offset of GetFragDataIndexEXT index_shm_id should be 12");
 static_assert(offsetof(GetFragDataIndexEXT, index_shm_offset) == 16,
               "offset of GetFragDataIndexEXT index_shm_offset should be 16");
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_