command_buffer: Implement path rendering functions for CHROMIUM_path_rendering

gpu/command_buffer/common/gles2_cmd_format_autogen.h

Index: gpu/command_buffer/common/gles2_cmd_format_autogen.h
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index ccdc040a007916f424d044200dda4c6943990c27..2d845a2a1dac96c6d4b5eac2ca26c9a600fe26fa 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -9014,4 +9014,555 @@ COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, header) == 0,
 COMPILE_ASSERT(offsetof(MatrixLoadIdentityCHROMIUM, matrixMode) == 4,
                OffsetOf_MatrixLoadIdentityCHROMIUM_matrixMode_not_4);
 
+struct GenPathsCHROMIUM {
+  typedef GenPathsCHROMIUM ValueType;
+  static const CommandId kCmdId = kGenPathsCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _first_client_id, GLsizei _range) {
+    SetHeader();
+    first_client_id = _first_client_id;
+    range = _range;
+  }
+
+  void* Set(void* cmd, GLuint _first_client_id, GLsizei _range) {
+    static_cast<ValueType*>(cmd)->Init(_first_client_id, _range);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t first_client_id;
+  int32_t range;
+};
+
+COMPILE_ASSERT(sizeof(GenPathsCHROMIUM) == 12,
+               Sizeof_GenPathsCHROMIUM_is_not_12);
+COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, header) == 0,
+               OffsetOf_GenPathsCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, first_client_id) == 4,
+               OffsetOf_GenPathsCHROMIUM_first_client_id_not_4);
+COMPILE_ASSERT(offsetof(GenPathsCHROMIUM, range) == 8,
+               OffsetOf_GenPathsCHROMIUM_range_not_8);
+
+struct DeletePathsCHROMIUM {
+  typedef DeletePathsCHROMIUM ValueType;
+  static const CommandId kCmdId = kDeletePathsCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _first_client_id, GLsizei _range) {
+    SetHeader();
+    first_client_id = _first_client_id;
+    range = _range;
+  }
+
+  void* Set(void* cmd, GLuint _first_client_id, GLsizei _range) {
+    static_cast<ValueType*>(cmd)->Init(_first_client_id, _range);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t first_client_id;
+  int32_t range;
+};
+
+COMPILE_ASSERT(sizeof(DeletePathsCHROMIUM) == 12,
+               Sizeof_DeletePathsCHROMIUM_is_not_12);
+COMPILE_ASSERT(offsetof(DeletePathsCHROMIUM, header) == 0,
+               OffsetOf_DeletePathsCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(DeletePathsCHROMIUM, first_client_id) == 4,
+               OffsetOf_DeletePathsCHROMIUM_first_client_id_not_4);
+COMPILE_ASSERT(offsetof(DeletePathsCHROMIUM, range) == 8,
+               OffsetOf_DeletePathsCHROMIUM_range_not_8);
+
+struct IsPathCHROMIUM {
+  typedef IsPathCHROMIUM ValueType;
+  static const CommandId kCmdId = kIsPathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  typedef uint32_t Result;
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path,
+            uint32_t _result_shm_id,
+            uint32_t _result_shm_offset) {
+    SetHeader();
+    path = _path;
+    result_shm_id = _result_shm_id;
+    result_shm_offset = _result_shm_offset;
+  }
+
+  void* Set(void* cmd,
+            GLuint _path,
+            uint32_t _result_shm_id,
+            uint32_t _result_shm_offset) {
+    static_cast<ValueType*>(cmd)
+        ->Init(_path, _result_shm_id, _result_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  uint32_t result_shm_id;
+  uint32_t result_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(IsPathCHROMIUM) == 16, Sizeof_IsPathCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(IsPathCHROMIUM, header) == 0,
+               OffsetOf_IsPathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(IsPathCHROMIUM, path) == 4,
+               OffsetOf_IsPathCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(IsPathCHROMIUM, result_shm_id) == 8,
+               OffsetOf_IsPathCHROMIUM_result_shm_id_not_8);
+COMPILE_ASSERT(offsetof(IsPathCHROMIUM, result_shm_offset) == 12,
+               OffsetOf_IsPathCHROMIUM_result_shm_offset_not_12);
+
+struct PathCommandsCHROMIUM {
+  typedef PathCommandsCHROMIUM ValueType;
+  static const CommandId kCmdId = kPathCommandsCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path,
+            GLsizei _numCommands,
+            uint32_t _commands_shm_id,
+            uint32_t _commands_shm_offset,
+            GLsizei _numCoords,
+            uint32_t _coords_shm_id,
+            uint32_t _coords_shm_offset) {
+    SetHeader();
+    path = _path;
+    numCommands = _numCommands;
+    commands_shm_id = _commands_shm_id;
+    commands_shm_offset = _commands_shm_offset;
+    numCoords = _numCoords;
+    coords_shm_id = _coords_shm_id;
+    coords_shm_offset = _coords_shm_offset;
+  }
+
+  void* Set(void* cmd,
+            GLuint _path,
+            GLsizei _numCommands,
+            uint32_t _commands_shm_id,
+            uint32_t _commands_shm_offset,
+            GLsizei _numCoords,
+            uint32_t _coords_shm_id,
+            uint32_t _coords_shm_offset) {
+    static_cast<ValueType*>(cmd)->Init(_path,
+                                       _numCommands,
+                                       _commands_shm_id,
+                                       _commands_shm_offset,
+                                       _numCoords,
+                                       _coords_shm_id,
+                                       _coords_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  int32_t numCommands;
+  uint32_t commands_shm_id;
+  uint32_t commands_shm_offset;
+  int32_t numCoords;
+  uint32_t coords_shm_id;
+  uint32_t coords_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(PathCommandsCHROMIUM) == 32,
+               Sizeof_PathCommandsCHROMIUM_is_not_32);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, header) == 0,
+               OffsetOf_PathCommandsCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, path) == 4,
+               OffsetOf_PathCommandsCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, numCommands) == 8,
+               OffsetOf_PathCommandsCHROMIUM_numCommands_not_8);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, commands_shm_id) == 12,
+               OffsetOf_PathCommandsCHROMIUM_commands_shm_id_not_12);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, commands_shm_offset) == 16,
+               OffsetOf_PathCommandsCHROMIUM_commands_shm_offset_not_16);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, numCoords) == 20,
+               OffsetOf_PathCommandsCHROMIUM_numCoords_not_20);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, coords_shm_id) == 24,
+               OffsetOf_PathCommandsCHROMIUM_coords_shm_id_not_24);
+COMPILE_ASSERT(offsetof(PathCommandsCHROMIUM, coords_shm_offset) == 28,
+               OffsetOf_PathCommandsCHROMIUM_coords_shm_offset_not_28);
+
+struct PathParameterfCHROMIUM {
+  typedef PathParameterfCHROMIUM ValueType;
+  static const CommandId kCmdId = kPathParameterfCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path, GLenum _pname, GLfloat _value) {
+    SetHeader();
+    path = _path;
+    pname = _pname;
+    value = _value;
+  }
+
+  void* Set(void* cmd, GLuint _path, GLenum _pname, GLfloat _value) {
+    static_cast<ValueType*>(cmd)->Init(_path, _pname, _value);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  uint32_t pname;
+  float value;
+};
+
+COMPILE_ASSERT(sizeof(PathParameterfCHROMIUM) == 16,
+               Sizeof_PathParameterfCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, header) == 0,
+               OffsetOf_PathParameterfCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, path) == 4,
+               OffsetOf_PathParameterfCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, pname) == 8,
+               OffsetOf_PathParameterfCHROMIUM_pname_not_8);
+COMPILE_ASSERT(offsetof(PathParameterfCHROMIUM, value) == 12,
+               OffsetOf_PathParameterfCHROMIUM_value_not_12);
+
+struct PathParameteriCHROMIUM {
+  typedef PathParameteriCHROMIUM ValueType;
+  static const CommandId kCmdId = kPathParameteriCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path, GLenum _pname, GLint _value) {
+    SetHeader();
+    path = _path;
+    pname = _pname;
+    value = _value;
+  }
+
+  void* Set(void* cmd, GLuint _path, GLenum _pname, GLint _value) {
+    static_cast<ValueType*>(cmd)->Init(_path, _pname, _value);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  uint32_t pname;
+  int32_t value;
+};
+
+COMPILE_ASSERT(sizeof(PathParameteriCHROMIUM) == 16,
+               Sizeof_PathParameteriCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, header) == 0,
+               OffsetOf_PathParameteriCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, path) == 4,
+               OffsetOf_PathParameteriCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, pname) == 8,
+               OffsetOf_PathParameteriCHROMIUM_pname_not_8);
+COMPILE_ASSERT(offsetof(PathParameteriCHROMIUM, value) == 12,
+               OffsetOf_PathParameteriCHROMIUM_value_not_12);
+
+struct PathStencilFuncCHROMIUM {
+  typedef PathStencilFuncCHROMIUM ValueType;
+  static const CommandId kCmdId = kPathStencilFuncCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLenum _func, GLint _ref, GLuint _mask) {
+    SetHeader();
+    func = _func;
+    ref = _ref;
+    mask = _mask;
+  }
+
+  void* Set(void* cmd, GLenum _func, GLint _ref, GLuint _mask) {
+    static_cast<ValueType*>(cmd)->Init(_func, _ref, _mask);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t func;
+  int32_t ref;
+  uint32_t mask;
+};
+
+COMPILE_ASSERT(sizeof(PathStencilFuncCHROMIUM) == 16,
+               Sizeof_PathStencilFuncCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, header) == 0,
+               OffsetOf_PathStencilFuncCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, func) == 4,
+               OffsetOf_PathStencilFuncCHROMIUM_func_not_4);
+COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, ref) == 8,
+               OffsetOf_PathStencilFuncCHROMIUM_ref_not_8);
+COMPILE_ASSERT(offsetof(PathStencilFuncCHROMIUM, mask) == 12,
+               OffsetOf_PathStencilFuncCHROMIUM_mask_not_12);
+
+struct StencilFillPathCHROMIUM {
+  typedef StencilFillPathCHROMIUM ValueType;
+  static const CommandId kCmdId = kStencilFillPathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path, GLenum _fillMode, GLuint _mask) {
+    SetHeader();
+    path = _path;
+    fillMode = _fillMode;
+    mask = _mask;
+  }
+
+  void* Set(void* cmd, GLuint _path, GLenum _fillMode, GLuint _mask) {
+    static_cast<ValueType*>(cmd)->Init(_path, _fillMode, _mask);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  uint32_t fillMode;
+  uint32_t mask;
+};
+
+COMPILE_ASSERT(sizeof(StencilFillPathCHROMIUM) == 16,
+               Sizeof_StencilFillPathCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, header) == 0,
+               OffsetOf_StencilFillPathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, path) == 4,
+               OffsetOf_StencilFillPathCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, fillMode) == 8,
+               OffsetOf_StencilFillPathCHROMIUM_fillMode_not_8);
+COMPILE_ASSERT(offsetof(StencilFillPathCHROMIUM, mask) == 12,
+               OffsetOf_StencilFillPathCHROMIUM_mask_not_12);
+
+struct StencilStrokePathCHROMIUM {
+  typedef StencilStrokePathCHROMIUM ValueType;
+  static const CommandId kCmdId = kStencilStrokePathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path, GLint _reference, GLuint _mask) {
+    SetHeader();
+    path = _path;
+    reference = _reference;
+    mask = _mask;
+  }
+
+  void* Set(void* cmd, GLuint _path, GLint _reference, GLuint _mask) {
+    static_cast<ValueType*>(cmd)->Init(_path, _reference, _mask);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  int32_t reference;
+  uint32_t mask;
+};
+
+COMPILE_ASSERT(sizeof(StencilStrokePathCHROMIUM) == 16,
+               Sizeof_StencilStrokePathCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, header) == 0,
+               OffsetOf_StencilStrokePathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, path) == 4,
+               OffsetOf_StencilStrokePathCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, reference) == 8,
+               OffsetOf_StencilStrokePathCHROMIUM_reference_not_8);
+COMPILE_ASSERT(offsetof(StencilStrokePathCHROMIUM, mask) == 12,
+               OffsetOf_StencilStrokePathCHROMIUM_mask_not_12);
+
+struct CoverFillPathCHROMIUM {
+  typedef CoverFillPathCHROMIUM ValueType;
+  static const CommandId kCmdId = kCoverFillPathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path) {
+    SetHeader();
+    path = _path;
+  }
+
+  void* Set(void* cmd, GLuint _path) {
+    static_cast<ValueType*>(cmd)->Init(_path);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+};
+
+COMPILE_ASSERT(sizeof(CoverFillPathCHROMIUM) == 8,
+               Sizeof_CoverFillPathCHROMIUM_is_not_8);
+COMPILE_ASSERT(offsetof(CoverFillPathCHROMIUM, header) == 0,
+               OffsetOf_CoverFillPathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(CoverFillPathCHROMIUM, path) == 4,
+               OffsetOf_CoverFillPathCHROMIUM_path_not_4);
+
+struct CoverStrokePathCHROMIUM {
+  typedef CoverStrokePathCHROMIUM ValueType;
+  static const CommandId kCmdId = kCoverStrokePathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path) {
+    SetHeader();
+    path = _path;
+  }
+
+  void* Set(void* cmd, GLuint _path) {
+    static_cast<ValueType*>(cmd)->Init(_path);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+};
+
+COMPILE_ASSERT(sizeof(CoverStrokePathCHROMIUM) == 8,
+               Sizeof_CoverStrokePathCHROMIUM_is_not_8);
+COMPILE_ASSERT(offsetof(CoverStrokePathCHROMIUM, header) == 0,
+               OffsetOf_CoverStrokePathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(CoverStrokePathCHROMIUM, path) == 4,
+               OffsetOf_CoverStrokePathCHROMIUM_path_not_4);
+
+struct StencilThenCoverFillPathCHROMIUM {
+  typedef StencilThenCoverFillPathCHROMIUM ValueType;
+  static const CommandId kCmdId = kStencilThenCoverFillPathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path, GLenum _fillMode, GLuint _mask) {
+    SetHeader();
+    path = _path;
+    fillMode = _fillMode;
+    mask = _mask;
+  }
+
+  void* Set(void* cmd, GLuint _path, GLenum _fillMode, GLuint _mask) {
+    static_cast<ValueType*>(cmd)->Init(_path, _fillMode, _mask);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  uint32_t fillMode;
+  uint32_t mask;
+};
+
+COMPILE_ASSERT(sizeof(StencilThenCoverFillPathCHROMIUM) == 16,
+               Sizeof_StencilThenCoverFillPathCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(StencilThenCoverFillPathCHROMIUM, header) == 0,
+               OffsetOf_StencilThenCoverFillPathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(StencilThenCoverFillPathCHROMIUM, path) == 4,
+               OffsetOf_StencilThenCoverFillPathCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(StencilThenCoverFillPathCHROMIUM, fillMode) == 8,
+               OffsetOf_StencilThenCoverFillPathCHROMIUM_fillMode_not_8);
+COMPILE_ASSERT(offsetof(StencilThenCoverFillPathCHROMIUM, mask) == 12,
+               OffsetOf_StencilThenCoverFillPathCHROMIUM_mask_not_12);
+
+struct StencilThenCoverStrokePathCHROMIUM {
+  typedef StencilThenCoverStrokePathCHROMIUM ValueType;
+  static const CommandId kCmdId = kStencilThenCoverStrokePathCHROMIUM;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+  static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
+
+  static uint32_t ComputeSize() {
+    return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() { header.SetCmd<ValueType>(); }
+
+  void Init(GLuint _path, GLint _reference, GLuint _mask) {
+    SetHeader();
+    path = _path;
+    reference = _reference;
+    mask = _mask;
+  }
+
+  void* Set(void* cmd, GLuint _path, GLint _reference, GLuint _mask) {
+    static_cast<ValueType*>(cmd)->Init(_path, _reference, _mask);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32_t path;
+  int32_t reference;
+  uint32_t mask;
+};
+
+COMPILE_ASSERT(sizeof(StencilThenCoverStrokePathCHROMIUM) == 16,
+               Sizeof_StencilThenCoverStrokePathCHROMIUM_is_not_16);
+COMPILE_ASSERT(offsetof(StencilThenCoverStrokePathCHROMIUM, header) == 0,
+               OffsetOf_StencilThenCoverStrokePathCHROMIUM_header_not_0);
+COMPILE_ASSERT(offsetof(StencilThenCoverStrokePathCHROMIUM, path) == 4,
+               OffsetOf_StencilThenCoverStrokePathCHROMIUM_path_not_4);
+COMPILE_ASSERT(offsetof(StencilThenCoverStrokePathCHROMIUM, reference) == 8,
+               OffsetOf_StencilThenCoverStrokePathCHROMIUM_reference_not_8);
+COMPILE_ASSERT(offsetof(StencilThenCoverStrokePathCHROMIUM, mask) == 12,
+               OffsetOf_StencilThenCoverStrokePathCHROMIUM_mask_not_12);
+
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_