gpu/command_buffer/common/gles2_cmd_format.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file defines the GLES2 command buffer commands.
   6
   7 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
   8 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
   9
  10
  11 #include <KHR/khrplatform.h>
  12
  13 #include <string.h>
  14
  15 #include "base/safe_numerics.h"
  16 #include "gpu/command_buffer/common/bitfield_helpers.h"
  17 #include "gpu/command_buffer/common/cmd_buffer_common.h"
  18 #include "gpu/command_buffer/common/gles2_cmd_ids.h"
  19 #include "gpu/command_buffer/common/types.h"
  20
  21 // GL types are forward declared to avoid including the GL headers. The problem
  22 // is determining which GL headers to include from code that is common to the
  23 // client and service sides (GLES2 or one of several GL implementations).
  24 typedef unsigned int GLenum;
  25 typedef unsigned int GLbitfield;
  26 typedef unsigned int GLuint;
  27 typedef int GLint;
  28 typedef int GLsizei;
  29 typedef unsigned char GLboolean;
  30 typedef signed char GLbyte;
  31 typedef short GLshort;
  32 typedef unsigned char GLubyte;
  33 typedef unsigned short GLushort;
  34 typedef unsigned long GLulong;
  35 typedef float GLfloat;
  36 typedef float GLclampf;
  37 typedef double GLdouble;
  38 typedef double GLclampd;
  39 typedef void GLvoid;
  40 typedef khronos_intptr_t GLintptr;
  41 typedef khronos_ssize_t  GLsizeiptr;
  42
  43 namespace gpu {
  44 namespace gles2 {
  45
  46 #pragma pack(push, 1)
  47
  48 namespace id_namespaces {
  49
  50 // These are used when contexts share resources.
  51 enum IdNamespaces {
  52   kBuffers,
  53   kFramebuffers,
  54   kProgramsAndShaders,
  55   kRenderbuffers,
  56   kTextures,
  57   kQueries,
  58   kVertexArrays,
  59   kNumIdNamespaces
  60 };
  61
  62 // These numbers must not change
  63 COMPILE_ASSERT(kBuffers == 0, kBuffers_is_not_0);
  64 COMPILE_ASSERT(kFramebuffers == 1, kFramebuffers_is_not_1);
  65 COMPILE_ASSERT(kProgramsAndShaders == 2, kProgramsAndShaders_is_not_2);
  66 COMPILE_ASSERT(kRenderbuffers == 3, kRenderbuffers_is_not_3);
  67 COMPILE_ASSERT(kTextures == 4, kTextures_is_not_4);
  68
  69 }  // namespace id_namespaces
  70
  71 // Used for some glGetXXX commands that return a result through a pointer. We
  72 // need to know if the command succeeded or not and the size of the result. If
  73 // the command failed its result size will 0.
  74 template <typename T>
  75 struct SizedResult {
  76   typedef T Type;
  77
  78   T* GetData() {
  79     return static_cast<T*>(static_cast<void*>(&data));
  80   }
  81
  82   // Returns the total size in bytes of the SizedResult for a given number of
  83   // results including the size field.
  84   static size_t ComputeSize(size_t num_results) {
  85     return sizeof(T) * num_results + sizeof(uint32);  // NOLINT
  86   }
  87
  88   // Returns the total size in bytes of the SizedResult for a given size of
  89   // results.
  90   static size_t ComputeSizeFromBytes(size_t size_of_result_in_bytes) {
  91     return size_of_result_in_bytes + sizeof(uint32);  // NOLINT
  92   }
  93
  94   // Returns the maximum number of results for a given buffer size.
  95   static uint32 ComputeMaxResults(size_t size_of_buffer) {
  96     return (size_of_buffer >= sizeof(uint32)) ?
  97         ((size_of_buffer - sizeof(uint32)) / sizeof(T)) : 0;  // NOLINT
  98   }
  99
 100   // Set the size for a given number of results.
 101   void SetNumResults(size_t num_results) {
 102     size = sizeof(T) * num_results;  // NOLINT
 103   }
 104
 105   // Get the number of elements in the result
 106   int32 GetNumResults() const {
 107     return size / sizeof(T);  // NOLINT
 108   }
 109
 110   // Copy the result.
 111   void CopyResult(void* dst) const {
 112     memcpy(dst, &data, size);
 113   }
 114
 115   uint32 size;  // in bytes.
 116   int32 data;  // this is just here to get an offset.
 117 };
 118
 119 COMPILE_ASSERT(sizeof(SizedResult<int8>) == 8, SizedResult_size_not_8);
 120 COMPILE_ASSERT(offsetof(SizedResult<int8>, size) == 0,
 121                OffsetOf_SizedResult_size_not_0);
 122 COMPILE_ASSERT(offsetof(SizedResult<int8>, data) == 4,
 123                OffsetOf_SizedResult_data_not_4);
 124
 125 // The data for one attrib or uniform from GetProgramInfoCHROMIUM.
 126 struct ProgramInput {
 127   uint32 type;             // The type (GL_VEC3, GL_MAT3, GL_SAMPLER_2D, etc.
 128   int32 size;              // The size (how big the array is for uniforms)
 129   uint32 location_offset;  // offset from ProgramInfoHeader to 'size' locations
 130                            // for uniforms, 1 for attribs.
 131   uint32 name_offset;      // offset from ProgrmaInfoHeader to start of name.
 132   uint32 name_length;      // length of the name.
 133 };
 134
 135 // The format of the bucket filled out by GetProgramInfoCHROMIUM
 136 struct ProgramInfoHeader {
 137   uint32 link_status;
 138   uint32 num_attribs;
 139   uint32 num_uniforms;
 140   // ProgramInput inputs[num_attribs + num_uniforms];
 141 };
 142
 143 // The format of QuerySync used by EXT_occlusion_query_boolean
 144 struct QuerySync {
 145   void Reset() {
 146     process_count = 0;
 147     result = 0;
 148   }
 149
 150   uint32 process_count;
 151   uint64 result;
 152 };
 153
 154 COMPILE_ASSERT(sizeof(ProgramInput) == 20, ProgramInput_size_not_20);
 155 COMPILE_ASSERT(offsetof(ProgramInput, type) == 0,
 156                OffsetOf_ProgramInput_type_not_0);
 157 COMPILE_ASSERT(offsetof(ProgramInput, size) == 4,
 158                OffsetOf_ProgramInput_size_not_4);
 159 COMPILE_ASSERT(offsetof(ProgramInput, location_offset) == 8,
 160                OffsetOf_ProgramInput_location_offset_not_8);
 161 COMPILE_ASSERT(offsetof(ProgramInput, name_offset) == 12,
 162                OffsetOf_ProgramInput_name_offset_not_12);
 163 COMPILE_ASSERT(offsetof(ProgramInput, name_length) == 16,
 164                OffsetOf_ProgramInput_name_length_not_16);
 165
 166 COMPILE_ASSERT(sizeof(ProgramInfoHeader) == 12, ProgramInfoHeader_size_not_12);
 167 COMPILE_ASSERT(offsetof(ProgramInfoHeader, link_status) == 0,
 168                OffsetOf_ProgramInfoHeader_link_status_not_0);
 169 COMPILE_ASSERT(offsetof(ProgramInfoHeader, num_attribs) == 4,
 170                OffsetOf_ProgramInfoHeader_num_attribs_not_4);
 171 COMPILE_ASSERT(offsetof(ProgramInfoHeader, num_uniforms) == 8,
 172                OffsetOf_ProgramInfoHeader_num_uniforms_not_8);
 173
 174 namespace cmds {
 175
 176 #include "../common/gles2_cmd_format_autogen.h"
 177
 178 // These are hand written commands.
 179 // TODO(gman): Attempt to make these auto-generated.
 180
 181 struct GetAttribLocation {
 182   typedef GetAttribLocation ValueType;
 183   static const CommandId kCmdId = kGetAttribLocation;
 184   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 185
 186   typedef GLint Result;
 187
 188   static uint32 ComputeSize() {
 189     return static_cast<uint32>(sizeof(ValueType));  // NOLINT
 190   }
 191
 192   void SetHeader() {
 193     header.SetCmd<ValueType>();
 194   }
 195
 196   void Init(
 197       GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
 198       uint32 _location_shm_id, uint32 _location_shm_offset,
 199       uint32 _data_size) {
 200     SetHeader();
 201     program = _program;
 202     name_shm_id = _name_shm_id;
 203     name_shm_offset = _name_shm_offset;
 204     location_shm_id = _location_shm_id;
 205     location_shm_offset = _location_shm_offset;
 206     data_size = _data_size;
 207   }
 208
 209   void* Set(
 210       void* cmd, GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
 211       uint32 _location_shm_id, uint32 _location_shm_offset,
 212       uint32 _data_size) {
 213     static_cast<ValueType*>(
 214         cmd)->Init(
 215             _program, _name_shm_id, _name_shm_offset, _location_shm_id,
 216             _location_shm_offset, _data_size);
 217     return NextCmdAddress<ValueType>(cmd);
 218   }
 219
 220   CommandHeader header;
 221   uint32 program;
 222   uint32 name_shm_id;
 223   uint32 name_shm_offset;
 224   uint32 location_shm_id;
 225   uint32 location_shm_offset;
 226   uint32 data_size;
 227 };
 228
 229 COMPILE_ASSERT(sizeof(GetAttribLocation) == 28,
 230                Sizeof_GetAttribLocation_is_not_28);
 231 COMPILE_ASSERT(offsetof(GetAttribLocation, header) == 0,
 232                OffsetOf_GetAttribLocation_header_not_0);
 233 COMPILE_ASSERT(offsetof(GetAttribLocation, program) == 4,
 234                OffsetOf_GetAttribLocation_program_not_4);
 235 COMPILE_ASSERT(offsetof(GetAttribLocation, name_shm_id) == 8,
 236                OffsetOf_GetAttribLocation_name_shm_id_not_8);
 237 COMPILE_ASSERT(offsetof(GetAttribLocation, name_shm_offset) == 12,
 238                OffsetOf_GetAttribLocation_name_shm_offset_not_12);
 239 COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_id) == 16,
 240                OffsetOf_GetAttribLocation_location_shm_id_not_16);
 241 COMPILE_ASSERT(offsetof(GetAttribLocation, location_shm_offset) == 20,
 242                OffsetOf_GetAttribLocation_location_shm_offset_not_20);
 243 COMPILE_ASSERT(offsetof(GetAttribLocation, data_size) == 24,
 244                OffsetOf_GetAttribLocation_data_size_not_24);
 245
 246 struct GetAttribLocationImmediate {
 247   typedef GetAttribLocationImmediate ValueType;
 248   static const CommandId kCmdId = kGetAttribLocationImmediate;
 249   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 250
 251   typedef GLint Result;
 252
 253   static uint32 ComputeDataSize(const char* s) {
 254     return base::checked_numeric_cast<uint32>(strlen(s));
 255   }
 256
 257   static uint32 ComputeSize(const char* s) {
 258     return base::checked_numeric_cast<uint32>(sizeof(ValueType) +
 259                                               ComputeDataSize(s));
 260   }
 261
 262   void SetHeader(const char* s) {
 263     header.SetCmdByTotalSize<ValueType>(ComputeSize(s));
 264   }
 265
 266   void Init(
 267       GLuint _program, const char* _name,
 268       uint32 _location_shm_id, uint32 _location_shm_offset) {
 269     SetHeader(_name);
 270     program = _program;
 271     location_shm_id = _location_shm_id;
 272     location_shm_offset = _location_shm_offset;
 273     data_size = ComputeDataSize(_name);
 274     memcpy(ImmediateDataAddress(this), _name, data_size);
 275   }
 276
 277   void* Set(
 278       void* cmd, GLuint _program, const char* _name,
 279       uint32 _location_shm_id, uint32 _location_shm_offset) {
 280     uint32 total_size = ComputeSize(_name);
 281     static_cast<ValueType*>(
 282         cmd)->Init(_program, _name, _location_shm_id, _location_shm_offset);
 283     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
 284   }
 285
 286   CommandHeader header;
 287   uint32 program;
 288   uint32 location_shm_id;
 289   uint32 location_shm_offset;
 290   uint32 data_size;
 291 };
 292
 293 COMPILE_ASSERT(sizeof(GetAttribLocationImmediate) == 20,
 294                Sizeof_GetAttribLocationImmediate_is_not_20);
 295 COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, header) == 0,
 296                OffsetOf_GetAttribLocationImmediate_header_not_0);
 297 COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, program) == 4,
 298                OffsetOf_GetAttribLocationImmediate_program_not_4);
 299 COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, location_shm_id) == 8,
 300                OffsetOf_GetAttribLocationImmediate_location_shm_id_not_8);
 301 COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, location_shm_offset) == 12,
 302                OffsetOf_GetAttribLocationImmediate_location_shm_offset_not_12);
 303 COMPILE_ASSERT(offsetof(GetAttribLocationImmediate, data_size) == 16,
 304                OffsetOf_GetAttribLocationImmediate_data_size_not_16);
 305
 306
 307 struct GetAttribLocationBucket {
 308   typedef GetAttribLocationBucket ValueType;
 309   static const CommandId kCmdId = kGetAttribLocationBucket;
 310   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 311
 312   typedef GLint Result;
 313
 314   static uint32 ComputeSize() {
 315     return static_cast<uint32>(sizeof(ValueType));  // NOLINT
 316   }
 317
 318   void SetHeader() {
 319     header.SetCmd<ValueType>();
 320   }
 321
 322   void Init(
 323       GLuint _program, uint32 _name_bucket_id,
 324       uint32 _location_shm_id, uint32 _location_shm_offset) {
 325     SetHeader();
 326     program = _program;
 327     name_bucket_id = _name_bucket_id;
 328     location_shm_id = _location_shm_id;
 329     location_shm_offset = _location_shm_offset;
 330   }
 331
 332   void* Set(
 333       void* cmd, GLuint _program, uint32 _name_bucket_id,
 334       uint32 _location_shm_id, uint32 _location_shm_offset) {
 335     static_cast<ValueType*>(
 336         cmd)->Init(
 337             _program, _name_bucket_id, _location_shm_id,
 338             _location_shm_offset);
 339     return NextCmdAddress<ValueType>(cmd);
 340   }
 341
 342   CommandHeader header;
 343   uint32 program;
 344   uint32 name_bucket_id;
 345   uint32 location_shm_id;
 346   uint32 location_shm_offset;
 347 };
 348
 349 COMPILE_ASSERT(sizeof(GetAttribLocationBucket) == 20,
 350                Sizeof_GetAttribLocationBucket_is_not_24);
 351 COMPILE_ASSERT(offsetof(GetAttribLocationBucket, header) == 0,
 352                OffsetOf_GetAttribLocationBucket_header_not_0);
 353 COMPILE_ASSERT(offsetof(GetAttribLocationBucket, program) == 4,
 354                OffsetOf_GetAttribLocationBucket_program_not_4);
 355 COMPILE_ASSERT(offsetof(GetAttribLocationBucket, name_bucket_id) == 8,
 356                OffsetOf_GetAttribLocationBucket_name_bucket_id_not_8);
 357 COMPILE_ASSERT(offsetof(GetAttribLocationBucket, location_shm_id) == 12,
 358                OffsetOf_GetAttribLocationBucket_location_shm_id_not_12);
 359 COMPILE_ASSERT(offsetof(GetAttribLocationBucket, location_shm_offset) == 16,
 360                OffsetOf_GetAttribLocationBucket_location_shm_offset_not_16);
 361
 362 struct GetUniformLocation {
 363   typedef GetUniformLocation ValueType;
 364   static const CommandId kCmdId = kGetUniformLocation;
 365   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 366
 367   typedef GLint Result;
 368
 369   static uint32 ComputeSize() {
 370     return static_cast<uint32>(sizeof(ValueType));  // NOLINT
 371   }
 372
 373   void SetHeader() {
 374     header.SetCmd<ValueType>();
 375   }
 376
 377   void Init(
 378       GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
 379       uint32 _location_shm_id, uint32 _location_shm_offset,
 380       uint32 _data_size) {
 381     SetHeader();
 382     program = _program;
 383     name_shm_id = _name_shm_id;
 384     name_shm_offset = _name_shm_offset;
 385     location_shm_id = _location_shm_id;
 386     location_shm_offset = _location_shm_offset;
 387     data_size = _data_size;
 388   }
 389
 390   void* Set(
 391       void* cmd, GLuint _program, uint32 _name_shm_id, uint32 _name_shm_offset,
 392       uint32 _location_shm_id, uint32 _location_shm_offset,
 393       uint32 _data_size) {
 394     static_cast<ValueType*>(
 395         cmd)->Init(
 396             _program, _name_shm_id, _name_shm_offset, _location_shm_id,
 397             _location_shm_offset, _data_size);
 398     return NextCmdAddress<ValueType>(cmd);
 399   }
 400
 401   CommandHeader header;
 402   uint32 program;
 403   uint32 name_shm_id;
 404   uint32 name_shm_offset;
 405   uint32 location_shm_id;
 406   uint32 location_shm_offset;
 407   uint32 data_size;
 408 };
 409
 410 COMPILE_ASSERT(sizeof(GetUniformLocation) == 28,
 411                Sizeof_GetUniformLocation_is_not_28);
 412 COMPILE_ASSERT(offsetof(GetUniformLocation, header) == 0,
 413                OffsetOf_GetUniformLocation_header_not_0);
 414 COMPILE_ASSERT(offsetof(GetUniformLocation, program) == 4,
 415                OffsetOf_GetUniformLocation_program_not_4);
 416 COMPILE_ASSERT(offsetof(GetUniformLocation, name_shm_id) == 8,
 417                OffsetOf_GetUniformLocation_name_shm_id_not_8);
 418 COMPILE_ASSERT(offsetof(GetUniformLocation, name_shm_offset) == 12,
 419                OffsetOf_GetUniformLocation_name_shm_offset_not_12);
 420 COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_id) == 16,
 421                OffsetOf_GetUniformLocation_location_shm_id_not_16);
 422 COMPILE_ASSERT(offsetof(GetUniformLocation, location_shm_offset) == 20,
 423                OffsetOf_GetUniformLocation_location_shm_offset_not_20);
 424 COMPILE_ASSERT(offsetof(GetUniformLocation, data_size) == 24,
 425                OffsetOf_GetUniformLocation_data_size_not_24);
 426
 427 struct GetUniformLocationImmediate {
 428   typedef GetUniformLocationImmediate ValueType;
 429   static const CommandId kCmdId = kGetUniformLocationImmediate;
 430   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
 431
 432   typedef GLint Result;
 433
 434   static uint32 ComputeDataSize(const char* s) {
 435     return base::checked_numeric_cast<uint32>(strlen(s));
 436   }
 437
 438   static uint32 ComputeSize(const char* s) {
 439     return base::checked_numeric_cast<uint32>(sizeof(ValueType) +
 440                                               ComputeDataSize(s));
 441   }
 442
 443   void SetHeader(const char* s) {
 444     header.SetCmdByTotalSize<ValueType>(ComputeSize(s));
 445   }
 446
 447   void Init(
 448       GLuint _program, const char* _name,
 449       uint32 _location_shm_id, uint32 _location_shm_offset) {
 450     SetHeader(_name);
 451     program = _program;
 452     location_shm_id = _location_shm_id;
 453     location_shm_offset = _location_shm_offset;
 454     data_size = ComputeDataSize(_name);
 455     memcpy(ImmediateDataAddress(this), _name, data_size);
 456   }
 457
 458   void* Set(
 459       void* cmd, GLuint _program, const char* _name,
 460       uint32 _location_shm_id, uint32 _location_shm_offset) {
 461     uint32 total_size = ComputeSize(_name);
 462     static_cast<ValueType*>(
 463         cmd)->Init(_program, _name, _location_shm_id, _location_shm_offset);
 464     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
 465   }
 466
 467   CommandHeader header;
 468   uint32 program;
 469   uint32 location_shm_id;
 470   uint32 location_shm_offset;
 471   uint32 data_size;
 472 };
 473
 474 COMPILE_ASSERT(sizeof(GetUniformLocationImmediate) == 20,
 475                Sizeof_GetUniformLocationImmediate_is_not_20);
 476 COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, header) == 0,
 477                OffsetOf_GetUniformLocationImmediate_header_not_0);
 478 COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, program) == 4,
 479                OffsetOf_GetUniformLocationImmediate_program_not_4);
 480 COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, location_shm_id) == 8,
 481                OffsetOf_GetUniformLocationImmediate_location_shm_id_not_8);
 482 COMPILE_ASSERT(
 483     offsetof(GetUniformLocationImmediate, location_shm_offset) == 12,
 484                OffsetOf_GetUniformLocationImmediate_location_shm_offset_not_12);
 485 COMPILE_ASSERT(offsetof(GetUniformLocationImmediate, data_size) == 16,
 486                OffsetOf_GetUniformLocationImmediate_data_size_not_16);
 487
 488 struct GetUniformLocationBucket {
 489   typedef GetUniformLocationBucket ValueType;
 490   static const CommandId kCmdId = kGetUniformLocationBucket;
 491   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 492
 493   typedef GLint Result;
 494
 495   static uint32 ComputeSize() {
 496     return static_cast<uint32>(sizeof(ValueType));  // NOLINT
 497   }
 498
 499   void SetHeader() {
 500     header.SetCmd<ValueType>();
 501   }
 502
 503   void Init(
 504       GLuint _program, uint32 _name_bucket_id,
 505       uint32 _location_shm_id, uint32 _location_shm_offset) {
 506     SetHeader();
 507     program = _program;
 508     name_bucket_id = _name_bucket_id;
 509     location_shm_id = _location_shm_id;
 510     location_shm_offset = _location_shm_offset;
 511   }
 512
 513   void* Set(
 514       void* cmd, GLuint _program, uint32 _name_bucket_id,
 515       uint32 _location_shm_id, uint32 _location_shm_offset) {
 516     static_cast<ValueType*>(
 517         cmd)->Init(
 518             _program, _name_bucket_id, _location_shm_id,
 519             _location_shm_offset);
 520     return NextCmdAddress<ValueType>(cmd);
 521   }
 522
 523   CommandHeader header;
 524   uint32 program;
 525   uint32 name_bucket_id;
 526   uint32 location_shm_id;
 527   uint32 location_shm_offset;
 528 };
 529
 530 COMPILE_ASSERT(sizeof(GetUniformLocationBucket) == 20,
 531                Sizeof_GetUniformLocationBucket_is_not_24);
 532 COMPILE_ASSERT(offsetof(GetUniformLocationBucket, header) == 0,
 533                OffsetOf_GetUniformLocationBucket_header_not_0);
 534 COMPILE_ASSERT(offsetof(GetUniformLocationBucket, program) == 4,
 535                OffsetOf_GetUniformLocationBucket_program_not_4);
 536 COMPILE_ASSERT(offsetof(GetUniformLocationBucket, name_bucket_id) == 8,
 537                OffsetOf_GetUniformLocationBucket_name_bucket_id_not_8);
 538 COMPILE_ASSERT(offsetof(GetUniformLocationBucket, location_shm_id) == 12,
 539                OffsetOf_GetUniformLocationBucket_location_shm_id_not_12);
 540 COMPILE_ASSERT(offsetof(GetUniformLocationBucket, location_shm_offset) == 16,
 541                OffsetOf_GetUniformLocationBucket_location_shm_offset_not_16);
 542
 543 struct InsertSyncPointCHROMIUM {
 544   typedef InsertSyncPointCHROMIUM ValueType;
 545   static const CommandId kCmdId = kInsertSyncPointCHROMIUM;
 546   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 547   CommandHeader header;
 548 };
 549
 550 #pragma pack(pop)
 551
 552 }  // namespace cmd
 553 }  // namespace gles2
 554 }  // namespace gpu
 555
 556 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_