Update from https://crrev.com/303153

gpu/command_buffer/common/gles2_cmd_format_test_autogen.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 21 matching lines @@
             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.shader);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindAttribLocationBucket) {
   cmds::BindAttribLocationBucket& cmd =
       *GetBufferAs<cmds::BindAttribLocationBucket>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLuint>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11),
+                           static_cast<GLuint>(12), 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_t>(13), cmd.name_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindBuffer) {
@@ skipping 39 matching lines @@
   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);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendColor) {
   cmds::BlendColor& cmd = *GetBufferAs<cmds::BlendColor>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLclampf>(11),
-                           static_cast<GLclampf>(12),
-                           static_cast<GLclampf>(13),
-                           static_cast<GLclampf>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLclampf>(11), static_cast<GLclampf>(12),
+              static_cast<GLclampf>(13), static_cast<GLclampf>(14));
   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);
   EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
   EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 26 matching lines @@
       cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12));
   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);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendFuncSeparate) {
   cmds::BlendFuncSeparate& cmd = *GetBufferAs<cmds::BlendFuncSeparate>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLenum>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLenum>(13), static_cast<GLenum>(14));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.dstRGB);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.srcAlpha);
   EXPECT_EQ(static_cast<GLenum>(14), cmd.dstAlpha);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BufferData) {
   cmds::BufferData& cmd = *GetBufferAs<cmds::BufferData>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizeiptr>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<GLenum>(15));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLsizeiptr>(12),
+              static_cast<uint32_t>(13), static_cast<uint32_t>(14),
+              static_cast<GLenum>(15));
   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_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));
 }
 
 TEST_F(GLES2FormatTest, BufferSubData) {
   cmds::BufferSubData& cmd = *GetBufferAs<cmds::BufferSubData>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLintptr>(12),
-                           static_cast<GLsizeiptr>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLintptr>(12),
+              static_cast<GLsizeiptr>(13), 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_t>(14), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(15), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CheckFramebufferStatus) {
   cmds::CheckFramebufferStatus& cmd =
       *GetBufferAs<cmds::CheckFramebufferStatus>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), 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_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_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));
 }
 
 TEST_F(GLES2FormatTest, ClearColor) {
   cmds::ClearColor& cmd = *GetBufferAs<cmds::ClearColor>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLclampf>(11),
-                           static_cast<GLclampf>(12),
-                           static_cast<GLclampf>(13),
-                           static_cast<GLclampf>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLclampf>(11), static_cast<GLclampf>(12),
+              static_cast<GLclampf>(13), static_cast<GLclampf>(14));
   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);
   EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
   EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 12 matching lines @@
   void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11));
   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);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ColorMask) {
   cmds::ColorMask& cmd = *GetBufferAs<cmds::ColorMask>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLboolean>(11),
-                           static_cast<GLboolean>(12),
-                           static_cast<GLboolean>(13),
-                           static_cast<GLboolean>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLboolean>(11), static_cast<GLboolean>(12),
+              static_cast<GLboolean>(13), static_cast<GLboolean>(14));
   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);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.blue);
   EXPECT_EQ(static_cast<GLboolean>(14), cmd.alpha);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 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_t>(cmds::CompileShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
   cmds::CompressedTexImage2DBucket& cmd =
       *GetBufferAs<cmds::CompressedTexImage2DBucket>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLuint>(16));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLenum>(13), static_cast<GLsizei>(14),
+              static_cast<GLsizei>(15), static_cast<GLuint>(16));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLuint>(16), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompressedTexImage2D) {
   cmds::CompressedTexImage2D& cmd = *GetBufferAs<cmds::CompressedTexImage2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLsizei>(16),
-                           static_cast<uint32_t>(17),
-                           static_cast<uint32_t>(18));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLenum>(13), static_cast<GLsizei>(14),
+              static_cast<GLsizei>(15), static_cast<GLsizei>(16),
+              static_cast<uint32_t>(17), static_cast<uint32_t>(18));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.imageSize);
   EXPECT_EQ(static_cast<uint32_t>(17), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(18), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompressedTexSubImage2DBucket) {
   cmds::CompressedTexSubImage2DBucket& cmd =
       *GetBufferAs<cmds::CompressedTexSubImage2DBucket>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLsizei>(16),
-                           static_cast<GLenum>(17),
-                           static_cast<GLuint>(18));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLint>(13), static_cast<GLint>(14),
+              static_cast<GLsizei>(15), static_cast<GLsizei>(16),
+              static_cast<GLenum>(17), static_cast<GLuint>(18));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLuint>(18), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompressedTexSubImage2D) {
   cmds::CompressedTexSubImage2D& cmd =
       *GetBufferAs<cmds::CompressedTexSubImage2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLsizei>(16),
-                           static_cast<GLenum>(17),
-                           static_cast<GLsizei>(18),
-                           static_cast<uint32_t>(19),
-                           static_cast<uint32_t>(20));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLint>(13), static_cast<GLint>(14),
+              static_cast<GLsizei>(15), static_cast<GLsizei>(16),
+              static_cast<GLenum>(17), static_cast<GLsizei>(18),
+              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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   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_t>(19), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(20), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CopyTexImage2D) {
   cmds::CopyTexImage2D& cmd = *GetBufferAs<cmds::CopyTexImage2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLint>(15),
-                           static_cast<GLsizei>(16),
-                           static_cast<GLsizei>(17));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLint>(12), static_cast<GLenum>(13),
+                           static_cast<GLint>(14), static_cast<GLint>(15),
+                           static_cast<GLsizei>(16), static_cast<GLsizei>(17));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLint>(14), cmd.x);
   EXPECT_EQ(static_cast<GLint>(15), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CopyTexSubImage2D) {
   cmds::CopyTexSubImage2D& cmd = *GetBufferAs<cmds::CopyTexSubImage2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLint>(15),
-                           static_cast<GLint>(16),
-                           static_cast<GLsizei>(17),
-                           static_cast<GLsizei>(18));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLint>(13), static_cast<GLint>(14),
+              static_cast<GLint>(15), static_cast<GLint>(16),
+              static_cast<GLsizei>(17), static_cast<GLsizei>(18));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLint>(15), cmd.x);
   EXPECT_EQ(static_cast<GLint>(16), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.width);
@@ skipping 181 matching lines @@
   void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11));
   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);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawArrays) {
   cmds::DrawArrays& cmd = *GetBufferAs<cmds::DrawArrays>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLsizei>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLint>(12), static_cast<GLsizei>(13));
   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);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawElements) {
   cmds::DrawElements& cmd = *GetBufferAs<cmds::DrawElements>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLuint>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLsizei>(12),
+              static_cast<GLenum>(13), static_cast<GLuint>(14));
   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);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 29 matching lines @@
   cmds::Flush& cmd = *GetBufferAs<cmds::Flush>();
   void* next_cmd = cmd.Set(&cmd);
   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));
 }
 
 TEST_F(GLES2FormatTest, FramebufferRenderbuffer) {
   cmds::FramebufferRenderbuffer& cmd =
       *GetBufferAs<cmds::FramebufferRenderbuffer>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLuint>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLenum>(13), static_cast<GLuint>(14));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.renderbuffertarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.renderbuffer);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, FramebufferTexture2D) {
   cmds::FramebufferTexture2D& cmd = *GetBufferAs<cmds::FramebufferTexture2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLuint>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLenum>(13), static_cast<GLuint>(14));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 81 matching lines @@
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd,
       sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, GetActiveAttrib) {
   cmds::GetActiveAttrib& cmd = *GetBufferAs<cmds::GetActiveAttrib>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLuint>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12),
+              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_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));
 }
 
 TEST_F(GLES2FormatTest, GetActiveUniform) {
   cmds::GetActiveUniform& cmd = *GetBufferAs<cmds::GetActiveUniform>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLuint>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLuint>(12),
+              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_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));
 }
 
 TEST_F(GLES2FormatTest, GetAttachedShaders) {
   cmds::GetAttachedShaders& cmd = *GetBufferAs<cmds::GetAttachedShaders>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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));
 }
 
 TEST_F(GLES2FormatTest, GetAttribLocation) {
   cmds::GetAttribLocation& cmd = *GetBufferAs<cmds::GetAttribLocation>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12),
+              static_cast<uint32_t>(13), static_cast<uint32_t>(14));
   EXPECT_EQ(static_cast<uint32_t>(cmds::GetAttribLocation::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_t>(12), cmd.name_bucket_id);
   EXPECT_EQ(static_cast<uint32_t>(13), cmd.location_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(14), cmd.location_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetBooleanv) {
   cmds::GetBooleanv& cmd = *GetBufferAs<cmds::GetBooleanv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), 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_t>(12), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetBufferParameteriv) {
   cmds::GetBufferParameteriv& cmd = *GetBufferAs<cmds::GetBufferParameteriv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              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_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_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_t>(11), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(12), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetFloatv) {
   cmds::GetFloatv& cmd = *GetBufferAs<cmds::GetFloatv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), 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_t>(12), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
   cmds::GetFramebufferAttachmentParameteriv& cmd =
       *GetBufferAs<cmds::GetFramebufferAttachmentParameteriv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLenum>(13), static_cast<uint32_t>(14),
+              static_cast<uint32_t>(15));
   EXPECT_EQ(
       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_t>(14), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(15), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetIntegerv) {
   cmds::GetIntegerv& cmd = *GetBufferAs<cmds::GetIntegerv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), 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_t>(12), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetProgramiv) {
   cmds::GetProgramiv& cmd = *GetBufferAs<cmds::GetProgramiv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLenum>(12),
+              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_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_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_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetRenderbufferParameteriv) {
   cmds::GetRenderbufferParameteriv& cmd =
       *GetBufferAs<cmds::GetRenderbufferParameteriv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              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_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, GetShaderiv) {
   cmds::GetShaderiv& cmd = *GetBufferAs<cmds::GetShaderiv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLenum>(12),
+              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_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_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_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderPrecisionFormat) {
   cmds::GetShaderPrecisionFormat& cmd =
       *GetBufferAs<cmds::GetShaderPrecisionFormat>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              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_t>(13), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(14), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 15 matching lines @@
       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_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetTexParameterfv) {
   cmds::GetTexParameterfv& cmd = *GetBufferAs<cmds::GetTexParameterfv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              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_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, GetTexParameteriv) {
   cmds::GetTexParameteriv& cmd = *GetBufferAs<cmds::GetTexParameteriv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              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_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, GetUniformfv) {
   cmds::GetUniformfv& cmd = *GetBufferAs<cmds::GetUniformfv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLint>(12),
+              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_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, GetUniformiv) {
   cmds::GetUniformiv& cmd = *GetBufferAs<cmds::GetUniformiv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLint>(12),
+              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_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, GetUniformLocation) {
   cmds::GetUniformLocation& cmd = *GetBufferAs<cmds::GetUniformLocation>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<uint32_t>(12),
+              static_cast<uint32_t>(13), static_cast<uint32_t>(14));
   EXPECT_EQ(static_cast<uint32_t>(cmds::GetUniformLocation::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_t>(12), cmd.name_bucket_id);
   EXPECT_EQ(static_cast<uint32_t>(13), cmd.location_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(14), cmd.location_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetVertexAttribfv) {
   cmds::GetVertexAttribfv& cmd = *GetBufferAs<cmds::GetVertexAttribfv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLenum>(12),
+              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_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, GetVertexAttribiv) {
   cmds::GetVertexAttribiv& cmd = *GetBufferAs<cmds::GetVertexAttribiv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLenum>(12),
+              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_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, GetVertexAttribPointerv) {
   cmds::GetVertexAttribPointerv& cmd =
       *GetBufferAs<cmds::GetVertexAttribPointerv>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLenum>(12),
+              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_t>(13), cmd.pointer_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(14), cmd.pointer_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 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_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);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsBuffer) {
   cmds::IsBuffer& cmd = *GetBufferAs<cmds::IsBuffer>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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, IsEnabled) {
   cmds::IsEnabled& cmd = *GetBufferAs<cmds::IsEnabled>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), 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_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, IsFramebuffer) {
   cmds::IsFramebuffer& cmd = *GetBufferAs<cmds::IsFramebuffer>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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, IsProgram) {
   cmds::IsProgram& cmd = *GetBufferAs<cmds::IsProgram>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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, IsRenderbuffer) {
   cmds::IsRenderbuffer& cmd = *GetBufferAs<cmds::IsRenderbuffer>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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, IsShader) {
   cmds::IsShader& cmd = *GetBufferAs<cmds::IsShader>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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, IsTexture) {
   cmds::IsTexture& cmd = *GetBufferAs<cmds::IsTexture>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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>();
@@ skipping 33 matching lines @@
   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);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.units);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ReadPixels) {
   cmds::ReadPixels& cmd = *GetBufferAs<cmds::ReadPixels>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLsizei>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLenum>(15),
-                           static_cast<GLenum>(16),
-                           static_cast<uint32_t>(17),
-                           static_cast<uint32_t>(18),
-                           static_cast<uint32_t>(19),
-                           static_cast<uint32_t>(20),
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+                           static_cast<GLsizei>(13), static_cast<GLsizei>(14),
+                           static_cast<GLenum>(15), static_cast<GLenum>(16),
+                           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_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);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(15), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(16), cmd.type);
@@ skipping 10 matching lines @@
       *GetBufferAs<cmds::ReleaseShaderCompiler>();
   void* next_cmd = cmd.Set(&cmd);
   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));
 }
 
 TEST_F(GLES2FormatTest, RenderbufferStorage) {
   cmds::RenderbufferStorage& cmd = *GetBufferAs<cmds::RenderbufferStorage>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLsizei>(13),
-                           static_cast<GLsizei>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLsizei>(13), static_cast<GLsizei>(14));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 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_t>(cmds::SampleCoverage::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
   EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Scissor) {
   cmds::Scissor& cmd = *GetBufferAs<cmds::Scissor>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLsizei>(13),
-                           static_cast<GLsizei>(14));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+                           static_cast<GLsizei>(13), static_cast<GLsizei>(14));
   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);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ShaderBinary) {
   cmds::ShaderBinary& cmd = *GetBufferAs<cmds::ShaderBinary>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLsizei>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<GLenum>(14),
-                           static_cast<uint32_t>(15),
-                           static_cast<uint32_t>(16),
-                           static_cast<GLsizei>(17));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLsizei>(11),
+                           static_cast<uint32_t>(12), static_cast<uint32_t>(13),
+                           static_cast<GLenum>(14), static_cast<uint32_t>(15),
+                           static_cast<uint32_t>(16), static_cast<GLsizei>(17));
   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_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_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));
 }
 
 TEST_F(GLES2FormatTest, ShaderSourceBucket) {
   cmds::ShaderSourceBucket& cmd = *GetBufferAs<cmds::ShaderSourceBucket>();
   void* next_cmd =
       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_t>(12), cmd.data_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilFunc) {
   cmds::StencilFunc& cmd = *GetBufferAs<cmds::StencilFunc>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLuint>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLint>(12), static_cast<GLuint>(13));
   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);
   EXPECT_EQ(static_cast<GLuint>(13), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilFuncSeparate) {
   cmds::StencilFuncSeparate& cmd = *GetBufferAs<cmds::StencilFuncSeparate>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLuint>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLint>(13), static_cast<GLuint>(14));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.func);
   EXPECT_EQ(static_cast<GLint>(13), cmd.ref);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 14 matching lines @@
   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);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilOp) {
   cmds::StencilOp& cmd = *GetBufferAs<cmds::StencilOp>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLenum>(12), static_cast<GLenum>(13));
   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);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilOpSeparate) {
   cmds::StencilOpSeparate& cmd = *GetBufferAs<cmds::StencilOpSeparate>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLenum>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLenum>(13), static_cast<GLenum>(14));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.fail);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail);
   EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexImage2D) {
   cmds::TexImage2D& cmd = *GetBufferAs<cmds::TexImage2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLenum>(16),
-                           static_cast<GLenum>(17),
-                           static_cast<uint32_t>(18),
-                           static_cast<uint32_t>(19));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLint>(13), static_cast<GLsizei>(14),
+              static_cast<GLsizei>(15), static_cast<GLenum>(16),
+              static_cast<GLenum>(17), static_cast<uint32_t>(18),
+              static_cast<uint32_t>(19));
   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);
   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(16), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.type);
   EXPECT_EQ(static_cast<uint32_t>(18), cmd.pixels_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(19), cmd.pixels_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterf) {
   cmds::TexParameterf& cmd = *GetBufferAs<cmds::TexParameterf>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLfloat>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLenum>(12), static_cast<GLfloat>(13));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.param);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
@@ skipping 11 matching lines @@
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, TexParameteri) {
   cmds::TexParameteri& cmd = *GetBufferAs<cmds::TexParameteri>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLint>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLenum>(12), static_cast<GLint>(13));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<GLint>(13), cmd.param);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterivImmediate) {
@@ skipping 11 matching lines @@
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, TexSubImage2D) {
   cmds::TexSubImage2D& cmd = *GetBufferAs<cmds::TexSubImage2D>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLsizei>(16),
-                           static_cast<GLenum>(17),
-                           static_cast<GLenum>(18),
-                           static_cast<uint32_t>(19),
-                           static_cast<uint32_t>(20),
-                           static_cast<GLboolean>(21));
+  void* next_cmd = cmd.Set(
+      &cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+      static_cast<GLint>(13), static_cast<GLint>(14), static_cast<GLsizei>(15),
+      static_cast<GLsizei>(16), static_cast<GLenum>(17),
+      static_cast<GLenum>(18), static_cast<uint32_t>(19),
+      static_cast<uint32_t>(20), static_cast<GLboolean>(21));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
@@ skipping 65 matching lines @@
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform2f) {
   cmds::Uniform2f& cmd = *GetBufferAs<cmds::Uniform2f>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLfloat>(12),
-                           static_cast<GLfloat>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11),
+                           static_cast<GLfloat>(12), static_cast<GLfloat>(13));
   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);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
@@ skipping 14 matching lines @@
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform2i) {
   cmds::Uniform2i& cmd = *GetBufferAs<cmds::Uniform2i>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
                            static_cast<GLint>(13));
   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);
   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
@@ skipping 15 matching lines @@
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform3f) {
   cmds::Uniform3f& cmd = *GetBufferAs<cmds::Uniform3f>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLfloat>(12),
-                           static_cast<GLfloat>(13),
-                           static_cast<GLfloat>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLfloat>(12),
+              static_cast<GLfloat>(13), static_cast<GLfloat>(14));
   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);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
@@ skipping 17 matching lines @@
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform3i) {
   cmds::Uniform3i& cmd = *GetBufferAs<cmds::Uniform3i>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+                           static_cast<GLint>(13), static_cast<GLint>(14));
   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);
   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
   EXPECT_EQ(static_cast<GLint>(14), cmd.z);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
@@ skipping 17 matching lines @@
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform4f) {
   cmds::Uniform4f& cmd = *GetBufferAs<cmds::Uniform4f>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLfloat>(12),
-                           static_cast<GLfloat>(13),
-                           static_cast<GLfloat>(14),
-                           static_cast<GLfloat>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11),
+                           static_cast<GLfloat>(12), static_cast<GLfloat>(13),
+                           static_cast<GLfloat>(14), static_cast<GLfloat>(15));
   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);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 20 matching lines @@
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform4i) {
   cmds::Uniform4i& cmd = *GetBufferAs<cmds::Uniform4i>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+                           static_cast<GLint>(13), static_cast<GLint>(14),
                            static_cast<GLint>(15));
   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);
   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
   EXPECT_EQ(static_cast<GLint>(14), cmd.z);
   EXPECT_EQ(static_cast<GLint>(15), cmd.w);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ skipping 192 matching lines @@
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib2f) {
   cmds::VertexAttrib2f& cmd = *GetBufferAs<cmds::VertexAttrib2f>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLfloat>(12),
-                           static_cast<GLfloat>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11),
+                           static_cast<GLfloat>(12), static_cast<GLfloat>(13));
   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);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
@@ skipping 10 matching lines @@
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib3f) {
   cmds::VertexAttrib3f& cmd = *GetBufferAs<cmds::VertexAttrib3f>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLfloat>(12),
-                           static_cast<GLfloat>(13),
-                           static_cast<GLfloat>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLfloat>(12),
+              static_cast<GLfloat>(13), static_cast<GLfloat>(14));
   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);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib4f) {
   cmds::VertexAttrib4f& cmd = *GetBufferAs<cmds::VertexAttrib4f>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLfloat>(12),
-                           static_cast<GLfloat>(13),
-                           static_cast<GLfloat>(14),
-                           static_cast<GLfloat>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11),
+                           static_cast<GLfloat>(12), static_cast<GLfloat>(13),
+                           static_cast<GLfloat>(14), static_cast<GLfloat>(15));
   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);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ skipping 14 matching lines @@
   EXPECT_EQ(sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttribPointer) {
   cmds::VertexAttribPointer& cmd = *GetBufferAs<cmds::VertexAttribPointer>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLboolean>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLuint>(16));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLint>(12),
+              static_cast<GLenum>(13), static_cast<GLboolean>(14),
+              static_cast<GLsizei>(15), static_cast<GLuint>(16));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.size);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride);
   EXPECT_EQ(static_cast<GLuint>(16), cmd.offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Viewport) {
   cmds::Viewport& cmd = *GetBufferAs<cmds::Viewport>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLsizei>(13),
-                           static_cast<GLsizei>(14));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+                           static_cast<GLsizei>(13), static_cast<GLsizei>(14));
   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);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlitFramebufferCHROMIUM) {
   cmds::BlitFramebufferCHROMIUM& cmd =
       *GetBufferAs<cmds::BlitFramebufferCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLint>(15),
-                           static_cast<GLint>(16),
-                           static_cast<GLint>(17),
-                           static_cast<GLint>(18),
-                           static_cast<GLbitfield>(19),
-                           static_cast<GLenum>(20));
+  void* next_cmd = cmd.Set(
+      &cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+      static_cast<GLint>(13), static_cast<GLint>(14), static_cast<GLint>(15),
+      static_cast<GLint>(16), static_cast<GLint>(17), static_cast<GLint>(18),
+      static_cast<GLbitfield>(19), static_cast<GLenum>(20));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.srcY0);
   EXPECT_EQ(static_cast<GLint>(13), cmd.srcX1);
   EXPECT_EQ(static_cast<GLint>(14), cmd.srcY1);
   EXPECT_EQ(static_cast<GLint>(15), cmd.dstX0);
   EXPECT_EQ(static_cast<GLint>(16), cmd.dstY0);
   EXPECT_EQ(static_cast<GLint>(17), cmd.dstX1);
   EXPECT_EQ(static_cast<GLint>(18), cmd.dstY1);
   EXPECT_EQ(static_cast<GLbitfield>(19), cmd.mask);
   EXPECT_EQ(static_cast<GLenum>(20), cmd.filter);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleCHROMIUM) {
   cmds::RenderbufferStorageMultisampleCHROMIUM& cmd =
       *GetBufferAs<cmds::RenderbufferStorageMultisampleCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLsizei>(12), static_cast<GLenum>(13),
+                           static_cast<GLsizei>(14), static_cast<GLsizei>(15));
   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);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
   cmds::RenderbufferStorageMultisampleEXT& cmd =
       *GetBufferAs<cmds::RenderbufferStorageMultisampleEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLsizei>(12), static_cast<GLenum>(13),
+                           static_cast<GLsizei>(14), static_cast<GLsizei>(15));
   EXPECT_EQ(
       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);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, FramebufferTexture2DMultisampleEXT) {
   cmds::FramebufferTexture2DMultisampleEXT& cmd =
       *GetBufferAs<cmds::FramebufferTexture2DMultisampleEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLuint>(14),
-                           static_cast<GLsizei>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLenum>(12), static_cast<GLenum>(13),
+                           static_cast<GLuint>(14), static_cast<GLsizei>(15));
   EXPECT_EQ(
       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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.samples);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexStorage2DEXT) {
   cmds::TexStorage2DEXT& cmd = *GetBufferAs<cmds::TexStorage2DEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLsizei>(12), static_cast<GLenum>(13),
+                           static_cast<GLsizei>(14), static_cast<GLsizei>(15));
   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);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.levels);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalFormat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ skipping 29 matching lines @@
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd,
       sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, BeginQueryEXT) {
   cmds::BeginQueryEXT& cmd = *GetBufferAs<cmds::BeginQueryEXT>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLuint>(12),
-                           static_cast<uint32_t>(13),
-                           static_cast<uint32_t>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLuint>(12),
+              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_t>(13), cmd.sync_data_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(14), cmd.sync_data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 69 matching lines @@
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd,
       sizeof(cmd) + RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, IsVertexArrayOES) {
   cmds::IsVertexArrayOES& cmd = *GetBufferAs<cmds::IsVertexArrayOES>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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) {
@@ skipping 11 matching lines @@
   void* next_cmd = cmd.Set(&cmd);
   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));
 }
 
 TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
   cmds::GetMaxValueInBufferCHROMIUM& cmd =
       *GetBufferAs<cmds::GetMaxValueInBufferCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLuint>(14),
-                           static_cast<uint32_t>(15),
-                           static_cast<uint32_t>(16));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), static_cast<GLsizei>(12),
+              static_cast<GLenum>(13), static_cast<GLuint>(14),
+              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_t>(15), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32_t>(16), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) {
   cmds::EnableFeatureCHROMIUM& cmd =
       *GetBufferAs<cmds::EnableFeatureCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLuint>(11), 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_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, ResizeCHROMIUM) {
   cmds::ResizeCHROMIUM& cmd = *GetBufferAs<cmds::ResizeCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLuint>(12),
-                           static_cast<GLfloat>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11),
+                           static_cast<GLuint>(12), static_cast<GLfloat>(13));
   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);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.height);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.scale_factor);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
@@ skipping 15 matching lines @@
   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_t>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
   cmds::GetMultipleIntegervCHROMIUM& cmd =
       *GetBufferAs<cmds::GetMultipleIntegervCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<uint32_t>(11),
-                           static_cast<uint32_t>(12),
-                           static_cast<GLuint>(13),
-                           static_cast<uint32_t>(14),
-                           static_cast<uint32_t>(15),
-                           static_cast<GLsizeiptr>(16));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<uint32_t>(11), static_cast<uint32_t>(12),
+              static_cast<GLuint>(13), static_cast<uint32_t>(14),
+              static_cast<uint32_t>(15), static_cast<GLsizeiptr>(16));
   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_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_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));
@@ skipping 21 matching lines @@
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32_t>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, PostSubBufferCHROMIUM) {
   cmds::PostSubBufferCHROMIUM& cmd =
       *GetBufferAs<cmds::PostSubBufferCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLint>(11), static_cast<GLint>(12),
+                           static_cast<GLint>(13), static_cast<GLint>(14));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
   EXPECT_EQ(static_cast<GLint>(13), cmd.width);
   EXPECT_EQ(static_cast<GLint>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexImageIOSurface2DCHROMIUM) {
   cmds::TexImageIOSurface2DCHROMIUM& cmd =
       *GetBufferAs<cmds::TexImageIOSurface2DCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLsizei>(13),
-                           static_cast<GLuint>(14),
-                           static_cast<GLuint>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLsizei>(12), static_cast<GLsizei>(13),
+                           static_cast<GLuint>(14), static_cast<GLuint>(15));
   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);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.height);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.ioSurfaceId);
   EXPECT_EQ(static_cast<GLuint>(15), cmd.plane);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CopyTextureCHROMIUM) {
   cmds::CopyTextureCHROMIUM& cmd = *GetBufferAs<cmds::CopyTextureCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLenum>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLint>(15),
-                           static_cast<GLenum>(16));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLenum>(12),
+              static_cast<GLenum>(13), static_cast<GLint>(14),
+              static_cast<GLint>(15), static_cast<GLenum>(16));
   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);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.source_id);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.dest_id);
   EXPECT_EQ(static_cast<GLint>(14), cmd.level);
   EXPECT_EQ(static_cast<GLint>(15), cmd.internalformat);
   EXPECT_EQ(static_cast<GLenum>(16), cmd.dest_type);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawArraysInstancedANGLE) {
   cmds::DrawArraysInstancedANGLE& cmd =
       *GetBufferAs<cmds::DrawArraysInstancedANGLE>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLsizei>(13),
-                           static_cast<GLsizei>(14));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLsizei>(13), static_cast<GLsizei>(14));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.first);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.primcount);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawElementsInstancedANGLE) {
   cmds::DrawElementsInstancedANGLE& cmd =
       *GetBufferAs<cmds::DrawElementsInstancedANGLE>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLsizei>(12),
-                           static_cast<GLenum>(13),
-                           static_cast<GLuint>(14),
-                           static_cast<GLsizei>(15));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLenum>(11),
+                           static_cast<GLsizei>(12), static_cast<GLenum>(13),
+                           static_cast<GLuint>(14), static_cast<GLsizei>(15));
   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);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.primcount);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
@@ skipping 257 matching lines @@
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) + RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 // TODO(gman): Write test for CreateAndConsumeTextureCHROMIUMImmediate
 TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMBucket) {
   cmds::BindUniformLocationCHROMIUMBucket& cmd =
       *GetBufferAs<cmds::BindUniformLocationCHROMIUMBucket>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLuint>(11),
-                           static_cast<GLint>(12),
-                           static_cast<uint32_t>(13));
+  void* next_cmd = cmd.Set(&cmd, static_cast<GLuint>(11),
+                           static_cast<GLint>(12), static_cast<uint32_t>(13));
   EXPECT_EQ(
       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_t>(13), cmd.name_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
@@ skipping 38 matching lines @@
   void* next_cmd = cmd.Set(&cmd);
   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));
 }
 
 TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
   cmds::AsyncTexSubImage2DCHROMIUM& cmd =
       *GetBufferAs<cmds::AsyncTexSubImage2DCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLint>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLsizei>(16),
-                           static_cast<GLenum>(17),
-                           static_cast<GLenum>(18),
-                           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));
+  void* next_cmd = cmd.Set(
+      &cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+      static_cast<GLint>(13), static_cast<GLint>(14), static_cast<GLsizei>(15),
+      static_cast<GLsizei>(16), static_cast<GLenum>(17),
+      static_cast<GLenum>(18), 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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   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_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));
 }
 
 TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
   cmds::AsyncTexImage2DCHROMIUM& cmd =
       *GetBufferAs<cmds::AsyncTexImage2DCHROMIUM>();
-  void* next_cmd = cmd.Set(&cmd,
-                           static_cast<GLenum>(11),
-                           static_cast<GLint>(12),
-                           static_cast<GLint>(13),
-                           static_cast<GLsizei>(14),
-                           static_cast<GLsizei>(15),
-                           static_cast<GLenum>(16),
-                           static_cast<GLenum>(17),
-                           static_cast<uint32_t>(18),
-                           static_cast<uint32_t>(19),
-                           static_cast<uint32_t>(20),
-                           static_cast<uint32_t>(21),
-                           static_cast<uint32_t>(22));
+  void* next_cmd =
+      cmd.Set(&cmd, static_cast<GLenum>(11), static_cast<GLint>(12),
+              static_cast<GLint>(13), static_cast<GLsizei>(14),
+              static_cast<GLsizei>(15), static_cast<GLenum>(16),
+              static_cast<GLenum>(17), static_cast<uint32_t>(18),
+              static_cast<uint32_t>(19), static_cast<uint32_t>(20),
+              static_cast<uint32_t>(21), static_cast<uint32_t>(22));
   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);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(16), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.type);
@@ skipping 99 matching lines @@
   void* next_cmd = cmd.Set(&cmd);
   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));
+  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);
@@ skipping 51 matching lines @@
 TEST_F(GLES2FormatTest, BlendBarrierKHR) {
   cmds::BlendBarrierKHR& cmd = *GetBufferAs<cmds::BlendBarrierKHR>();
   void* next_cmd = cmd.Set(&cmd);
   EXPECT_EQ(static_cast<uint32_t>(cmds::BlendBarrierKHR::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(next_cmd, sizeof(cmd));
 }
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_