Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / gpu / command_buffer / common / gles2_cmd_format_test_autogen.h

diff --git a/src/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/src/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index ff172a1..115137d 100644 (file)
--- a/src/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/src/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -17,7 +17,7 @@
 TEST_F(GLES2FormatTest, ActiveTexture) {
   cmds::ActiveTexture& cmd = *GetBufferAs<cmds::ActiveTexture>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::ActiveTexture::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ActiveTexture::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.texture);
@@ -28,7 +28,7 @@ TEST_F(GLES2FormatTest, AttachShader) {
   cmds::AttachShader& cmd = *GetBufferAs<cmds::AttachShader>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::AttachShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::AttachShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
@@ -41,17 +41,17 @@ TEST_F(GLES2FormatTest, BindAttribLocation) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLuint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocation::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindAttribLocation::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.name_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.name_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.data_size);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -61,13 +61,13 @@ TEST_F(GLES2FormatTest, BindAttribLocationBucket) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLuint>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocationBucket::kCmdId),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindAttribLocationBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.name_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -75,7 +75,8 @@ TEST_F(GLES2FormatTest, BindBuffer) {
   cmds::BindBuffer& cmd = *GetBufferAs<cmds::BindBuffer>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindBuffer::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindBuffer::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.buffer);
@@ -86,7 +87,7 @@ TEST_F(GLES2FormatTest, BindFramebuffer) {
   cmds::BindFramebuffer& cmd = *GetBufferAs<cmds::BindFramebuffer>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindFramebuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindFramebuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -98,7 +99,7 @@ TEST_F(GLES2FormatTest, BindRenderbuffer) {
   cmds::BindRenderbuffer& cmd = *GetBufferAs<cmds::BindRenderbuffer>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindRenderbuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindRenderbuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -110,7 +111,8 @@ TEST_F(GLES2FormatTest, BindTexture) {
   cmds::BindTexture& cmd = *GetBufferAs<cmds::BindTexture>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindTexture::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindTexture::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.texture);
@@ -124,7 +126,8 @@ TEST_F(GLES2FormatTest, BlendColor) {
                            static_cast<GLclampf>(12),
                            static_cast<GLclampf>(13),
                            static_cast<GLclampf>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::BlendColor::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BlendColor::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
   EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
@@ -136,7 +139,7 @@ TEST_F(GLES2FormatTest, BlendColor) {
 TEST_F(GLES2FormatTest, BlendEquation) {
   cmds::BlendEquation& cmd = *GetBufferAs<cmds::BlendEquation>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::BlendEquation::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BlendEquation::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
@@ -148,7 +151,7 @@ TEST_F(GLES2FormatTest, BlendEquationSeparate) {
       *GetBufferAs<cmds::BlendEquationSeparate>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BlendEquationSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BlendEquationSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.modeRGB);
@@ -160,7 +163,7 @@ TEST_F(GLES2FormatTest, BlendFunc) {
   cmds::BlendFunc& cmd = *GetBufferAs<cmds::BlendFunc>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BlendFunc::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BlendFunc::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.sfactor);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.dfactor);
@@ -174,7 +177,7 @@ TEST_F(GLES2FormatTest, BlendFuncSeparate) {
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13),
                            static_cast<GLenum>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::BlendFuncSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BlendFuncSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.srcRGB);
@@ -189,15 +192,16 @@ TEST_F(GLES2FormatTest, BufferData) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLsizeiptr>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14),
                            static_cast<GLenum>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::BufferData::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BufferData::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizeiptr>(12), cmd.size);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.data_shm_offset);
   EXPECT_EQ(static_cast<GLenum>(15), cmd.usage);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -208,16 +212,16 @@ TEST_F(GLES2FormatTest, BufferSubData) {
                            static_cast<GLenum>(11),
                            static_cast<GLintptr>(12),
                            static_cast<GLsizeiptr>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::BufferSubData::kCmdId),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BufferSubData::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLintptr>(12), cmd.offset);
   EXPECT_EQ(static_cast<GLsizeiptr>(13), cmd.size);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -226,21 +230,21 @@ TEST_F(GLES2FormatTest, CheckFramebufferStatus) {
       *GetBufferAs<cmds::CheckFramebufferStatus>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::CheckFramebufferStatus::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CheckFramebufferStatus::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Clear) {
   cmds::Clear& cmd = *GetBufferAs<cmds::Clear>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLbitfield>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::Clear::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Clear::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -253,7 +257,8 @@ TEST_F(GLES2FormatTest, ClearColor) {
                            static_cast<GLclampf>(12),
                            static_cast<GLclampf>(13),
                            static_cast<GLclampf>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::ClearColor::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ClearColor::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
   EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
@@ -265,7 +270,8 @@ TEST_F(GLES2FormatTest, ClearColor) {
 TEST_F(GLES2FormatTest, ClearDepthf) {
   cmds::ClearDepthf& cmd = *GetBufferAs<cmds::ClearDepthf>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLclampf>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::ClearDepthf::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ClearDepthf::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -274,7 +280,7 @@ TEST_F(GLES2FormatTest, ClearDepthf) {
 TEST_F(GLES2FormatTest, ClearStencil) {
   cmds::ClearStencil& cmd = *GetBufferAs<cmds::ClearStencil>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::ClearStencil::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ClearStencil::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.s);
@@ -288,7 +294,7 @@ TEST_F(GLES2FormatTest, ColorMask) {
                            static_cast<GLboolean>(12),
                            static_cast<GLboolean>(13),
                            static_cast<GLboolean>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::ColorMask::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ColorMask::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLboolean>(11), cmd.red);
   EXPECT_EQ(static_cast<GLboolean>(12), cmd.green);
@@ -300,7 +306,7 @@ TEST_F(GLES2FormatTest, ColorMask) {
 TEST_F(GLES2FormatTest, CompileShader) {
   cmds::CompileShader& cmd = *GetBufferAs<cmds::CompileShader>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::CompileShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CompileShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
@@ -317,9 +323,9 @@ TEST_F(GLES2FormatTest, CompressedTexImage2D) {
                            static_cast<GLsizei>(15),
                            static_cast<GLint>(16),
                            static_cast<GLsizei>(17),
-                           static_cast<uint32>(18),
-                           static_cast<uint32>(19));
-  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexImage2D::kCmdId),
+                           static_cast<uint32_t>(18),
+                           static_cast<uint32_t>(19));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CompressedTexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -329,8 +335,8 @@ TEST_F(GLES2FormatTest, CompressedTexImage2D) {
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize);
-  EXPECT_EQ(static_cast<uint32>(18), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(18), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -345,7 +351,7 @@ TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
                            static_cast<GLsizei>(15),
                            static_cast<GLint>(16),
                            static_cast<GLuint>(17));
-  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexImage2DBucket::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CompressedTexImage2DBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -370,9 +376,9 @@ TEST_F(GLES2FormatTest, CompressedTexSubImage2D) {
                            static_cast<GLsizei>(16),
                            static_cast<GLenum>(17),
                            static_cast<GLsizei>(18),
-                           static_cast<uint32>(19),
-                           static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexSubImage2D::kCmdId),
+                           static_cast<uint32_t>(19),
+                           static_cast<uint32_t>(20));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CompressedTexSubImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -383,8 +389,8 @@ TEST_F(GLES2FormatTest, CompressedTexSubImage2D) {
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLsizei>(18), cmd.imageSize);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -400,7 +406,7 @@ TEST_F(GLES2FormatTest, CompressedTexSubImage2DBucket) {
                            static_cast<GLsizei>(16),
                            static_cast<GLenum>(17),
                            static_cast<GLuint>(18));
-  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexSubImage2DBucket::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CompressedTexSubImage2DBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -425,7 +431,7 @@ TEST_F(GLES2FormatTest, CopyTexImage2D) {
                            static_cast<GLsizei>(16),
                            static_cast<GLsizei>(17),
                            static_cast<GLint>(18));
-  EXPECT_EQ(static_cast<uint32>(cmds::CopyTexImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CopyTexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -450,7 +456,7 @@ TEST_F(GLES2FormatTest, CopyTexSubImage2D) {
                            static_cast<GLint>(16),
                            static_cast<GLsizei>(17),
                            static_cast<GLsizei>(18));
-  EXPECT_EQ(static_cast<uint32>(cmds::CopyTexSubImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CopyTexSubImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -466,30 +472,30 @@ TEST_F(GLES2FormatTest, CopyTexSubImage2D) {
 
 TEST_F(GLES2FormatTest, CreateProgram) {
   cmds::CreateProgram& cmd = *GetBufferAs<cmds::CreateProgram>();
-  void* next_cmd = cmd.Set(&cmd, static_cast<uint32>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::CreateProgram::kCmdId),
+  void* next_cmd = cmd.Set(&cmd, static_cast<uint32_t>(11));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CreateProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<uint32>(11), cmd.client_id);
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.client_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CreateShader) {
   cmds::CreateShader& cmd = *GetBufferAs<cmds::CreateShader>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::CreateShader::kCmdId),
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CreateShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.type);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.client_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.client_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CullFace) {
   cmds::CullFace& cmd = *GetBufferAs<cmds::CullFace>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::CullFace::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CullFace::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -499,23 +505,25 @@ TEST_F(GLES2FormatTest, DeleteBuffers) {
   cmds::DeleteBuffers& cmd = *GetBufferAs<cmds::DeleteBuffers>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteBuffers::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteBuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.buffers_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.buffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteBuffersImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::DeleteBuffersImmediate& cmd =
       *GetBufferAs<cmds::DeleteBuffersImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteBuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteBuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -530,23 +538,25 @@ TEST_F(GLES2FormatTest, DeleteFramebuffers) {
   cmds::DeleteFramebuffers& cmd = *GetBufferAs<cmds::DeleteFramebuffers>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteFramebuffers::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteFramebuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.framebuffers_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.framebuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteFramebuffersImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::DeleteFramebuffersImmediate& cmd =
       *GetBufferAs<cmds::DeleteFramebuffersImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteFramebuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteFramebuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -560,7 +570,7 @@ TEST_F(GLES2FormatTest, DeleteFramebuffersImmediate) {
 TEST_F(GLES2FormatTest, DeleteProgram) {
   cmds::DeleteProgram& cmd = *GetBufferAs<cmds::DeleteProgram>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
@@ -571,23 +581,25 @@ TEST_F(GLES2FormatTest, DeleteRenderbuffers) {
   cmds::DeleteRenderbuffers& cmd = *GetBufferAs<cmds::DeleteRenderbuffers>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteRenderbuffers::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteRenderbuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.renderbuffers_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.renderbuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteRenderbuffersImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::DeleteRenderbuffersImmediate& cmd =
       *GetBufferAs<cmds::DeleteRenderbuffersImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteRenderbuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteRenderbuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -601,7 +613,7 @@ TEST_F(GLES2FormatTest, DeleteRenderbuffersImmediate) {
 TEST_F(GLES2FormatTest, DeleteShader) {
   cmds::DeleteShader& cmd = *GetBufferAs<cmds::DeleteShader>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
@@ -612,23 +624,25 @@ TEST_F(GLES2FormatTest, DeleteTextures) {
   cmds::DeleteTextures& cmd = *GetBufferAs<cmds::DeleteTextures>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteTextures::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteTextures::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.textures_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.textures_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteTexturesImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::DeleteTexturesImmediate& cmd =
       *GetBufferAs<cmds::DeleteTexturesImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteTexturesImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteTexturesImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -642,7 +656,7 @@ TEST_F(GLES2FormatTest, DeleteTexturesImmediate) {
 TEST_F(GLES2FormatTest, DepthFunc) {
   cmds::DepthFunc& cmd = *GetBufferAs<cmds::DepthFunc>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::DepthFunc::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DepthFunc::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -651,7 +665,7 @@ TEST_F(GLES2FormatTest, DepthFunc) {
 TEST_F(GLES2FormatTest, DepthMask) {
   cmds::DepthMask& cmd = *GetBufferAs<cmds::DepthMask>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLboolean>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::DepthMask::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DepthMask::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -661,7 +675,8 @@ TEST_F(GLES2FormatTest, DepthRangef) {
   cmds::DepthRangef& cmd = *GetBufferAs<cmds::DepthRangef>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLclampf>(11), static_cast<GLclampf>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::DepthRangef::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DepthRangef::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.zNear);
   EXPECT_EQ(static_cast<GLclampf>(12), cmd.zFar);
@@ -672,7 +687,7 @@ TEST_F(GLES2FormatTest, DetachShader) {
   cmds::DetachShader& cmd = *GetBufferAs<cmds::DetachShader>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::DetachShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DetachShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
@@ -683,7 +698,7 @@ TEST_F(GLES2FormatTest, DetachShader) {
 TEST_F(GLES2FormatTest, Disable) {
   cmds::Disable& cmd = *GetBufferAs<cmds::Disable>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::Disable::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Disable::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -693,7 +708,7 @@ TEST_F(GLES2FormatTest, DisableVertexAttribArray) {
   cmds::DisableVertexAttribArray& cmd =
       *GetBufferAs<cmds::DisableVertexAttribArray>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::DisableVertexAttribArray::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DisableVertexAttribArray::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
@@ -706,7 +721,8 @@ TEST_F(GLES2FormatTest, DrawArrays) {
                            static_cast<GLenum>(11),
                            static_cast<GLint>(12),
                            static_cast<GLsizei>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DrawArrays::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawArrays::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   EXPECT_EQ(static_cast<GLint>(12), cmd.first);
@@ -721,7 +737,7 @@ TEST_F(GLES2FormatTest, DrawElements) {
                            static_cast<GLsizei>(12),
                            static_cast<GLenum>(13),
                            static_cast<GLuint>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::DrawElements::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawElements::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
@@ -734,7 +750,7 @@ TEST_F(GLES2FormatTest, DrawElements) {
 TEST_F(GLES2FormatTest, Enable) {
   cmds::Enable& cmd = *GetBufferAs<cmds::Enable>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::Enable::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Enable::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -744,7 +760,7 @@ TEST_F(GLES2FormatTest, EnableVertexAttribArray) {
   cmds::EnableVertexAttribArray& cmd =
       *GetBufferAs<cmds::EnableVertexAttribArray>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::EnableVertexAttribArray::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::EnableVertexAttribArray::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
@@ -754,7 +770,7 @@ TEST_F(GLES2FormatTest, EnableVertexAttribArray) {
 TEST_F(GLES2FormatTest, Finish) {
   cmds::Finish& cmd = *GetBufferAs<cmds::Finish>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::Finish::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Finish::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -762,7 +778,7 @@ TEST_F(GLES2FormatTest, Finish) {
 TEST_F(GLES2FormatTest, Flush) {
   cmds::Flush& cmd = *GetBufferAs<cmds::Flush>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::Flush::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Flush::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -775,7 +791,7 @@ TEST_F(GLES2FormatTest, FramebufferRenderbuffer) {
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13),
                            static_cast<GLuint>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::FramebufferRenderbuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::FramebufferRenderbuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -793,7 +809,7 @@ TEST_F(GLES2FormatTest, FramebufferTexture2D) {
                            static_cast<GLenum>(13),
                            static_cast<GLuint>(14),
                            static_cast<GLint>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::FramebufferTexture2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::FramebufferTexture2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -807,7 +823,7 @@ TEST_F(GLES2FormatTest, FramebufferTexture2D) {
 TEST_F(GLES2FormatTest, FrontFace) {
   cmds::FrontFace& cmd = *GetBufferAs<cmds::FrontFace>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::FrontFace::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::FrontFace::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -817,21 +833,24 @@ TEST_F(GLES2FormatTest, GenBuffers) {
   cmds::GenBuffers& cmd = *GetBufferAs<cmds::GenBuffers>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenBuffers::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenBuffers::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.buffers_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.buffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenBuffersImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::GenBuffersImmediate& cmd = *GetBufferAs<cmds::GenBuffersImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::GenBuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenBuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -845,7 +864,7 @@ TEST_F(GLES2FormatTest, GenBuffersImmediate) {
 TEST_F(GLES2FormatTest, GenerateMipmap) {
   cmds::GenerateMipmap& cmd = *GetBufferAs<cmds::GenerateMipmap>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenerateMipmap::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenerateMipmap::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -856,23 +875,25 @@ TEST_F(GLES2FormatTest, GenFramebuffers) {
   cmds::GenFramebuffers& cmd = *GetBufferAs<cmds::GenFramebuffers>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenFramebuffers::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenFramebuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.framebuffers_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.framebuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenFramebuffersImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::GenFramebuffersImmediate& cmd =
       *GetBufferAs<cmds::GenFramebuffersImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::GenFramebuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenFramebuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -887,23 +908,25 @@ TEST_F(GLES2FormatTest, GenRenderbuffers) {
   cmds::GenRenderbuffers& cmd = *GetBufferAs<cmds::GenRenderbuffers>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenRenderbuffers::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenRenderbuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.renderbuffers_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.renderbuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenRenderbuffersImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::GenRenderbuffersImmediate& cmd =
       *GetBufferAs<cmds::GenRenderbuffersImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::GenRenderbuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenRenderbuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -918,21 +941,24 @@ TEST_F(GLES2FormatTest, GenTextures) {
   cmds::GenTextures& cmd = *GetBufferAs<cmds::GenTextures>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenTextures::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenTextures::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.textures_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.textures_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenTexturesImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::GenTexturesImmediate& cmd = *GetBufferAs<cmds::GenTexturesImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::GenTexturesImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenTexturesImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -948,17 +974,17 @@ TEST_F(GLES2FormatTest, GetActiveAttrib) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLuint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetActiveAttrib::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetActiveAttrib::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.name_bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -967,17 +993,17 @@ TEST_F(GLES2FormatTest, GetActiveUniform) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLuint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetActiveUniform::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetActiveUniform::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.name_bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -985,16 +1011,16 @@ TEST_F(GLES2FormatTest, GetAttachedShaders) {
   cmds::GetAttachedShaders& cmd = *GetBufferAs<cmds::GetAttachedShaders>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetAttachedShaders::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetAttachedShaders::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.result_size);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.result_size);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1004,13 +1030,14 @@ TEST_F(GLES2FormatTest, GetBooleanv) {
   cmds::GetBooleanv& cmd = *GetBufferAs<cmds::GetBooleanv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetBooleanv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetBooleanv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1019,26 +1046,26 @@ TEST_F(GLES2FormatTest, GetBufferParameteriv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetBufferParameteriv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetBufferParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetError) {
   cmds::GetError& cmd = *GetBufferAs<cmds::GetError>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<uint32>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetError::kCmdId), cmd.header.command);
+      cmd.Set(&cmd, static_cast<uint32_t>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetError::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<uint32>(11), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1046,13 +1073,13 @@ TEST_F(GLES2FormatTest, GetFloatv) {
   cmds::GetFloatv& cmd = *GetBufferAs<cmds::GetFloatv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetFloatv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetFloatv::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1063,17 +1090,17 @@ TEST_F(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
   EXPECT_EQ(
-      static_cast<uint32>(cmds::GetFramebufferAttachmentParameteriv::kCmdId),
+      static_cast<uint32_t>(cmds::GetFramebufferAttachmentParameteriv::kCmdId),
       cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1081,13 +1108,14 @@ TEST_F(GLES2FormatTest, GetIntegerv) {
   cmds::GetIntegerv& cmd = *GetBufferAs<cmds::GetIntegerv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetIntegerv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetIntegerv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1096,27 +1124,27 @@ TEST_F(GLES2FormatTest, GetProgramiv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramiv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetProgramiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetProgramInfoLog) {
   cmds::GetProgramInfoLog& cmd = *GetBufferAs<cmds::GetProgramInfoLog>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoLog::kCmdId),
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetProgramInfoLog::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1126,15 +1154,15 @@ TEST_F(GLES2FormatTest, GetRenderbufferParameteriv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetRenderbufferParameteriv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetRenderbufferParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1143,26 +1171,27 @@ TEST_F(GLES2FormatTest, GetShaderiv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderiv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetShaderiv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderInfoLog) {
   cmds::GetShaderInfoLog& cmd = *GetBufferAs<cmds::GetShaderInfoLog>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderInfoLog::kCmdId),
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetShaderInfoLog::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1172,38 +1201,38 @@ TEST_F(GLES2FormatTest, GetShaderPrecisionFormat) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderPrecisionFormat::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetShaderPrecisionFormat::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.shadertype);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.precisiontype);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderSource) {
   cmds::GetShaderSource& cmd = *GetBufferAs<cmds::GetShaderSource>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderSource::kCmdId),
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetShaderSource::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetString) {
   cmds::GetString& cmd = *GetBufferAs<cmds::GetString>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetString::kCmdId), cmd.header.command);
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetString::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.name);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1212,15 +1241,15 @@ TEST_F(GLES2FormatTest, GetTexParameterfv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetTexParameterfv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetTexParameterfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1229,15 +1258,15 @@ TEST_F(GLES2FormatTest, GetTexParameteriv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetTexParameteriv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetTexParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1246,15 +1275,15 @@ TEST_F(GLES2FormatTest, GetUniformfv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetUniformfv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetUniformfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1263,15 +1292,15 @@ TEST_F(GLES2FormatTest, GetUniformiv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetUniformiv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetUniformiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1282,15 +1311,15 @@ TEST_F(GLES2FormatTest, GetVertexAttribfv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribfv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetVertexAttribfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1299,15 +1328,15 @@ TEST_F(GLES2FormatTest, GetVertexAttribiv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribiv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetVertexAttribiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1317,15 +1346,15 @@ TEST_F(GLES2FormatTest, GetVertexAttribPointerv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribPointerv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetVertexAttribPointerv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.pointer_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.pointer_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.pointer_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.pointer_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1333,7 +1362,7 @@ TEST_F(GLES2FormatTest, Hint) {
   cmds::Hint& cmd = *GetBufferAs<cmds::Hint>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::Hint::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Hint::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.mode);
@@ -1344,13 +1373,13 @@ TEST_F(GLES2FormatTest, IsBuffer) {
   cmds::IsBuffer& cmd = *GetBufferAs<cmds::IsBuffer>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsBuffer::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsBuffer::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1358,13 +1387,13 @@ TEST_F(GLES2FormatTest, IsEnabled) {
   cmds::IsEnabled& cmd = *GetBufferAs<cmds::IsEnabled>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsEnabled::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsEnabled::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1372,14 +1401,14 @@ TEST_F(GLES2FormatTest, IsFramebuffer) {
   cmds::IsFramebuffer& cmd = *GetBufferAs<cmds::IsFramebuffer>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsFramebuffer::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsFramebuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.framebuffer);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1387,13 +1416,13 @@ TEST_F(GLES2FormatTest, IsProgram) {
   cmds::IsProgram& cmd = *GetBufferAs<cmds::IsProgram>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsProgram::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsProgram::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1401,14 +1430,14 @@ TEST_F(GLES2FormatTest, IsRenderbuffer) {
   cmds::IsRenderbuffer& cmd = *GetBufferAs<cmds::IsRenderbuffer>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsRenderbuffer::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsRenderbuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.renderbuffer);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1416,13 +1445,13 @@ TEST_F(GLES2FormatTest, IsShader) {
   cmds::IsShader& cmd = *GetBufferAs<cmds::IsShader>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsShader::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsShader::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1430,20 +1459,20 @@ TEST_F(GLES2FormatTest, IsTexture) {
   cmds::IsTexture& cmd = *GetBufferAs<cmds::IsTexture>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsTexture::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsTexture::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, LineWidth) {
   cmds::LineWidth& cmd = *GetBufferAs<cmds::LineWidth>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLfloat>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::LineWidth::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::LineWidth::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLfloat>(11), cmd.width);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -1452,7 +1481,8 @@ TEST_F(GLES2FormatTest, LineWidth) {
 TEST_F(GLES2FormatTest, LinkProgram) {
   cmds::LinkProgram& cmd = *GetBufferAs<cmds::LinkProgram>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::LinkProgram::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::LinkProgram::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -1462,7 +1492,8 @@ TEST_F(GLES2FormatTest, PixelStorei) {
   cmds::PixelStorei& cmd = *GetBufferAs<cmds::PixelStorei>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::PixelStorei::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::PixelStorei::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
   EXPECT_EQ(static_cast<GLint>(12), cmd.param);
@@ -1473,7 +1504,7 @@ TEST_F(GLES2FormatTest, PolygonOffset) {
   cmds::PolygonOffset& cmd = *GetBufferAs<cmds::PolygonOffset>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLfloat>(11), static_cast<GLfloat>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::PolygonOffset::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::PolygonOffset::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLfloat>(11), cmd.factor);
@@ -1490,12 +1521,13 @@ TEST_F(GLES2FormatTest, ReadPixels) {
                            static_cast<GLsizei>(14),
                            static_cast<GLenum>(15),
                            static_cast<GLenum>(16),
-                           static_cast<uint32>(17),
-                           static_cast<uint32>(18),
-                           static_cast<uint32>(19),
-                           static_cast<uint32>(20),
+                           static_cast<uint32_t>(17),
+                           static_cast<uint32_t>(18),
+                           static_cast<uint32_t>(19),
+                           static_cast<uint32_t>(20),
                            static_cast<GLboolean>(21));
-  EXPECT_EQ(static_cast<uint32>(cmds::ReadPixels::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ReadPixels::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
@@ -1503,10 +1535,10 @@ TEST_F(GLES2FormatTest, ReadPixels) {
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(15), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(16), cmd.type);
-  EXPECT_EQ(static_cast<uint32>(17), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(20), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(17), cmd.pixels_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(18), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.result_shm_offset);
   EXPECT_EQ(static_cast<GLboolean>(21), cmd.async);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -1515,7 +1547,7 @@ TEST_F(GLES2FormatTest, ReleaseShaderCompiler) {
   cmds::ReleaseShaderCompiler& cmd =
       *GetBufferAs<cmds::ReleaseShaderCompiler>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseShaderCompiler::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ReleaseShaderCompiler::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -1528,7 +1560,7 @@ TEST_F(GLES2FormatTest, RenderbufferStorage) {
                            static_cast<GLenum>(12),
                            static_cast<GLsizei>(13),
                            static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::RenderbufferStorage::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::RenderbufferStorage::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -1542,7 +1574,7 @@ TEST_F(GLES2FormatTest, SampleCoverage) {
   cmds::SampleCoverage& cmd = *GetBufferAs<cmds::SampleCoverage>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLclampf>(11), static_cast<GLboolean>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::SampleCoverage::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::SampleCoverage::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
@@ -1557,7 +1589,7 @@ TEST_F(GLES2FormatTest, Scissor) {
                            static_cast<GLint>(12),
                            static_cast<GLsizei>(13),
                            static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Scissor::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Scissor::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
@@ -1570,21 +1602,21 @@ TEST_F(GLES2FormatTest, ShaderBinary) {
   cmds::ShaderBinary& cmd = *GetBufferAs<cmds::ShaderBinary>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13),
                            static_cast<GLenum>(14),
-                           static_cast<uint32>(15),
-                           static_cast<uint32>(16),
+                           static_cast<uint32_t>(15),
+                           static_cast<uint32_t>(16),
                            static_cast<GLsizei>(17));
-  EXPECT_EQ(static_cast<uint32>(cmds::ShaderBinary::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ShaderBinary::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.shaders_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.shaders_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.shaders_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.shaders_shm_offset);
   EXPECT_EQ(static_cast<GLenum>(14), cmd.binaryformat);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.binary_shm_id);
-  EXPECT_EQ(static_cast<uint32>(16), cmd.binary_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.binary_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(16), cmd.binary_shm_offset);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.length);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -1593,28 +1625,28 @@ TEST_F(GLES2FormatTest, ShaderSource) {
   cmds::ShaderSource& cmd = *GetBufferAs<cmds::ShaderSource>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSource::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ShaderSource::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_offset);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.data_size);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.data_size);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ShaderSourceBucket) {
   cmds::ShaderSourceBucket& cmd = *GetBufferAs<cmds::ShaderSourceBucket>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSourceBucket::kCmdId),
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ShaderSourceBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.data_bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.data_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1624,7 +1656,8 @@ TEST_F(GLES2FormatTest, StencilFunc) {
                            static_cast<GLenum>(11),
                            static_cast<GLint>(12),
                            static_cast<GLuint>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::StencilFunc::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::StencilFunc::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
   EXPECT_EQ(static_cast<GLint>(12), cmd.ref);
@@ -1639,7 +1672,7 @@ TEST_F(GLES2FormatTest, StencilFuncSeparate) {
                            static_cast<GLenum>(12),
                            static_cast<GLint>(13),
                            static_cast<GLuint>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::StencilFuncSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::StencilFuncSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
@@ -1652,7 +1685,8 @@ TEST_F(GLES2FormatTest, StencilFuncSeparate) {
 TEST_F(GLES2FormatTest, StencilMask) {
   cmds::StencilMask& cmd = *GetBufferAs<cmds::StencilMask>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::StencilMask::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::StencilMask::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -1662,7 +1696,7 @@ TEST_F(GLES2FormatTest, StencilMaskSeparate) {
   cmds::StencilMaskSeparate& cmd = *GetBufferAs<cmds::StencilMaskSeparate>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::StencilMaskSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::StencilMaskSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
@@ -1676,7 +1710,7 @@ TEST_F(GLES2FormatTest, StencilOp) {
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::StencilOp::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::StencilOp::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.fail);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail);
@@ -1691,7 +1725,7 @@ TEST_F(GLES2FormatTest, StencilOpSeparate) {
                            static_cast<GLenum>(12),
                            static_cast<GLenum>(13),
                            static_cast<GLenum>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::StencilOpSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::StencilOpSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
@@ -1712,9 +1746,10 @@ TEST_F(GLES2FormatTest, TexImage2D) {
                            static_cast<GLint>(16),
                            static_cast<GLenum>(17),
                            static_cast<GLenum>(18),
-                           static_cast<uint32>(19),
-                           static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexImage2D::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(19),
+                           static_cast<uint32_t>(20));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexImage2D::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
@@ -1724,8 +1759,8 @@ TEST_F(GLES2FormatTest, TexImage2D) {
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.pixels_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1735,7 +1770,7 @@ TEST_F(GLES2FormatTest, TexParameterf) {
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
                            static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterf::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameterf::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -1749,27 +1784,28 @@ TEST_F(GLES2FormatTest, TexParameterfv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameterfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
+  };
   cmds::TexParameterfvImmediate& cmd =
       *GetBufferAs<cmds::TexParameterfvImmediate>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameterfvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
@@ -1786,7 +1822,7 @@ TEST_F(GLES2FormatTest, TexParameteri) {
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
                            static_cast<GLint>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteri::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameteri::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -1800,26 +1836,28 @@ TEST_F(GLES2FormatTest, TexParameteriv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLenum>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteriv::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0), };
+  static GLint data[] = {
+      static_cast<GLint>(kSomeBaseValueToTestWith + 0),
+  };
   cmds::TexParameterivImmediate& cmd =
       *GetBufferAs<cmds::TexParameterivImmediate>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexParameterivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
@@ -1841,10 +1879,10 @@ TEST_F(GLES2FormatTest, TexSubImage2D) {
                            static_cast<GLsizei>(16),
                            static_cast<GLenum>(17),
                            static_cast<GLenum>(18),
-                           static_cast<uint32>(19),
-                           static_cast<uint32>(20),
+                           static_cast<uint32_t>(19),
+                           static_cast<uint32_t>(20),
                            static_cast<GLboolean>(21));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexSubImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexSubImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -1855,8 +1893,8 @@ TEST_F(GLES2FormatTest, TexSubImage2D) {
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.pixels_shm_offset);
   EXPECT_EQ(static_cast<GLboolean>(21), cmd.internal);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -1865,7 +1903,7 @@ TEST_F(GLES2FormatTest, Uniform1f) {
   cmds::Uniform1f& cmd = *GetBufferAs<cmds::Uniform1f>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLfloat>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1f::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1f::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
@@ -1877,14 +1915,15 @@ TEST_F(GLES2FormatTest, Uniform1fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1fv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1892,14 +1931,15 @@ TEST_F(GLES2FormatTest, Uniform1fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
+  };
   cmds::Uniform1fvImmediate& cmd = *GetBufferAs<cmds::Uniform1fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -1913,7 +1953,7 @@ TEST_F(GLES2FormatTest, Uniform1i) {
   cmds::Uniform1i& cmd = *GetBufferAs<cmds::Uniform1i>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1i::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1i::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
@@ -1925,28 +1965,31 @@ TEST_F(GLES2FormatTest, Uniform1iv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1iv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1iv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform1ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 1), };
+  static GLint data[] = {
+      static_cast<GLint>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 1),
+  };
   cmds::Uniform1ivImmediate& cmd = *GetBufferAs<cmds::Uniform1ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 1;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform1ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -1962,7 +2005,7 @@ TEST_F(GLES2FormatTest, Uniform2f) {
                            static_cast<GLint>(11),
                            static_cast<GLfloat>(12),
                            static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2f::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2f::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
@@ -1975,14 +2018,15 @@ TEST_F(GLES2FormatTest, Uniform2fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2fv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -1992,14 +2036,15 @@ TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
+  };
   cmds::Uniform2fvImmediate& cmd = *GetBufferAs<cmds::Uniform2fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2015,7 +2060,7 @@ TEST_F(GLES2FormatTest, Uniform2i) {
                            static_cast<GLint>(11),
                            static_cast<GLint>(12),
                            static_cast<GLint>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2i::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2i::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
@@ -2028,30 +2073,33 @@ TEST_F(GLES2FormatTest, Uniform2iv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2iv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2iv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 1),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 2),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 3), };
+  static GLint data[] = {
+      static_cast<GLint>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 1),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 2),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 3),
+  };
   cmds::Uniform2ivImmediate& cmd = *GetBufferAs<cmds::Uniform2ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 2;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform2ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2068,7 +2116,7 @@ TEST_F(GLES2FormatTest, Uniform3f) {
                            static_cast<GLfloat>(12),
                            static_cast<GLfloat>(13),
                            static_cast<GLfloat>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3f::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3f::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
@@ -2082,14 +2130,15 @@ TEST_F(GLES2FormatTest, Uniform3fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3fv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2101,14 +2150,15 @@ TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
+  };
   cmds::Uniform3fvImmediate& cmd = *GetBufferAs<cmds::Uniform3fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2125,7 +2175,7 @@ TEST_F(GLES2FormatTest, Uniform3i) {
                            static_cast<GLint>(12),
                            static_cast<GLint>(13),
                            static_cast<GLint>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3i::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3i::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
@@ -2139,32 +2189,35 @@ TEST_F(GLES2FormatTest, Uniform3iv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3iv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3iv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 1),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 2),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 3),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 4),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 5), };
+  static GLint data[] = {
+      static_cast<GLint>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 1),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 2),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 3),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 4),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 5),
+  };
   cmds::Uniform3ivImmediate& cmd = *GetBufferAs<cmds::Uniform3ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 3;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform3ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2182,7 +2235,7 @@ TEST_F(GLES2FormatTest, Uniform4f) {
                            static_cast<GLfloat>(13),
                            static_cast<GLfloat>(14),
                            static_cast<GLfloat>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4f::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4f::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
@@ -2197,14 +2250,15 @@ TEST_F(GLES2FormatTest, Uniform4fv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4fv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2218,14 +2272,15 @@ TEST_F(GLES2FormatTest, Uniform4fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
+  };
   cmds::Uniform4fvImmediate& cmd = *GetBufferAs<cmds::Uniform4fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2243,7 +2298,7 @@ TEST_F(GLES2FormatTest, Uniform4i) {
                            static_cast<GLint>(13),
                            static_cast<GLint>(14),
                            static_cast<GLint>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4i::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4i::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
@@ -2258,34 +2313,37 @@ TEST_F(GLES2FormatTest, Uniform4iv) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4iv::kCmdId), cmd.header.command);
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4iv::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.v_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLint data[] = {static_cast<GLint>(kSomeBaseValueToTestWith + 0),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 1),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 2),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 3),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 4),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 5),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 6),
-                         static_cast<GLint>(kSomeBaseValueToTestWith + 7), };
+  static GLint data[] = {
+      static_cast<GLint>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 1),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 2),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 3),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 4),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 5),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 6),
+      static_cast<GLint>(kSomeBaseValueToTestWith + 7),
+  };
   cmds::Uniform4ivImmediate& cmd = *GetBufferAs<cmds::Uniform4ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 4;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLint>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Uniform4ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2301,16 +2359,16 @@ TEST_F(GLES2FormatTest, UniformMatrix2fv) {
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
                            static_cast<GLboolean>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fv::kCmdId),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix2fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2324,7 +2382,8 @@ TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
+  };
   cmds::UniformMatrix2fvImmediate& cmd =
       *GetBufferAs<cmds::UniformMatrix2fvImmediate>();
   const GLsizei kNumElements = 2;
@@ -2335,7 +2394,7 @@ TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
                            static_cast<GLsizei>(2),
                            static_cast<GLboolean>(3),
                            data);
-  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2352,16 +2411,16 @@ TEST_F(GLES2FormatTest, UniformMatrix3fv) {
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
                            static_cast<GLboolean>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fv::kCmdId),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix3fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2385,7 +2444,8 @@ TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 14),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 15),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 17), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 17),
+  };
   cmds::UniformMatrix3fvImmediate& cmd =
       *GetBufferAs<cmds::UniformMatrix3fvImmediate>();
   const GLsizei kNumElements = 2;
@@ -2396,7 +2456,7 @@ TEST_F(GLES2FormatTest, UniformMatrix3fvImmediate) {
                            static_cast<GLsizei>(2),
                            static_cast<GLboolean>(3),
                            data);
-  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2413,16 +2473,16 @@ TEST_F(GLES2FormatTest, UniformMatrix4fv) {
                            static_cast<GLint>(11),
                            static_cast<GLsizei>(12),
                            static_cast<GLboolean>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fv::kCmdId),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix4fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.value_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2460,7 +2520,8 @@ TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 28),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 29),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 30),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 31), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 31),
+  };
   cmds::UniformMatrix4fvImmediate& cmd =
       *GetBufferAs<cmds::UniformMatrix4fvImmediate>();
   const GLsizei kNumElements = 2;
@@ -2471,7 +2532,7 @@ TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
                            static_cast<GLsizei>(2),
                            static_cast<GLboolean>(3),
                            data);
-  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UniformMatrix4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
@@ -2485,7 +2546,8 @@ TEST_F(GLES2FormatTest, UniformMatrix4fvImmediate) {
 TEST_F(GLES2FormatTest, UseProgram) {
   cmds::UseProgram& cmd = *GetBufferAs<cmds::UseProgram>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::UseProgram::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::UseProgram::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -2494,7 +2556,7 @@ TEST_F(GLES2FormatTest, UseProgram) {
 TEST_F(GLES2FormatTest, ValidateProgram) {
   cmds::ValidateProgram& cmd = *GetBufferAs<cmds::ValidateProgram>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::ValidateProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ValidateProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
@@ -2505,7 +2567,7 @@ TEST_F(GLES2FormatTest, VertexAttrib1f) {
   cmds::VertexAttrib1f& cmd = *GetBufferAs<cmds::VertexAttrib1f>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLfloat>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1f::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib1f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
@@ -2517,25 +2579,26 @@ TEST_F(GLES2FormatTest, VertexAttrib1fv) {
   cmds::VertexAttrib1fv& cmd = *GetBufferAs<cmds::VertexAttrib1fv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fv::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib1fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib1fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
+  };
   cmds::VertexAttrib1fvImmediate& cmd =
       *GetBufferAs<cmds::VertexAttrib1fvImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib1fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
@@ -2551,7 +2614,7 @@ TEST_F(GLES2FormatTest, VertexAttrib2f) {
                            static_cast<GLuint>(11),
                            static_cast<GLfloat>(12),
                            static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2f::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib2f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
@@ -2564,14 +2627,14 @@ TEST_F(GLES2FormatTest, VertexAttrib2fv) {
   cmds::VertexAttrib2fv& cmd = *GetBufferAs<cmds::VertexAttrib2fv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fv::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib2fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2579,11 +2642,12 @@ TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
+  };
   cmds::VertexAttrib2fvImmediate& cmd =
       *GetBufferAs<cmds::VertexAttrib2fvImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
@@ -2600,7 +2664,7 @@ TEST_F(GLES2FormatTest, VertexAttrib3f) {
                            static_cast<GLfloat>(12),
                            static_cast<GLfloat>(13),
                            static_cast<GLfloat>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3f::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib3f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
@@ -2614,14 +2678,14 @@ TEST_F(GLES2FormatTest, VertexAttrib3fv) {
   cmds::VertexAttrib3fv& cmd = *GetBufferAs<cmds::VertexAttrib3fv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fv::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib3fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2630,11 +2694,12 @@ TEST_F(GLES2FormatTest, VertexAttrib3fvImmediate) {
   static GLfloat data[] = {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
+  };
   cmds::VertexAttrib3fvImmediate& cmd =
       *GetBufferAs<cmds::VertexAttrib3fvImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
@@ -2652,7 +2717,7 @@ TEST_F(GLES2FormatTest, VertexAttrib4f) {
                            static_cast<GLfloat>(13),
                            static_cast<GLfloat>(14),
                            static_cast<GLfloat>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4f::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib4f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
@@ -2667,14 +2732,14 @@ TEST_F(GLES2FormatTest, VertexAttrib4fv) {
   cmds::VertexAttrib4fv& cmd = *GetBufferAs<cmds::VertexAttrib4fv>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fv::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib4fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.values_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2684,11 +2749,12 @@ TEST_F(GLES2FormatTest, VertexAttrib4fvImmediate) {
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
       static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
-      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3), };
+      static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
+  };
   cmds::VertexAttrib4fvImmediate& cmd =
       *GetBufferAs<cmds::VertexAttrib4fvImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttrib4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
@@ -2707,7 +2773,7 @@ TEST_F(GLES2FormatTest, VertexAttribPointer) {
                            static_cast<GLboolean>(14),
                            static_cast<GLsizei>(15),
                            static_cast<GLuint>(16));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribPointer::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttribPointer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
@@ -2726,7 +2792,7 @@ TEST_F(GLES2FormatTest, Viewport) {
                            static_cast<GLint>(12),
                            static_cast<GLsizei>(13),
                            static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::Viewport::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::Viewport::kCmdId), cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
@@ -2749,7 +2815,7 @@ TEST_F(GLES2FormatTest, BlitFramebufferCHROMIUM) {
                            static_cast<GLint>(18),
                            static_cast<GLbitfield>(19),
                            static_cast<GLenum>(20));
-  EXPECT_EQ(static_cast<uint32>(cmds::BlitFramebufferCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BlitFramebufferCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.srcX0);
@@ -2774,9 +2840,9 @@ TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleCHROMIUM) {
                            static_cast<GLenum>(13),
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15));
-  EXPECT_EQ(
-      static_cast<uint32>(cmds::RenderbufferStorageMultisampleCHROMIUM::kCmdId),
-      cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(
+                cmds::RenderbufferStorageMultisampleCHROMIUM::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
@@ -2796,7 +2862,7 @@ TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15));
   EXPECT_EQ(
-      static_cast<uint32>(cmds::RenderbufferStorageMultisampleEXT::kCmdId),
+      static_cast<uint32_t>(cmds::RenderbufferStorageMultisampleEXT::kCmdId),
       cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -2818,7 +2884,7 @@ TEST_F(GLES2FormatTest, FramebufferTexture2DMultisampleEXT) {
                            static_cast<GLint>(15),
                            static_cast<GLsizei>(16));
   EXPECT_EQ(
-      static_cast<uint32>(cmds::FramebufferTexture2DMultisampleEXT::kCmdId),
+      static_cast<uint32_t>(cmds::FramebufferTexture2DMultisampleEXT::kCmdId),
       cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -2838,7 +2904,7 @@ TEST_F(GLES2FormatTest, TexStorage2DEXT) {
                            static_cast<GLenum>(13),
                            static_cast<GLsizei>(14),
                            static_cast<GLsizei>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexStorage2DEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexStorage2DEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -2853,23 +2919,25 @@ TEST_F(GLES2FormatTest, GenQueriesEXT) {
   cmds::GenQueriesEXT& cmd = *GetBufferAs<cmds::GenQueriesEXT>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXT::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenQueriesEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.queries_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.queries_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenQueriesEXTImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::GenQueriesEXTImmediate& cmd =
       *GetBufferAs<cmds::GenQueriesEXTImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenQueriesEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -2884,23 +2952,25 @@ TEST_F(GLES2FormatTest, DeleteQueriesEXT) {
   cmds::DeleteQueriesEXT& cmd = *GetBufferAs<cmds::DeleteQueriesEXT>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXT::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteQueriesEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.queries_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.queries_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteQueriesEXTImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::DeleteQueriesEXTImmediate& cmd =
       *GetBufferAs<cmds::DeleteQueriesEXTImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteQueriesEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -2916,15 +2986,15 @@ TEST_F(GLES2FormatTest, BeginQueryEXT) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLuint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::BeginQueryEXT::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BeginQueryEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.sync_data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.sync_data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.sync_data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.sync_data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -2932,7 +3002,8 @@ TEST_F(GLES2FormatTest, EndQueryEXT) {
   cmds::EndQueryEXT& cmd = *GetBufferAs<cmds::EndQueryEXT>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::EndQueryEXT::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::EndQueryEXT::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.submit_count);
@@ -2942,7 +3013,7 @@ TEST_F(GLES2FormatTest, EndQueryEXT) {
 TEST_F(GLES2FormatTest, InsertEventMarkerEXT) {
   cmds::InsertEventMarkerEXT& cmd = *GetBufferAs<cmds::InsertEventMarkerEXT>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::InsertEventMarkerEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::InsertEventMarkerEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
@@ -2952,7 +3023,7 @@ TEST_F(GLES2FormatTest, InsertEventMarkerEXT) {
 TEST_F(GLES2FormatTest, PushGroupMarkerEXT) {
   cmds::PushGroupMarkerEXT& cmd = *GetBufferAs<cmds::PushGroupMarkerEXT>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::PushGroupMarkerEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::PushGroupMarkerEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
@@ -2962,7 +3033,7 @@ TEST_F(GLES2FormatTest, PushGroupMarkerEXT) {
 TEST_F(GLES2FormatTest, PopGroupMarkerEXT) {
   cmds::PopGroupMarkerEXT& cmd = *GetBufferAs<cmds::PopGroupMarkerEXT>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::PopGroupMarkerEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::PopGroupMarkerEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -2972,23 +3043,25 @@ TEST_F(GLES2FormatTest, GenVertexArraysOES) {
   cmds::GenVertexArraysOES& cmd = *GetBufferAs<cmds::GenVertexArraysOES>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOES::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenVertexArraysOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.arrays_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.arrays_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenVertexArraysOESImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::GenVertexArraysOESImmediate& cmd =
       *GetBufferAs<cmds::GenVertexArraysOESImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOESImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenVertexArraysOESImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -3004,23 +3077,25 @@ TEST_F(GLES2FormatTest, DeleteVertexArraysOES) {
       *GetBufferAs<cmds::DeleteVertexArraysOES>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOES::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteVertexArraysOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.arrays_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.arrays_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteVertexArraysOESImmediate) {
-  static GLuint ids[] = {12, 23, 34, };
+  static GLuint ids[] = {
+      12, 23, 34,
+  };
   cmds::DeleteVertexArraysOESImmediate& cmd =
       *GetBufferAs<cmds::DeleteVertexArraysOESImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOESImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteVertexArraysOESImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
@@ -3035,21 +3110,21 @@ TEST_F(GLES2FormatTest, IsVertexArrayOES) {
   cmds::IsVertexArrayOES& cmd = *GetBufferAs<cmds::IsVertexArrayOES>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::IsVertexArrayOES::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::IsVertexArrayOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindVertexArrayOES) {
   cmds::BindVertexArrayOES& cmd = *GetBufferAs<cmds::BindVertexArrayOES>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindVertexArrayOES::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindVertexArrayOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
@@ -3059,7 +3134,8 @@ TEST_F(GLES2FormatTest, BindVertexArrayOES) {
 TEST_F(GLES2FormatTest, SwapBuffers) {
   cmds::SwapBuffers& cmd = *GetBufferAs<cmds::SwapBuffers>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::SwapBuffers::kCmdId), cmd.header.command);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::SwapBuffers::kCmdId),
+            cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -3072,17 +3148,17 @@ TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
                            static_cast<GLsizei>(12),
                            static_cast<GLenum>(13),
                            static_cast<GLuint>(14),
-                           static_cast<uint32>(15),
-                           static_cast<uint32>(16));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetMaxValueInBufferCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(15),
+                           static_cast<uint32_t>(16));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetMaxValueInBufferCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer_id);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.offset);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(16), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(16), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3092,16 +3168,16 @@ TEST_F(GLES2FormatTest, GenSharedIdsCHROMIUM) {
                            static_cast<GLuint>(11),
                            static_cast<GLuint>(12),
                            static_cast<GLsizei>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::GenSharedIdsCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GenSharedIdsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.id_offset);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.ids_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.ids_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.ids_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3111,15 +3187,15 @@ TEST_F(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::DeleteSharedIdsCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DeleteSharedIdsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.ids_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.ids_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3129,15 +3205,15 @@ TEST_F(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::RegisterSharedIdsCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::RegisterSharedIdsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.ids_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.ids_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3146,14 +3222,14 @@ TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) {
       *GetBufferAs<cmds::EnableFeatureCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::EnableFeatureCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::EnableFeatureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3163,7 +3239,7 @@ TEST_F(GLES2FormatTest, ResizeCHROMIUM) {
                            static_cast<GLuint>(11),
                            static_cast<GLuint>(12),
                            static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::ResizeCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ResizeCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.width);
@@ -3175,22 +3251,23 @@ TEST_F(GLES2FormatTest, ResizeCHROMIUM) {
 TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
   cmds::GetRequestableExtensionsCHROMIUM& cmd =
       *GetBufferAs<cmds::GetRequestableExtensionsCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd, static_cast<uint32>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetRequestableExtensionsCHROMIUM::kCmdId),
-            cmd.header.command);
+  void* next_cmd = cmd.Set(&cmd, static_cast<uint32_t>(11));
+  EXPECT_EQ(
+      static_cast<uint32_t>(cmds::GetRequestableExtensionsCHROMIUM::kCmdId),
+      cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RequestExtensionCHROMIUM) {
   cmds::RequestExtensionCHROMIUM& cmd =
       *GetBufferAs<cmds::RequestExtensionCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd, static_cast<uint32>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::RequestExtensionCHROMIUM::kCmdId),
+  void* next_cmd = cmd.Set(&cmd, static_cast<uint32_t>(11));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::RequestExtensionCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3198,20 +3275,20 @@ TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
   cmds::GetMultipleIntegervCHROMIUM& cmd =
       *GetBufferAs<cmds::GetMultipleIntegervCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd,
-                           static_cast<uint32>(11),
-                           static_cast<uint32>(12),
+                           static_cast<uint32_t>(11),
+                           static_cast<uint32_t>(12),
                            static_cast<GLuint>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15),
                            static_cast<GLsizeiptr>(16));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetMultipleIntegervCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetMultipleIntegervCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
-  EXPECT_EQ(static_cast<uint32>(11), cmd.pnames_shm_id);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.pnames_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(11), cmd.pnames_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.pnames_shm_offset);
   EXPECT_EQ(static_cast<GLuint>(13), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.results_shm_id);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.results_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.results_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.results_shm_offset);
   EXPECT_EQ(static_cast<GLsizeiptr>(16), cmd.size);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ -3220,12 +3297,12 @@ TEST_F(GLES2FormatTest, GetProgramInfoCHROMIUM) {
   cmds::GetProgramInfoCHROMIUM& cmd =
       *GetBufferAs<cmds::GetProgramInfoCHROMIUM>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoCHROMIUM::kCmdId),
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetProgramInfoCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3233,12 +3310,12 @@ TEST_F(GLES2FormatTest, GetTranslatedShaderSourceANGLE) {
   cmds::GetTranslatedShaderSourceANGLE& cmd =
       *GetBufferAs<cmds::GetTranslatedShaderSourceANGLE>();
   void* next_cmd =
-      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::GetTranslatedShaderSourceANGLE::kCmdId),
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::GetTranslatedShaderSourceANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3250,7 +3327,7 @@ TEST_F(GLES2FormatTest, PostSubBufferCHROMIUM) {
                            static_cast<GLint>(12),
                            static_cast<GLint>(13),
                            static_cast<GLint>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::PostSubBufferCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::PostSubBufferCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
@@ -3269,7 +3346,7 @@ TEST_F(GLES2FormatTest, TexImageIOSurface2DCHROMIUM) {
                            static_cast<GLsizei>(13),
                            static_cast<GLuint>(14),
                            static_cast<GLuint>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::TexImageIOSurface2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TexImageIOSurface2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3289,7 +3366,7 @@ TEST_F(GLES2FormatTest, CopyTextureCHROMIUM) {
                            static_cast<GLint>(14),
                            static_cast<GLint>(15),
                            static_cast<GLenum>(16));
-  EXPECT_EQ(static_cast<uint32>(cmds::CopyTextureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::CopyTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3309,7 +3386,7 @@ TEST_F(GLES2FormatTest, DrawArraysInstancedANGLE) {
                            static_cast<GLint>(12),
                            static_cast<GLsizei>(13),
                            static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::DrawArraysInstancedANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawArraysInstancedANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
@@ -3328,7 +3405,7 @@ TEST_F(GLES2FormatTest, DrawElementsInstancedANGLE) {
                            static_cast<GLenum>(13),
                            static_cast<GLuint>(14),
                            static_cast<GLsizei>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::DrawElementsInstancedANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawElementsInstancedANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
@@ -3344,7 +3421,7 @@ TEST_F(GLES2FormatTest, VertexAttribDivisorANGLE) {
       *GetBufferAs<cmds::VertexAttribDivisorANGLE>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribDivisorANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::VertexAttribDivisorANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
@@ -3358,88 +3435,91 @@ TEST_F(GLES2FormatTest, ProduceTextureCHROMIUM) {
       *GetBufferAs<cmds::ProduceTextureCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ProduceTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.mailbox_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.mailbox_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ProduceTextureCHROMIUMImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLbyte data[] = {static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 63), };
+  static GLbyte data[] = {
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 63),
+  };
   cmds::ProduceTextureCHROMIUMImmediate& cmd =
       *GetBufferAs<cmds::ProduceTextureCHROMIUMImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUMImmediate::kCmdId),
-            cmd.header.command);
+  EXPECT_EQ(
+      static_cast<uint32_t>(cmds::ProduceTextureCHROMIUMImmediate::kCmdId),
+      cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3453,88 +3533,91 @@ TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUM) {
       *GetBufferAs<cmds::ConsumeTextureCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ConsumeTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.mailbox_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.mailbox_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUMImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLbyte data[] = {static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
-                          static_cast<GLbyte>(kSomeBaseValueToTestWith + 63), };
+  static GLbyte data[] = {
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 1),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 2),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 3),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 4),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 5),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 6),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 7),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 8),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 9),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 10),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 11),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 12),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 13),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 14),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 15),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 16),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 17),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 18),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 19),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 20),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 21),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 22),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 23),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 24),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 25),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 26),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 27),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 28),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 29),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 30),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 31),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 32),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 33),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 34),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 35),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 36),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 37),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 38),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 39),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 40),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 41),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 42),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 43),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 44),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 45),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 46),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 47),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 48),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 49),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 50),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 51),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 52),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 53),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 54),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
+      static_cast<GLbyte>(kSomeBaseValueToTestWith + 63),
+  };
   cmds::ConsumeTextureCHROMIUMImmediate& cmd =
       *GetBufferAs<cmds::ConsumeTextureCHROMIUMImmediate>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUMImmediate::kCmdId),
-            cmd.header.command);
+  EXPECT_EQ(
+      static_cast<uint32_t>(cmds::ConsumeTextureCHROMIUMImmediate::kCmdId),
+      cmd.header.command);
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3549,17 +3632,17 @@ TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUM) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLint>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14),
-                           static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindUniformLocationCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14),
+                           static_cast<uint32_t>(15));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindUniformLocationCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
-  EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.name_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.name_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(15), cmd.data_size);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3569,14 +3652,14 @@ TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMBucket) {
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLuint>(11),
                            static_cast<GLint>(12),
-                           static_cast<uint32>(13));
+                           static_cast<uint32_t>(13));
   EXPECT_EQ(
-      static_cast<uint32>(cmds::BindUniformLocationCHROMIUMBucket::kCmdId),
+      static_cast<uint32_t>(cmds::BindUniformLocationCHROMIUMBucket::kCmdId),
       cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.name_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3585,7 +3668,7 @@ TEST_F(GLES2FormatTest, BindTexImage2DCHROMIUM) {
       *GetBufferAs<cmds::BindTexImage2DCHROMIUM>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::BindTexImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::BindTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3598,7 +3681,7 @@ TEST_F(GLES2FormatTest, ReleaseTexImage2DCHROMIUM) {
       *GetBufferAs<cmds::ReleaseTexImage2DCHROMIUM>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseTexImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ReleaseTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3609,7 +3692,7 @@ TEST_F(GLES2FormatTest, ReleaseTexImage2DCHROMIUM) {
 TEST_F(GLES2FormatTest, TraceBeginCHROMIUM) {
   cmds::TraceBeginCHROMIUM& cmd = *GetBufferAs<cmds::TraceBeginCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::TraceBeginCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TraceBeginCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
@@ -3619,7 +3702,7 @@ TEST_F(GLES2FormatTest, TraceBeginCHROMIUM) {
 TEST_F(GLES2FormatTest, TraceEndCHROMIUM) {
   cmds::TraceEndCHROMIUM& cmd = *GetBufferAs<cmds::TraceEndCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::TraceEndCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::TraceEndCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
@@ -3637,9 +3720,12 @@ TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
                            static_cast<GLsizei>(16),
                            static_cast<GLenum>(17),
                            static_cast<GLenum>(18),
-                           static_cast<uint32>(19),
-                           static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexSubImage2DCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(19),
+                           static_cast<uint32_t>(20),
+                           static_cast<uint32_t>(21),
+                           static_cast<uint32_t>(22),
+                           static_cast<uint32_t>(23));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::AsyncTexSubImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3650,8 +3736,11 @@ TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
-  EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.data_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(21), cmd.async_upload_token);
+  EXPECT_EQ(static_cast<uint32_t>(22), cmd.sync_data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(23), cmd.sync_data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3667,9 +3756,12 @@ TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
                            static_cast<GLint>(16),
                            static_cast<GLenum>(17),
                            static_cast<GLenum>(18),
-                           static_cast<uint32>(19),
-                           static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
+                           static_cast<uint32_t>(19),
+                           static_cast<uint32_t>(20),
+                           static_cast<uint32_t>(21),
+                           static_cast<uint32_t>(22),
+                           static_cast<uint32_t>(23));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
@@ -3680,8 +3772,11 @@ TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
-  EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
-  EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(20), cmd.pixels_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(21), cmd.async_upload_token);
+  EXPECT_EQ(static_cast<uint32_t>(22), cmd.sync_data_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(23), cmd.sync_data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ -3689,35 +3784,47 @@ TEST_F(GLES2FormatTest, WaitAsyncTexImage2DCHROMIUM) {
   cmds::WaitAsyncTexImage2DCHROMIUM& cmd =
       *GetBufferAs<cmds::WaitAsyncTexImage2DCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::WaitAsyncTexImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::WaitAsyncTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
+TEST_F(GLES2FormatTest, WaitAllAsyncTexImage2DCHROMIUM) {
+  cmds::WaitAllAsyncTexImage2DCHROMIUM& cmd =
+      *GetBufferAs<cmds::WaitAllAsyncTexImage2DCHROMIUM>();
+  void* next_cmd = cmd.Set(&cmd);
+  EXPECT_EQ(static_cast<uint32_t>(cmds::WaitAllAsyncTexImage2DCHROMIUM::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
+}
+
 TEST_F(GLES2FormatTest, DiscardFramebufferEXT) {
   cmds::DiscardFramebufferEXT& cmd =
       *GetBufferAs<cmds::DiscardFramebufferEXT>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLenum>(11),
                            static_cast<GLsizei>(12),
-                           static_cast<uint32>(13),
-                           static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXT::kCmdId),
+                           static_cast<uint32_t>(13),
+                           static_cast<uint32_t>(14));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DiscardFramebufferEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.attachments_shm_id);
-  EXPECT_EQ(static_cast<uint32>(14), cmd.attachments_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.attachments_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(14), cmd.attachments_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLenum data[] = {static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
-                          static_cast<GLenum>(kSomeBaseValueToTestWith + 1), };
+  static GLenum data[] = {
+      static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
+      static_cast<GLenum>(kSomeBaseValueToTestWith + 1),
+  };
   cmds::DiscardFramebufferEXTImmediate& cmd =
       *GetBufferAs<cmds::DiscardFramebufferEXTImmediate>();
   const GLsizei kNumElements = 2;
@@ -3725,7 +3832,7 @@ TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
       sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(1), static_cast<GLsizei>(2), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DiscardFramebufferEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(1), cmd.target);
@@ -3739,7 +3846,7 @@ TEST_F(GLES2FormatTest, LoseContextCHROMIUM) {
   cmds::LoseContextCHROMIUM& cmd = *GetBufferAs<cmds::LoseContextCHROMIUM>();
   void* next_cmd =
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(cmds::LoseContextCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::LoseContextCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.current);
@@ -3752,7 +3859,7 @@ TEST_F(GLES2FormatTest, WaitSyncPointCHROMIUM) {
   cmds::WaitSyncPointCHROMIUM& cmd =
       *GetBufferAs<cmds::WaitSyncPointCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(cmds::WaitSyncPointCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::WaitSyncPointCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.sync_point);
@@ -3763,27 +3870,29 @@ TEST_F(GLES2FormatTest, DrawBuffersEXT) {
   cmds::DrawBuffersEXT& cmd = *GetBufferAs<cmds::DrawBuffersEXT>();
   void* next_cmd = cmd.Set(&cmd,
                            static_cast<GLsizei>(11),
-                           static_cast<uint32>(12),
-                           static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(cmds::DrawBuffersEXT::kCmdId),
+                           static_cast<uint32_t>(12),
+                           static_cast<uint32_t>(13));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawBuffersEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.count);
-  EXPECT_EQ(static_cast<uint32>(12), cmd.bufs_shm_id);
-  EXPECT_EQ(static_cast<uint32>(13), cmd.bufs_shm_offset);
+  EXPECT_EQ(static_cast<uint32_t>(12), cmd.bufs_shm_id);
+  EXPECT_EQ(static_cast<uint32_t>(13), cmd.bufs_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawBuffersEXTImmediate) {
   const int kSomeBaseValueToTestWith = 51;
-  static GLenum data[] = {static_cast<GLenum>(kSomeBaseValueToTestWith + 0), };
+  static GLenum data[] = {
+      static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
+  };
   cmds::DrawBuffersEXTImmediate& cmd =
       *GetBufferAs<cmds::DrawBuffersEXTImmediate>();
   const GLsizei kNumElements = 1;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
   void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(1), data);
-  EXPECT_EQ(static_cast<uint32>(cmds::DrawBuffersEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DrawBuffersEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(1), cmd.count);
@@ -3796,10 +3905,42 @@ TEST_F(GLES2FormatTest, DiscardBackbufferCHROMIUM) {
   cmds::DiscardBackbufferCHROMIUM& cmd =
       *GetBufferAs<cmds::DiscardBackbufferCHROMIUM>();
   void* next_cmd = cmd.Set(&cmd);
-  EXPECT_EQ(static_cast<uint32>(cmds::DiscardBackbufferCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32_t>(cmds::DiscardBackbufferCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
+TEST_F(GLES2FormatTest, ScheduleOverlayPlaneCHROMIUM) {
+  cmds::ScheduleOverlayPlaneCHROMIUM& cmd =
+      *GetBufferAs<cmds::ScheduleOverlayPlaneCHROMIUM>();
+  void* next_cmd = cmd.Set(&cmd,
+                           static_cast<GLint>(11),
+                           static_cast<GLenum>(12),
+                           static_cast<GLuint>(13),
+                           static_cast<GLint>(14),
+                           static_cast<GLint>(15),
+                           static_cast<GLint>(16),
+                           static_cast<GLint>(17),
+                           static_cast<GLfloat>(18),
+                           static_cast<GLfloat>(19),
+                           static_cast<GLfloat>(20),
+                           static_cast<GLfloat>(21));
+  EXPECT_EQ(static_cast<uint32_t>(cmds::ScheduleOverlayPlaneCHROMIUM::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLint>(11), cmd.plane_z_order);
+  EXPECT_EQ(static_cast<GLenum>(12), cmd.plane_transform);
+  EXPECT_EQ(static_cast<GLuint>(13), cmd.overlay_texture_id);
+  EXPECT_EQ(static_cast<GLint>(14), cmd.bounds_x);
+  EXPECT_EQ(static_cast<GLint>(15), cmd.bounds_y);
+  EXPECT_EQ(static_cast<GLint>(16), cmd.bounds_width);
+  EXPECT_EQ(static_cast<GLint>(17), cmd.bounds_height);
+  EXPECT_EQ(static_cast<GLfloat>(18), cmd.uv_x);
+  EXPECT_EQ(static_cast<GLfloat>(19), cmd.uv_y);
+  EXPECT_EQ(static_cast<GLfloat>(20), cmd.uv_width);
+  EXPECT_EQ(static_cast<GLfloat>(21), cmd.uv_height);
+  CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
+}
+
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_