Added CommandBufferClient, CommandBufferStub and some IPC messages....

gpu/command_buffer/common/gles2_cmd_format_autogen.h

 // This file is auto-generated. DO NOT EDIT!
 
 #pragma pack(push, 1)
 
 struct ActiveTexture {
   typedef ActiveTexture ValueType;
   static const CommandId kCmdId = kActiveTexture;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   static uint32 ComputeSize() {
     return static_cast<uint32>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init(GLenum _texture) {
     SetHeader();
     texture = _texture;
   }
 
   void* Set(void* cmd, GLenum _texture) {
     static_cast<ValueType*>(cmd)->Init(_texture);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 texture;
 };
 
 COMPILE_ASSERT(sizeof(ActiveTexture) == 8,
                Sizeof_ActiveTexture_is_not_8);
 COMPILE_ASSERT(offsetof(ActiveTexture, header) == 0,
                OffsetOf_ActiveTexture_header_not_0);
 COMPILE_ASSERT(offsetof(ActiveTexture, texture) == 4,
                OffsetOf_ActiveTexture_texture_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     program = _program;
     shader = _shader;
   }
 
   void* Set(void* cmd, GLuint _program, GLuint _shader) {
     static_cast<ValueType*>(cmd)->Init(_program, _shader);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 shader;
 };
 
 COMPILE_ASSERT(sizeof(AttachShader) == 12,
                Sizeof_AttachShader_is_not_12);
 COMPILE_ASSERT(offsetof(AttachShader, header) == 0,
                OffsetOf_AttachShader_header_not_0);
 COMPILE_ASSERT(offsetof(AttachShader, program) == 4,
                OffsetOf_AttachShader_program_not_4);
@@ skipping 26 matching lines @@
 
   void* Set(
       void* cmd, GLuint _program, GLuint _index, uint32 _name_shm_id,
       uint32 _name_shm_offset, uint32 _data_size) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _index, _name_shm_id, _name_shm_offset, _data_size);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 index;
   uint32 name_shm_id;
   uint32 name_shm_offset;
   uint32 data_size;
 };
 
 COMPILE_ASSERT(sizeof(BindAttribLocation) == 24,
                Sizeof_BindAttribLocation_is_not_24);
 COMPILE_ASSERT(offsetof(BindAttribLocation, header) == 0,
@@ skipping 34 matching lines @@
     data_size = strlen(_name);
     memcpy(ImmediateDataAddress(this), _name, data_size);
   }
 
   void* Set(void* cmd, GLuint _program, GLuint _index, const char* _name) {
     static_cast<ValueType*>(cmd)->Init(_program, _index, _name);
     const uint32 size = ComputeSize(_name);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 index;
   uint32 data_size;
 };
 
 COMPILE_ASSERT(sizeof(BindAttribLocationImmediate) == 16,
                Sizeof_BindAttribLocationImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, header) == 0,
                OffsetOf_BindAttribLocationImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(BindAttribLocationImmediate, program) == 4,
@@ skipping 20 matching lines @@
     SetHeader();
     target = _target;
     buffer = _buffer;
   }
 
   void* Set(void* cmd, GLenum _target, GLuint _buffer) {
     static_cast<ValueType*>(cmd)->Init(_target, _buffer);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 buffer;
 };
 
 COMPILE_ASSERT(sizeof(BindBuffer) == 12,
                Sizeof_BindBuffer_is_not_12);
 COMPILE_ASSERT(offsetof(BindBuffer, header) == 0,
                OffsetOf_BindBuffer_header_not_0);
 COMPILE_ASSERT(offsetof(BindBuffer, target) == 4,
                OffsetOf_BindBuffer_target_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     target = _target;
     framebuffer = _framebuffer;
   }
 
   void* Set(void* cmd, GLenum _target, GLuint _framebuffer) {
     static_cast<ValueType*>(cmd)->Init(_target, _framebuffer);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 framebuffer;
 };
 
 COMPILE_ASSERT(sizeof(BindFramebuffer) == 12,
                Sizeof_BindFramebuffer_is_not_12);
 COMPILE_ASSERT(offsetof(BindFramebuffer, header) == 0,
                OffsetOf_BindFramebuffer_header_not_0);
 COMPILE_ASSERT(offsetof(BindFramebuffer, target) == 4,
                OffsetOf_BindFramebuffer_target_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     target = _target;
     renderbuffer = _renderbuffer;
   }
 
   void* Set(void* cmd, GLenum _target, GLuint _renderbuffer) {
     static_cast<ValueType*>(cmd)->Init(_target, _renderbuffer);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 renderbuffer;
 };
 
 COMPILE_ASSERT(sizeof(BindRenderbuffer) == 12,
                Sizeof_BindRenderbuffer_is_not_12);
 COMPILE_ASSERT(offsetof(BindRenderbuffer, header) == 0,
                OffsetOf_BindRenderbuffer_header_not_0);
 COMPILE_ASSERT(offsetof(BindRenderbuffer, target) == 4,
                OffsetOf_BindRenderbuffer_target_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     target = _target;
     texture = _texture;
   }
 
   void* Set(void* cmd, GLenum _target, GLuint _texture) {
     static_cast<ValueType*>(cmd)->Init(_target, _texture);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 texture;
 };
 
 COMPILE_ASSERT(sizeof(BindTexture) == 12,
                Sizeof_BindTexture_is_not_12);
 COMPILE_ASSERT(offsetof(BindTexture, header) == 0,
                OffsetOf_BindTexture_header_not_0);
 COMPILE_ASSERT(offsetof(BindTexture, target) == 4,
                OffsetOf_BindTexture_target_not_4);
@@ skipping 21 matching lines @@
     alpha = _alpha;
   }
 
   void* Set(
       void* cmd, GLclampf _red, GLclampf _green, GLclampf _blue,
       GLclampf _alpha) {
     static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float red;
   float green;
   float blue;
   float alpha;
 };
 
 COMPILE_ASSERT(sizeof(BlendColor) == 20,
                Sizeof_BlendColor_is_not_20);
 COMPILE_ASSERT(offsetof(BlendColor, header) == 0,
                OffsetOf_BlendColor_header_not_0);
@@ skipping 22 matching lines @@
   void Init(GLenum _mode) {
     SetHeader();
     mode = _mode;
   }
 
   void* Set(void* cmd, GLenum _mode) {
     static_cast<ValueType*>(cmd)->Init(_mode);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mode;
 };
 
 COMPILE_ASSERT(sizeof(BlendEquation) == 8,
                Sizeof_BlendEquation_is_not_8);
 COMPILE_ASSERT(offsetof(BlendEquation, header) == 0,
                OffsetOf_BlendEquation_header_not_0);
 COMPILE_ASSERT(offsetof(BlendEquation, mode) == 4,
                OffsetOf_BlendEquation_mode_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     modeRGB = _modeRGB;
     modeAlpha = _modeAlpha;
   }
 
   void* Set(void* cmd, GLenum _modeRGB, GLenum _modeAlpha) {
     static_cast<ValueType*>(cmd)->Init(_modeRGB, _modeAlpha);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 modeRGB;
   uint32 modeAlpha;
 };
 
 COMPILE_ASSERT(sizeof(BlendEquationSeparate) == 12,
                Sizeof_BlendEquationSeparate_is_not_12);
 COMPILE_ASSERT(offsetof(BlendEquationSeparate, header) == 0,
                OffsetOf_BlendEquationSeparate_header_not_0);
 COMPILE_ASSERT(offsetof(BlendEquationSeparate, modeRGB) == 4,
                OffsetOf_BlendEquationSeparate_modeRGB_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     sfactor = _sfactor;
     dfactor = _dfactor;
   }
 
   void* Set(void* cmd, GLenum _sfactor, GLenum _dfactor) {
     static_cast<ValueType*>(cmd)->Init(_sfactor, _dfactor);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 sfactor;
   uint32 dfactor;
 };
 
 COMPILE_ASSERT(sizeof(BlendFunc) == 12,
                Sizeof_BlendFunc_is_not_12);
 COMPILE_ASSERT(offsetof(BlendFunc, header) == 0,
                OffsetOf_BlendFunc_header_not_0);
 COMPILE_ASSERT(offsetof(BlendFunc, sfactor) == 4,
                OffsetOf_BlendFunc_sfactor_not_4);
@@ skipping 22 matching lines @@
     dstAlpha = _dstAlpha;
   }
 
   void* Set(
       void* cmd, GLenum _srcRGB, GLenum _dstRGB, GLenum _srcAlpha,
       GLenum _dstAlpha) {
     static_cast<ValueType*>(cmd)->Init(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 srcRGB;
   uint32 dstRGB;
   uint32 srcAlpha;
   uint32 dstAlpha;
 };
 
 COMPILE_ASSERT(sizeof(BlendFuncSeparate) == 20,
                Sizeof_BlendFuncSeparate_is_not_20);
 COMPILE_ASSERT(offsetof(BlendFuncSeparate, header) == 0,
                OffsetOf_BlendFuncSeparate_header_not_0);
@@ skipping 31 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLsizeiptr _size, uint32 _data_shm_id,
       uint32 _data_shm_offset, GLenum _usage) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _size, _data_shm_id, _data_shm_offset, _usage);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 size;
   uint32 data_shm_id;
   uint32 data_shm_offset;
   uint32 usage;
 };
 
 COMPILE_ASSERT(sizeof(BufferData) == 24,
                Sizeof_BufferData_is_not_24);
 COMPILE_ASSERT(offsetof(BufferData, header) == 0,
@@ skipping 31 matching lines @@
     size = _size;
     usage = _usage;
   }
 
   void* Set(void* cmd, GLenum _target, GLsizeiptr _size, GLenum _usage) {
     uint32 total_size = 0;  // TODO(gman): get correct size.
     static_cast<ValueType*>(cmd)->Init(_target, _size, _usage);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 size;
   uint32 usage;
 };
 
 COMPILE_ASSERT(sizeof(BufferDataImmediate) == 16,
                Sizeof_BufferDataImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(BufferDataImmediate, header) == 0,
                OffsetOf_BufferDataImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(BufferDataImmediate, target) == 4,
@@ skipping 28 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLintptr _offset, GLsizeiptr _size,
       uint32 _data_shm_id, uint32 _data_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _offset, _size, _data_shm_id, _data_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 offset;
   uint32 size;
   uint32 data_shm_id;
   uint32 data_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(BufferSubData) == 24,
                Sizeof_BufferSubData_is_not_24);
 COMPILE_ASSERT(offsetof(BufferSubData, header) == 0,
@@ skipping 31 matching lines @@
     offset = _offset;
     size = _size;
   }
 
   void* Set(void* cmd, GLenum _target, GLintptr _offset, GLsizeiptr _size) {
     uint32 total_size = ComputeSize(_size);
     static_cast<ValueType*>(cmd)->Init(_target, _offset, _size);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 offset;
   uint32 size;
 };
 
 COMPILE_ASSERT(sizeof(BufferSubDataImmediate) == 16,
                Sizeof_BufferSubDataImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(BufferSubDataImmediate, header) == 0,
                OffsetOf_BufferSubDataImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(BufferSubDataImmediate, target) == 4,
@@ skipping 19 matching lines @@
   void Init(GLenum _target) {
     SetHeader();
     target = _target;
   }
 
   void* Set(void* cmd, GLenum _target) {
     static_cast<ValueType*>(cmd)->Init(_target);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
 };
 
 COMPILE_ASSERT(sizeof(CheckFramebufferStatus) == 8,
                Sizeof_CheckFramebufferStatus_is_not_8);
 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, header) == 0,
                OffsetOf_CheckFramebufferStatus_header_not_0);
 COMPILE_ASSERT(offsetof(CheckFramebufferStatus, target) == 4,
                OffsetOf_CheckFramebufferStatus_target_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLbitfield _mask) {
     SetHeader();
     mask = _mask;
   }
 
   void* Set(void* cmd, GLbitfield _mask) {
     static_cast<ValueType*>(cmd)->Init(_mask);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(Clear) == 8,
                Sizeof_Clear_is_not_8);
 COMPILE_ASSERT(offsetof(Clear, header) == 0,
                OffsetOf_Clear_header_not_0);
 COMPILE_ASSERT(offsetof(Clear, mask) == 4,
                OffsetOf_Clear_mask_not_4);
 
@@ skipping 18 matching lines @@
     alpha = _alpha;
   }
 
   void* Set(
       void* cmd, GLclampf _red, GLclampf _green, GLclampf _blue,
       GLclampf _alpha) {
     static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float red;
   float green;
   float blue;
   float alpha;
 };
 
 COMPILE_ASSERT(sizeof(ClearColor) == 20,
                Sizeof_ClearColor_is_not_20);
 COMPILE_ASSERT(offsetof(ClearColor, header) == 0,
                OffsetOf_ClearColor_header_not_0);
@@ skipping 22 matching lines @@
   void Init(GLclampf _depth) {
     SetHeader();
     depth = _depth;
   }
 
   void* Set(void* cmd, GLclampf _depth) {
     static_cast<ValueType*>(cmd)->Init(_depth);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float depth;
 };
 
 COMPILE_ASSERT(sizeof(ClearDepthf) == 8,
                Sizeof_ClearDepthf_is_not_8);
 COMPILE_ASSERT(offsetof(ClearDepthf, header) == 0,
                OffsetOf_ClearDepthf_header_not_0);
 COMPILE_ASSERT(offsetof(ClearDepthf, depth) == 4,
                OffsetOf_ClearDepthf_depth_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLint _s) {
     SetHeader();
     s = _s;
   }
 
   void* Set(void* cmd, GLint _s) {
     static_cast<ValueType*>(cmd)->Init(_s);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 s;
 };
 
 COMPILE_ASSERT(sizeof(ClearStencil) == 8,
                Sizeof_ClearStencil_is_not_8);
 COMPILE_ASSERT(offsetof(ClearStencil, header) == 0,
                OffsetOf_ClearStencil_header_not_0);
 COMPILE_ASSERT(offsetof(ClearStencil, s) == 4,
                OffsetOf_ClearStencil_s_not_4);
 
@@ skipping 19 matching lines @@
     alpha = _alpha;
   }
 
   void* Set(
       void* cmd, GLboolean _red, GLboolean _green, GLboolean _blue,
       GLboolean _alpha) {
     static_cast<ValueType*>(cmd)->Init(_red, _green, _blue, _alpha);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 red;
   uint32 green;
   uint32 blue;
   uint32 alpha;
 };
 
 COMPILE_ASSERT(sizeof(ColorMask) == 20,
                Sizeof_ColorMask_is_not_20);
 COMPILE_ASSERT(offsetof(ColorMask, header) == 0,
                OffsetOf_ColorMask_header_not_0);
@@ skipping 22 matching lines @@
   void Init(GLuint _shader) {
     SetHeader();
     shader = _shader;
   }
 
   void* Set(void* cmd, GLuint _shader) {
     static_cast<ValueType*>(cmd)->Init(_shader);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
 };
 
 COMPILE_ASSERT(sizeof(CompileShader) == 8,
                Sizeof_CompileShader_is_not_8);
 COMPILE_ASSERT(offsetof(CompileShader, header) == 0,
                OffsetOf_CompileShader_header_not_0);
 COMPILE_ASSERT(offsetof(CompileShader, shader) == 4,
                OffsetOf_CompileShader_shader_not_4);
 
@@ skipping 30 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLenum _internalformat,
       GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize,
       uint32 _data_shm_id, uint32 _data_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border,
             _imageSize, _data_shm_id, _data_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 internalformat;
   uint32 width;
   uint32 height;
   uint32 border;
   uint32 imageSize;
   uint32 data_shm_id;
   uint32 data_shm_offset;
 };
@@ skipping 54 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLenum _internalformat,
       GLsizei _width, GLsizei _height, GLint _border, GLsizei _imageSize) {
     uint32 total_size = 0;  // TODO(gman): get correct size.
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border,
             _imageSize);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 internalformat;
   uint32 width;
   uint32 height;
   uint32 border;
   uint32 imageSize;
 };
 
 COMPILE_ASSERT(sizeof(CompressedTexImage2DImmediate) == 32,
@@ skipping 49 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset,
       GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize,
       uint32 _data_shm_id, uint32 _data_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _imageSize, _data_shm_id, _data_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 xoffset;
   uint32 yoffset;
   uint32 width;
   uint32 height;
   uint32 format;
   uint32 imageSize;
   uint32 data_shm_id;
   uint32 data_shm_offset;
@@ skipping 58 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset,
       GLsizei _width, GLsizei _height, GLenum _format, GLsizei _imageSize) {
     uint32 total_size = ComputeSize(_imageSize);
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _imageSize);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 xoffset;
   uint32 yoffset;
   uint32 width;
   uint32 height;
   uint32 format;
   uint32 imageSize;
 };
 
@@ skipping 48 matching lines @@
   void* Set(
       void* cmd, GLenum _target, GLint _level, GLenum _internalformat, GLint _x,
       GLint _y, GLsizei _width, GLsizei _height, GLint _border) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _x, _y, _width, _height,
             _border);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 internalformat;
   uint32 x;
   uint32 y;
   uint32 width;
   uint32 height;
   uint32 border;
 };
 
@@ skipping 47 matching lines @@
 
   void* Set(
       void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset,
       GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 xoffset;
   uint32 yoffset;
   uint32 x;
   uint32 y;
   uint32 width;
   uint32 height;
 };
 
@@ skipping 34 matching lines @@
   void Init(uint32 _client_id) {
     SetHeader();
     client_id = _client_id;
   }
 
   void* Set(void* cmd, uint32 _client_id) {
     static_cast<ValueType*>(cmd)->Init(_client_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 client_id;
 };
 
 COMPILE_ASSERT(sizeof(CreateProgram) == 8,
                Sizeof_CreateProgram_is_not_8);
 COMPILE_ASSERT(offsetof(CreateProgram, header) == 0,
                OffsetOf_CreateProgram_header_not_0);
 COMPILE_ASSERT(offsetof(CreateProgram, client_id) == 4,
                OffsetOf_CreateProgram_client_id_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     type = _type;
     client_id = _client_id;
   }
 
   void* Set(void* cmd, GLenum _type, uint32 _client_id) {
     static_cast<ValueType*>(cmd)->Init(_type, _client_id);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 type;
   uint32 client_id;
 };
 
 COMPILE_ASSERT(sizeof(CreateShader) == 12,
                Sizeof_CreateShader_is_not_12);
 COMPILE_ASSERT(offsetof(CreateShader, header) == 0,
                OffsetOf_CreateShader_header_not_0);
 COMPILE_ASSERT(offsetof(CreateShader, type) == 4,
                OffsetOf_CreateShader_type_not_4);
@@ skipping 16 matching lines @@
   void Init(GLenum _mode) {
     SetHeader();
     mode = _mode;
   }
 
   void* Set(void* cmd, GLenum _mode) {
     static_cast<ValueType*>(cmd)->Init(_mode);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mode;
 };
 
 COMPILE_ASSERT(sizeof(CullFace) == 8,
                Sizeof_CullFace_is_not_8);
 COMPILE_ASSERT(offsetof(CullFace, header) == 0,
                OffsetOf_CullFace_header_not_0);
 COMPILE_ASSERT(offsetof(CullFace, mode) == 4,
                OffsetOf_CullFace_mode_not_4);
 
@@ skipping 18 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _buffers_shm_id,
       uint32 _buffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 buffers_shm_id;
   uint32 buffers_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(DeleteBuffers) == 16,
                Sizeof_DeleteBuffers_is_not_16);
 COMPILE_ASSERT(offsetof(DeleteBuffers, header) == 0,
                OffsetOf_DeleteBuffers_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteBuffers, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _buffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _buffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteBuffersImmediate) == 8,
                Sizeof_DeleteBuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, header) == 0,
                OffsetOf_DeleteBuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteBuffersImmediate, n) == 4,
                OffsetOf_DeleteBuffersImmediate_n_not_4);
 
@@ skipping 20 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _framebuffers_shm_id,
       uint32 _framebuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 framebuffers_shm_id;
   uint32 framebuffers_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(DeleteFramebuffers) == 16,
                Sizeof_DeleteFramebuffers_is_not_16);
 COMPILE_ASSERT(offsetof(DeleteFramebuffers, header) == 0,
                OffsetOf_DeleteFramebuffers_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteFramebuffers, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _framebuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _framebuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteFramebuffersImmediate) == 8,
                Sizeof_DeleteFramebuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, header) == 0,
                OffsetOf_DeleteFramebuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteFramebuffersImmediate, n) == 4,
                OffsetOf_DeleteFramebuffersImmediate_n_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
   }
 
   void* Set(void* cmd, GLuint _program) {
     static_cast<ValueType*>(cmd)->Init(_program);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
 };
 
 COMPILE_ASSERT(sizeof(DeleteProgram) == 8,
                Sizeof_DeleteProgram_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteProgram, header) == 0,
                OffsetOf_DeleteProgram_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteProgram, program) == 4,
                OffsetOf_DeleteProgram_program_not_4);
 
@@ skipping 20 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id,
       uint32 _renderbuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 renderbuffers_shm_id;
   uint32 renderbuffers_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(DeleteRenderbuffers) == 16,
                Sizeof_DeleteRenderbuffers_is_not_16);
 COMPILE_ASSERT(offsetof(DeleteRenderbuffers, header) == 0,
                OffsetOf_DeleteRenderbuffers_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteRenderbuffers, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _renderbuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _renderbuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteRenderbuffersImmediate) == 8,
                Sizeof_DeleteRenderbuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, header) == 0,
                OffsetOf_DeleteRenderbuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteRenderbuffersImmediate, n) == 4,
                OffsetOf_DeleteRenderbuffersImmediate_n_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLuint _shader) {
     SetHeader();
     shader = _shader;
   }
 
   void* Set(void* cmd, GLuint _shader) {
     static_cast<ValueType*>(cmd)->Init(_shader);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
 };
 
 COMPILE_ASSERT(sizeof(DeleteShader) == 8,
                Sizeof_DeleteShader_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteShader, header) == 0,
                OffsetOf_DeleteShader_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteShader, shader) == 4,
                OffsetOf_DeleteShader_shader_not_4);
 
@@ skipping 18 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _textures_shm_id,
       uint32 _textures_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _textures_shm_id, _textures_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 textures_shm_id;
   uint32 textures_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(DeleteTextures) == 16,
                Sizeof_DeleteTextures_is_not_16);
 COMPILE_ASSERT(offsetof(DeleteTextures, header) == 0,
                OffsetOf_DeleteTextures_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteTextures, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _textures, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, const GLuint* _textures) {
     static_cast<ValueType*>(cmd)->Init(_n, _textures);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(DeleteTexturesImmediate) == 8,
                Sizeof_DeleteTexturesImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, header) == 0,
                OffsetOf_DeleteTexturesImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(DeleteTexturesImmediate, n) == 4,
                OffsetOf_DeleteTexturesImmediate_n_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLenum _func) {
     SetHeader();
     func = _func;
   }
 
   void* Set(void* cmd, GLenum _func) {
     static_cast<ValueType*>(cmd)->Init(_func);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 func;
 };
 
 COMPILE_ASSERT(sizeof(DepthFunc) == 8,
                Sizeof_DepthFunc_is_not_8);
 COMPILE_ASSERT(offsetof(DepthFunc, header) == 0,
                OffsetOf_DepthFunc_header_not_0);
 COMPILE_ASSERT(offsetof(DepthFunc, func) == 4,
                OffsetOf_DepthFunc_func_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLboolean _flag) {
     SetHeader();
     flag = _flag;
   }
 
   void* Set(void* cmd, GLboolean _flag) {
     static_cast<ValueType*>(cmd)->Init(_flag);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 flag;
 };
 
 COMPILE_ASSERT(sizeof(DepthMask) == 8,
                Sizeof_DepthMask_is_not_8);
 COMPILE_ASSERT(offsetof(DepthMask, header) == 0,
                OffsetOf_DepthMask_header_not_0);
 COMPILE_ASSERT(offsetof(DepthMask, flag) == 4,
                OffsetOf_DepthMask_flag_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     zNear = _zNear;
     zFar = _zFar;
   }
 
   void* Set(void* cmd, GLclampf _zNear, GLclampf _zFar) {
     static_cast<ValueType*>(cmd)->Init(_zNear, _zFar);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float zNear;
   float zFar;
 };
 
 COMPILE_ASSERT(sizeof(DepthRangef) == 12,
                Sizeof_DepthRangef_is_not_12);
 COMPILE_ASSERT(offsetof(DepthRangef, header) == 0,
                OffsetOf_DepthRangef_header_not_0);
 COMPILE_ASSERT(offsetof(DepthRangef, zNear) == 4,
                OffsetOf_DepthRangef_zNear_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     program = _program;
     shader = _shader;
   }
 
   void* Set(void* cmd, GLuint _program, GLuint _shader) {
     static_cast<ValueType*>(cmd)->Init(_program, _shader);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 shader;
 };
 
 COMPILE_ASSERT(sizeof(DetachShader) == 12,
                Sizeof_DetachShader_is_not_12);
 COMPILE_ASSERT(offsetof(DetachShader, header) == 0,
                OffsetOf_DetachShader_header_not_0);
 COMPILE_ASSERT(offsetof(DetachShader, program) == 4,
                OffsetOf_DetachShader_program_not_4);
@@ skipping 16 matching lines @@
   void Init(GLenum _cap) {
     SetHeader();
     cap = _cap;
   }
 
   void* Set(void* cmd, GLenum _cap) {
     static_cast<ValueType*>(cmd)->Init(_cap);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 cap;
 };
 
 COMPILE_ASSERT(sizeof(Disable) == 8,
                Sizeof_Disable_is_not_8);
 COMPILE_ASSERT(offsetof(Disable, header) == 0,
                OffsetOf_Disable_header_not_0);
 COMPILE_ASSERT(offsetof(Disable, cap) == 4,
                OffsetOf_Disable_cap_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLuint _index) {
     SetHeader();
     index = _index;
   }
 
   void* Set(void* cmd, GLuint _index) {
     static_cast<ValueType*>(cmd)->Init(_index);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 index;
 };
 
 COMPILE_ASSERT(sizeof(DisableVertexAttribArray) == 8,
                Sizeof_DisableVertexAttribArray_is_not_8);
 COMPILE_ASSERT(offsetof(DisableVertexAttribArray, header) == 0,
                OffsetOf_DisableVertexAttribArray_header_not_0);
 COMPILE_ASSERT(offsetof(DisableVertexAttribArray, index) == 4,
                OffsetOf_DisableVertexAttribArray_index_not_4);
 
@@ skipping 15 matching lines @@
     mode = _mode;
     first = _first;
     count = _count;
   }
 
   void* Set(void* cmd, GLenum _mode, GLint _first, GLsizei _count) {
     static_cast<ValueType*>(cmd)->Init(_mode, _first, _count);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mode;
   uint32 first;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(DrawArrays) == 16,
                Sizeof_DrawArrays_is_not_16);
 COMPILE_ASSERT(offsetof(DrawArrays, header) == 0,
                OffsetOf_DrawArrays_header_not_0);
 COMPILE_ASSERT(offsetof(DrawArrays, mode) == 4,
@@ skipping 24 matching lines @@
     index_offset = _index_offset;
   }
 
   void* Set(
       void* cmd, GLenum _mode, GLsizei _count, GLenum _type,
       GLuint _index_offset) {
     static_cast<ValueType*>(cmd)->Init(_mode, _count, _type, _index_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mode;
   uint32 count;
   uint32 type;
   uint32 index_offset;
 };
 
 COMPILE_ASSERT(sizeof(DrawElements) == 20,
                Sizeof_DrawElements_is_not_20);
 COMPILE_ASSERT(offsetof(DrawElements, header) == 0,
                OffsetOf_DrawElements_header_not_0);
@@ skipping 22 matching lines @@
   void Init(GLenum _cap) {
     SetHeader();
     cap = _cap;
   }
 
   void* Set(void* cmd, GLenum _cap) {
     static_cast<ValueType*>(cmd)->Init(_cap);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 cap;
 };
 
 COMPILE_ASSERT(sizeof(Enable) == 8,
                Sizeof_Enable_is_not_8);
 COMPILE_ASSERT(offsetof(Enable, header) == 0,
                OffsetOf_Enable_header_not_0);
 COMPILE_ASSERT(offsetof(Enable, cap) == 4,
                OffsetOf_Enable_cap_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLuint _index) {
     SetHeader();
     index = _index;
   }
 
   void* Set(void* cmd, GLuint _index) {
     static_cast<ValueType*>(cmd)->Init(_index);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 index;
 };
 
 COMPILE_ASSERT(sizeof(EnableVertexAttribArray) == 8,
                Sizeof_EnableVertexAttribArray_is_not_8);
 COMPILE_ASSERT(offsetof(EnableVertexAttribArray, header) == 0,
                OffsetOf_EnableVertexAttribArray_header_not_0);
 COMPILE_ASSERT(offsetof(EnableVertexAttribArray, index) == 4,
                OffsetOf_EnableVertexAttribArray_index_not_4);
 
@@ skipping 12 matching lines @@
 
   void Init() {
     SetHeader();
   }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(Finish) == 4,
                Sizeof_Finish_is_not_4);
 COMPILE_ASSERT(offsetof(Finish, header) == 0,
                OffsetOf_Finish_header_not_0);
 
 struct Flush {
   typedef Flush ValueType;
   static const CommandId kCmdId = kFlush;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
 
   static uint32 ComputeSize() {
     return static_cast<uint32>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() {
     header.SetCmd<ValueType>();
   }
 
   void Init() {
     SetHeader();
   }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(Flush) == 4,
                Sizeof_Flush_is_not_4);
 COMPILE_ASSERT(offsetof(Flush, header) == 0,
                OffsetOf_Flush_header_not_0);
 
 struct FramebufferRenderbuffer {
   typedef FramebufferRenderbuffer ValueType;
   static const CommandId kCmdId = kFramebufferRenderbuffer;
@@ skipping 18 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _attachment, GLenum _renderbuffertarget,
       GLuint _renderbuffer) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _attachment, _renderbuffertarget, _renderbuffer);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 attachment;
   uint32 renderbuffertarget;
   uint32 renderbuffer;
 };
 
 COMPILE_ASSERT(sizeof(FramebufferRenderbuffer) == 20,
                Sizeof_FramebufferRenderbuffer_is_not_20);
 COMPILE_ASSERT(offsetof(FramebufferRenderbuffer, header) == 0,
                OffsetOf_FramebufferRenderbuffer_header_not_0);
@@ skipping 31 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _attachment, GLenum _textarget,
       GLuint _texture, GLint _level) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _attachment, _textarget, _texture, _level);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 attachment;
   uint32 textarget;
   uint32 texture;
   uint32 level;
 };
 
 COMPILE_ASSERT(sizeof(FramebufferTexture2D) == 24,
                Sizeof_FramebufferTexture2D_is_not_24);
 COMPILE_ASSERT(offsetof(FramebufferTexture2D, header) == 0,
@@ skipping 25 matching lines @@
   void Init(GLenum _mode) {
     SetHeader();
     mode = _mode;
   }
 
   void* Set(void* cmd, GLenum _mode) {
     static_cast<ValueType*>(cmd)->Init(_mode);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mode;
 };
 
 COMPILE_ASSERT(sizeof(FrontFace) == 8,
                Sizeof_FrontFace_is_not_8);
 COMPILE_ASSERT(offsetof(FrontFace, header) == 0,
                OffsetOf_FrontFace_header_not_0);
 COMPILE_ASSERT(offsetof(FrontFace, mode) == 4,
                OffsetOf_FrontFace_mode_not_4);
 
@@ skipping 18 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _buffers_shm_id,
       uint32 _buffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _buffers_shm_id, _buffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 buffers_shm_id;
   uint32 buffers_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GenBuffers) == 16,
                Sizeof_GenBuffers_is_not_16);
 COMPILE_ASSERT(offsetof(GenBuffers, header) == 0,
                OffsetOf_GenBuffers_header_not_0);
 COMPILE_ASSERT(offsetof(GenBuffers, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _buffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _buffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _buffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenBuffersImmediate) == 8,
                Sizeof_GenBuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenBuffersImmediate, header) == 0,
                OffsetOf_GenBuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenBuffersImmediate, n) == 4,
                OffsetOf_GenBuffersImmediate_n_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLenum _target) {
     SetHeader();
     target = _target;
   }
 
   void* Set(void* cmd, GLenum _target) {
     static_cast<ValueType*>(cmd)->Init(_target);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
 };
 
 COMPILE_ASSERT(sizeof(GenerateMipmap) == 8,
                Sizeof_GenerateMipmap_is_not_8);
 COMPILE_ASSERT(offsetof(GenerateMipmap, header) == 0,
                OffsetOf_GenerateMipmap_header_not_0);
 COMPILE_ASSERT(offsetof(GenerateMipmap, target) == 4,
                OffsetOf_GenerateMipmap_target_not_4);
 
@@ skipping 20 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _framebuffers_shm_id,
       uint32 _framebuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _framebuffers_shm_id, _framebuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 framebuffers_shm_id;
   uint32 framebuffers_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GenFramebuffers) == 16,
                Sizeof_GenFramebuffers_is_not_16);
 COMPILE_ASSERT(offsetof(GenFramebuffers, header) == 0,
                OffsetOf_GenFramebuffers_header_not_0);
 COMPILE_ASSERT(offsetof(GenFramebuffers, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _framebuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _framebuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _framebuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenFramebuffersImmediate) == 8,
                Sizeof_GenFramebuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, header) == 0,
                OffsetOf_GenFramebuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenFramebuffersImmediate, n) == 4,
                OffsetOf_GenFramebuffersImmediate_n_not_4);
 
@@ skipping 20 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _renderbuffers_shm_id,
       uint32 _renderbuffers_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _renderbuffers_shm_id, _renderbuffers_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 renderbuffers_shm_id;
   uint32 renderbuffers_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GenRenderbuffers) == 16,
                Sizeof_GenRenderbuffers_is_not_16);
 COMPILE_ASSERT(offsetof(GenRenderbuffers, header) == 0,
                OffsetOf_GenRenderbuffers_header_not_0);
 COMPILE_ASSERT(offsetof(GenRenderbuffers, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _renderbuffers, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _renderbuffers) {
     static_cast<ValueType*>(cmd)->Init(_n, _renderbuffers);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenRenderbuffersImmediate) == 8,
                Sizeof_GenRenderbuffersImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, header) == 0,
                OffsetOf_GenRenderbuffersImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenRenderbuffersImmediate, n) == 4,
                OffsetOf_GenRenderbuffersImmediate_n_not_4);
 
@@ skipping 18 matching lines @@
   }
 
   void* Set(
       void* cmd, GLsizei _n, uint32 _textures_shm_id,
       uint32 _textures_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_n, _textures_shm_id, _textures_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
   uint32 textures_shm_id;
   uint32 textures_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GenTextures) == 16,
                Sizeof_GenTextures_is_not_16);
 COMPILE_ASSERT(offsetof(GenTextures, header) == 0,
                OffsetOf_GenTextures_header_not_0);
 COMPILE_ASSERT(offsetof(GenTextures, n) == 4,
@@ skipping 27 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _textures, ComputeDataSize(_n));
   }
 
   void* Set(void* cmd, GLsizei _n, GLuint* _textures) {
     static_cast<ValueType*>(cmd)->Init(_n, _textures);
     const uint32 size = ComputeSize(_n);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 n;
 };
 
 COMPILE_ASSERT(sizeof(GenTexturesImmediate) == 8,
                Sizeof_GenTexturesImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(GenTexturesImmediate, header) == 0,
                OffsetOf_GenTexturesImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(GenTexturesImmediate, n) == 4,
                OffsetOf_GenTexturesImmediate_n_not_4);
 
@@ skipping 35 matching lines @@
       uint32 _size_shm_offset, uint32 _type_shm_id, uint32 _type_shm_offset,
       uint32 _name_shm_id, uint32 _name_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _index, _bufsize, _length_shm_id, _length_shm_offset,
             _size_shm_id, _size_shm_offset, _type_shm_id, _type_shm_offset,
             _name_shm_id, _name_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 index;
   uint32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 size_shm_id;
   uint32 size_shm_offset;
   uint32 type_shm_id;
   uint32 type_shm_offset;
   uint32 name_shm_id;
@@ skipping 65 matching lines @@
       uint32 _size_shm_offset, uint32 _type_shm_id, uint32 _type_shm_offset,
       uint32 _name_shm_id, uint32 _name_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _index, _bufsize, _length_shm_id, _length_shm_offset,
             _size_shm_id, _size_shm_offset, _type_shm_id, _type_shm_offset,
             _name_shm_id, _name_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 index;
   uint32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 size_shm_id;
   uint32 size_shm_offset;
   uint32 type_shm_id;
   uint32 type_shm_offset;
   uint32 name_shm_id;
@@ skipping 57 matching lines @@
       void* cmd, GLuint _program, GLsizei _maxcount, uint32 _count_shm_id,
       uint32 _count_shm_offset, uint32 _shaders_shm_id,
       uint32 _shaders_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _maxcount, _count_shm_id, _count_shm_offset,
             _shaders_shm_id, _shaders_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 maxcount;
   uint32 count_shm_id;
   uint32 count_shm_offset;
   uint32 shaders_shm_id;
   uint32 shaders_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetAttachedShaders) == 28,
                Sizeof_GetAttachedShaders_is_not_28);
@@ skipping 33 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetBooleanv) == 16,
                Sizeof_GetBooleanv_is_not_16);
 COMPILE_ASSERT(offsetof(GetBooleanv, header) == 0,
                OffsetOf_GetBooleanv_header_not_0);
 COMPILE_ASSERT(offsetof(GetBooleanv, pname) == 4,
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetBufferParameteriv) == 20,
                Sizeof_GetBufferParameteriv_is_not_20);
 COMPILE_ASSERT(offsetof(GetBufferParameteriv, header) == 0,
                OffsetOf_GetBufferParameteriv_header_not_0);
@@ skipping 23 matching lines @@
     SetHeader();
     result_shm_id = _result_shm_id;
     result_shm_offset = _result_shm_offset;
   }
 
   void* Set(void* cmd, uint32 _result_shm_id, uint32 _result_shm_offset) {
     static_cast<ValueType*>(cmd)->Init(_result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetError) == 12,
                Sizeof_GetError_is_not_12);
 COMPILE_ASSERT(offsetof(GetError, header) == 0,
                OffsetOf_GetError_header_not_0);
 COMPILE_ASSERT(offsetof(GetError, result_shm_id) == 4,
                OffsetOf_GetError_result_shm_id_not_4);
@@ skipping 21 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetFloatv) == 16,
                Sizeof_GetFloatv_is_not_16);
 COMPILE_ASSERT(offsetof(GetFloatv, header) == 0,
                OffsetOf_GetFloatv_header_not_0);
 COMPILE_ASSERT(offsetof(GetFloatv, pname) == 4,
@@ skipping 29 matching lines @@
 
   void* Set(
       void* cmd, GLenum _target, GLenum _attachment, GLenum _pname,
       uint32 _params_shm_id, uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _attachment, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 attachment;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetFramebufferAttachmentParameteriv) == 24,
                Sizeof_GetFramebufferAttachmentParameteriv_is_not_24);
 COMPILE_ASSERT(offsetof(GetFramebufferAttachmentParameteriv, header) == 0,
@@ skipping 32 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetIntegerv) == 16,
                Sizeof_GetIntegerv_is_not_16);
 COMPILE_ASSERT(offsetof(GetIntegerv, header) == 0,
                OffsetOf_GetIntegerv_header_not_0);
 COMPILE_ASSERT(offsetof(GetIntegerv, pname) == 4,
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _program, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_program, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetProgramiv) == 20,
                Sizeof_GetProgramiv_is_not_20);
 COMPILE_ASSERT(offsetof(GetProgramiv, header) == 0,
                OffsetOf_GetProgramiv_header_not_0);
@@ skipping 36 matching lines @@
       void* cmd, GLuint _program, GLsizei _bufsize, uint32 _length_shm_id,
       uint32 _length_shm_offset, uint32 _infolog_shm_id,
       uint32 _infolog_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _program, _bufsize, _length_shm_id, _length_shm_offset,
             _infolog_shm_id, _infolog_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 infolog_shm_id;
   uint32 infolog_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetProgramInfoLog) == 28,
                Sizeof_GetProgramInfoLog_is_not_28);
@@ skipping 36 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetRenderbufferParameteriv) == 20,
                Sizeof_GetRenderbufferParameteriv_is_not_20);
 COMPILE_ASSERT(offsetof(GetRenderbufferParameteriv, header) == 0,
                OffsetOf_GetRenderbufferParameteriv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _shader, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_shader, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetShaderiv) == 20,
                Sizeof_GetShaderiv_is_not_20);
 COMPILE_ASSERT(offsetof(GetShaderiv, header) == 0,
                OffsetOf_GetShaderiv_header_not_0);
@@ skipping 36 matching lines @@
       void* cmd, GLuint _shader, GLsizei _bufsize, uint32 _length_shm_id,
       uint32 _length_shm_offset, uint32 _infolog_shm_id,
       uint32 _infolog_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shader, _bufsize, _length_shm_id, _length_shm_offset,
             _infolog_shm_id, _infolog_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
   uint32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 infolog_shm_id;
   uint32 infolog_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetShaderInfoLog) == 28,
                Sizeof_GetShaderInfoLog_is_not_28);
@@ skipping 42 matching lines @@
       void* cmd, GLenum _shadertype, GLenum _precisiontype,
       uint32 _range_shm_id, uint32 _range_shm_offset, uint32 _precision_shm_id,
       uint32 _precision_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shadertype, _precisiontype, _range_shm_id, _range_shm_offset,
             _precision_shm_id, _precision_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shadertype;
   uint32 precisiontype;
   uint32 range_shm_id;
   uint32 range_shm_offset;
   uint32 precision_shm_id;
   uint32 precision_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetShaderPrecisionFormat) == 28,
                Sizeof_GetShaderPrecisionFormat_is_not_28);
@@ skipping 42 matching lines @@
       void* cmd, GLuint _shader, GLsizei _bufsize, uint32 _length_shm_id,
       uint32 _length_shm_offset, uint32 _source_shm_id,
       uint32 _source_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shader, _bufsize, _length_shm_id, _length_shm_offset,
             _source_shm_id, _source_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
   uint32 bufsize;
   uint32 length_shm_id;
   uint32 length_shm_offset;
   uint32 source_shm_id;
   uint32 source_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetShaderSource) == 28,
                Sizeof_GetShaderSource_is_not_28);
@@ skipping 28 matching lines @@
   void Init(GLenum _name) {
     SetHeader();
     name = _name;
   }
 
   void* Set(void* cmd, GLenum _name) {
     static_cast<ValueType*>(cmd)->Init(_name);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 name;
 };
 
 COMPILE_ASSERT(sizeof(GetString) == 8,
                Sizeof_GetString_is_not_8);
 COMPILE_ASSERT(offsetof(GetString, header) == 0,
                OffsetOf_GetString_header_not_0);
 COMPILE_ASSERT(offsetof(GetString, name) == 4,
                OffsetOf_GetString_name_not_4);
 
@@ skipping 21 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetTexParameterfv) == 20,
                Sizeof_GetTexParameterfv_is_not_20);
 COMPILE_ASSERT(offsetof(GetTexParameterfv, header) == 0,
                OffsetOf_GetTexParameterfv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetTexParameteriv) == 20,
                Sizeof_GetTexParameteriv_is_not_20);
 COMPILE_ASSERT(offsetof(GetTexParameteriv, header) == 0,
                OffsetOf_GetTexParameteriv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 location;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetUniformfv) == 20,
                Sizeof_GetUniformfv_is_not_20);
 COMPILE_ASSERT(offsetof(GetUniformfv, header) == 0,
                OffsetOf_GetUniformfv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _program, GLint _location, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_program, _location, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 location;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetUniformiv) == 20,
                Sizeof_GetUniformiv_is_not_20);
 COMPILE_ASSERT(offsetof(GetUniformiv, header) == 0,
                OffsetOf_GetUniformiv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _index, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_index, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 index;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetVertexAttribfv) == 20,
                Sizeof_GetVertexAttribfv_is_not_20);
 COMPILE_ASSERT(offsetof(GetVertexAttribfv, header) == 0,
                OffsetOf_GetVertexAttribfv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _index, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_index, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 index;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetVertexAttribiv) == 20,
                Sizeof_GetVertexAttribiv_is_not_20);
 COMPILE_ASSERT(offsetof(GetVertexAttribiv, header) == 0,
                OffsetOf_GetVertexAttribiv_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _index, GLenum _pname, uint32 _pointer_shm_id,
       uint32 _pointer_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_index, _pname, _pointer_shm_id, _pointer_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 index;
   uint32 pname;
   uint32 pointer_shm_id;
   uint32 pointer_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(GetVertexAttribPointerv) == 20,
                Sizeof_GetVertexAttribPointerv_is_not_20);
 COMPILE_ASSERT(offsetof(GetVertexAttribPointerv, header) == 0,
                OffsetOf_GetVertexAttribPointerv_header_not_0);
@@ skipping 23 matching lines @@
     SetHeader();
     target = _target;
     mode = _mode;
   }
 
   void* Set(void* cmd, GLenum _target, GLenum _mode) {
     static_cast<ValueType*>(cmd)->Init(_target, _mode);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 mode;
 };
 
 COMPILE_ASSERT(sizeof(Hint) == 12,
                Sizeof_Hint_is_not_12);
 COMPILE_ASSERT(offsetof(Hint, header) == 0,
                OffsetOf_Hint_header_not_0);
 COMPILE_ASSERT(offsetof(Hint, target) == 4,
                OffsetOf_Hint_target_not_4);
@@ skipping 21 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _buffer, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_buffer, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 buffer;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsBuffer) == 16,
                Sizeof_IsBuffer_is_not_16);
 COMPILE_ASSERT(offsetof(IsBuffer, header) == 0,
                OffsetOf_IsBuffer_header_not_0);
 COMPILE_ASSERT(offsetof(IsBuffer, buffer) == 4,
@@ skipping 24 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _cap, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_cap, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 cap;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsEnabled) == 16,
                Sizeof_IsEnabled_is_not_16);
 COMPILE_ASSERT(offsetof(IsEnabled, header) == 0,
                OffsetOf_IsEnabled_header_not_0);
 COMPILE_ASSERT(offsetof(IsEnabled, cap) == 4,
@@ skipping 25 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _framebuffer, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_framebuffer, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 framebuffer;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsFramebuffer) == 16,
                Sizeof_IsFramebuffer_is_not_16);
 COMPILE_ASSERT(offsetof(IsFramebuffer, header) == 0,
                OffsetOf_IsFramebuffer_header_not_0);
 COMPILE_ASSERT(offsetof(IsFramebuffer, framebuffer) == 4,
@@ skipping 25 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _program, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_program, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsProgram) == 16,
                Sizeof_IsProgram_is_not_16);
 COMPILE_ASSERT(offsetof(IsProgram, header) == 0,
                OffsetOf_IsProgram_header_not_0);
 COMPILE_ASSERT(offsetof(IsProgram, program) == 4,
@@ skipping 25 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _renderbuffer, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_renderbuffer, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 renderbuffer;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsRenderbuffer) == 16,
                Sizeof_IsRenderbuffer_is_not_16);
 COMPILE_ASSERT(offsetof(IsRenderbuffer, header) == 0,
                OffsetOf_IsRenderbuffer_header_not_0);
 COMPILE_ASSERT(offsetof(IsRenderbuffer, renderbuffer) == 4,
@@ skipping 24 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _shader, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_shader, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsShader) == 16,
                Sizeof_IsShader_is_not_16);
 COMPILE_ASSERT(offsetof(IsShader, header) == 0,
                OffsetOf_IsShader_header_not_0);
 COMPILE_ASSERT(offsetof(IsShader, shader) == 4,
@@ skipping 25 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _texture, uint32 _result_shm_id,
       uint32 _result_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_texture, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 texture;
   uint32 result_shm_id;
   uint32 result_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(IsTexture) == 16,
                Sizeof_IsTexture_is_not_16);
 COMPILE_ASSERT(offsetof(IsTexture, header) == 0,
                OffsetOf_IsTexture_header_not_0);
 COMPILE_ASSERT(offsetof(IsTexture, texture) == 4,
@@ skipping 19 matching lines @@
   void Init(GLfloat _width) {
     SetHeader();
     width = _width;
   }
 
   void* Set(void* cmd, GLfloat _width) {
     static_cast<ValueType*>(cmd)->Init(_width);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float width;
 };
 
 COMPILE_ASSERT(sizeof(LineWidth) == 8,
                Sizeof_LineWidth_is_not_8);
 COMPILE_ASSERT(offsetof(LineWidth, header) == 0,
                OffsetOf_LineWidth_header_not_0);
 COMPILE_ASSERT(offsetof(LineWidth, width) == 4,
                OffsetOf_LineWidth_width_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
   }
 
   void* Set(void* cmd, GLuint _program) {
     static_cast<ValueType*>(cmd)->Init(_program);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
 };
 
 COMPILE_ASSERT(sizeof(LinkProgram) == 8,
                Sizeof_LinkProgram_is_not_8);
 COMPILE_ASSERT(offsetof(LinkProgram, header) == 0,
                OffsetOf_LinkProgram_header_not_0);
 COMPILE_ASSERT(offsetof(LinkProgram, program) == 4,
                OffsetOf_LinkProgram_program_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     pname = _pname;
     param = _param;
   }
 
   void* Set(void* cmd, GLenum _pname, GLint _param) {
     static_cast<ValueType*>(cmd)->Init(_pname, _param);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 pname;
   uint32 param;
 };
 
 COMPILE_ASSERT(sizeof(PixelStorei) == 12,
                Sizeof_PixelStorei_is_not_12);
 COMPILE_ASSERT(offsetof(PixelStorei, header) == 0,
                OffsetOf_PixelStorei_header_not_0);
 COMPILE_ASSERT(offsetof(PixelStorei, pname) == 4,
                OffsetOf_PixelStorei_pname_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     factor = _factor;
     units = _units;
   }
 
   void* Set(void* cmd, GLfloat _factor, GLfloat _units) {
     static_cast<ValueType*>(cmd)->Init(_factor, _units);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float factor;
   float units;
 };
 
 COMPILE_ASSERT(sizeof(PolygonOffset) == 12,
                Sizeof_PolygonOffset_is_not_12);
 COMPILE_ASSERT(offsetof(PolygonOffset, header) == 0,
                OffsetOf_PolygonOffset_header_not_0);
 COMPILE_ASSERT(offsetof(PolygonOffset, factor) == 4,
                OffsetOf_PolygonOffset_factor_not_4);
@@ skipping 31 matching lines @@
       void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height,
       GLenum _format, GLenum _type, uint32 _pixels_shm_id,
       uint32 _pixels_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _x, _y, _width, _height, _format, _type, _pixels_shm_id,
             _pixels_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 x;
   uint32 y;
   uint32 width;
   uint32 height;
   uint32 format;
   uint32 type;
   uint32 pixels_shm_id;
   uint32 pixels_shm_offset;
 };
 
@@ skipping 42 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _internalformat, GLsizei _width,
       GLsizei _height) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _internalformat, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 internalformat;
   uint32 width;
   uint32 height;
 };
 
 COMPILE_ASSERT(sizeof(RenderbufferStorage) == 20,
                Sizeof_RenderbufferStorage_is_not_20);
 COMPILE_ASSERT(offsetof(RenderbufferStorage, header) == 0,
                OffsetOf_RenderbufferStorage_header_not_0);
@@ skipping 23 matching lines @@
     SetHeader();
     value = _value;
     invert = _invert;
   }
 
   void* Set(void* cmd, GLclampf _value, GLboolean _invert) {
     static_cast<ValueType*>(cmd)->Init(_value, _invert);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   float value;
   uint32 invert;
 };
 
 COMPILE_ASSERT(sizeof(SampleCoverage) == 12,
                Sizeof_SampleCoverage_is_not_12);
 COMPILE_ASSERT(offsetof(SampleCoverage, header) == 0,
                OffsetOf_SampleCoverage_header_not_0);
 COMPILE_ASSERT(offsetof(SampleCoverage, value) == 4,
                OffsetOf_SampleCoverage_value_not_4);
@@ skipping 19 matching lines @@
     y = _y;
     width = _width;
     height = _height;
   }
 
   void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 x;
   uint32 y;
   uint32 width;
   uint32 height;
 };
 
 COMPILE_ASSERT(sizeof(Scissor) == 20,
                Sizeof_Scissor_is_not_20);
 COMPILE_ASSERT(offsetof(Scissor, header) == 0,
                OffsetOf_Scissor_header_not_0);
@@ skipping 32 matching lines @@
 
   void* Set(
       void* cmd, GLuint _shader, GLsizei _count, uint32 _data_shm_id,
       uint32 _data_shm_offset, uint32 _data_size) {
     static_cast<ValueType*>(
         cmd)->Init(
             _shader, _count, _data_shm_id, _data_shm_offset, _data_size);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
   uint32 count;
   uint32 data_shm_id;
   uint32 data_shm_offset;
   uint32 data_size;
 };
 
 COMPILE_ASSERT(sizeof(ShaderSource) == 24,
                Sizeof_ShaderSource_is_not_24);
 COMPILE_ASSERT(offsetof(ShaderSource, header) == 0,
@@ skipping 31 matching lines @@
     count = _count;
     data_size = _data_size;
   }
 
   void* Set(void* cmd, GLuint _shader, GLsizei _count, uint32 _data_size) {
     uint32 total_size = ComputeSize(_data_size);
     static_cast<ValueType*>(cmd)->Init(_shader, _count, _data_size);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 shader;
   uint32 count;
   uint32 data_size;
 };
 
 COMPILE_ASSERT(sizeof(ShaderSourceImmediate) == 16,
                Sizeof_ShaderSourceImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(ShaderSourceImmediate, header) == 0,
                OffsetOf_ShaderSourceImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(ShaderSourceImmediate, shader) == 4,
@@ skipping 21 matching lines @@
     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);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 func;
   uint32 ref;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(StencilFunc) == 16,
                Sizeof_StencilFunc_is_not_16);
 COMPILE_ASSERT(offsetof(StencilFunc, header) == 0,
                OffsetOf_StencilFunc_header_not_0);
 COMPILE_ASSERT(offsetof(StencilFunc, func) == 4,
@@ skipping 22 matching lines @@
     func = _func;
     ref = _ref;
     mask = _mask;
   }
 
   void* Set(void* cmd, GLenum _face, GLenum _func, GLint _ref, GLuint _mask) {
     static_cast<ValueType*>(cmd)->Init(_face, _func, _ref, _mask);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 face;
   uint32 func;
   uint32 ref;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(StencilFuncSeparate) == 20,
                Sizeof_StencilFuncSeparate_is_not_20);
 COMPILE_ASSERT(offsetof(StencilFuncSeparate, header) == 0,
                OffsetOf_StencilFuncSeparate_header_not_0);
@@ skipping 22 matching lines @@
   void Init(GLuint _mask) {
     SetHeader();
     mask = _mask;
   }
 
   void* Set(void* cmd, GLuint _mask) {
     static_cast<ValueType*>(cmd)->Init(_mask);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(StencilMask) == 8,
                Sizeof_StencilMask_is_not_8);
 COMPILE_ASSERT(offsetof(StencilMask, header) == 0,
                OffsetOf_StencilMask_header_not_0);
 COMPILE_ASSERT(offsetof(StencilMask, mask) == 4,
                OffsetOf_StencilMask_mask_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     face = _face;
     mask = _mask;
   }
 
   void* Set(void* cmd, GLenum _face, GLuint _mask) {
     static_cast<ValueType*>(cmd)->Init(_face, _mask);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 face;
   uint32 mask;
 };
 
 COMPILE_ASSERT(sizeof(StencilMaskSeparate) == 12,
                Sizeof_StencilMaskSeparate_is_not_12);
 COMPILE_ASSERT(offsetof(StencilMaskSeparate, header) == 0,
                OffsetOf_StencilMaskSeparate_header_not_0);
 COMPILE_ASSERT(offsetof(StencilMaskSeparate, face) == 4,
                OffsetOf_StencilMaskSeparate_face_not_4);
@@ skipping 18 matching lines @@
     fail = _fail;
     zfail = _zfail;
     zpass = _zpass;
   }
 
   void* Set(void* cmd, GLenum _fail, GLenum _zfail, GLenum _zpass) {
     static_cast<ValueType*>(cmd)->Init(_fail, _zfail, _zpass);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 fail;
   uint32 zfail;
   uint32 zpass;
 };
 
 COMPILE_ASSERT(sizeof(StencilOp) == 16,
                Sizeof_StencilOp_is_not_16);
 COMPILE_ASSERT(offsetof(StencilOp, header) == 0,
                OffsetOf_StencilOp_header_not_0);
 COMPILE_ASSERT(offsetof(StencilOp, fail) == 4,
@@ skipping 23 matching lines @@
     zfail = _zfail;
     zpass = _zpass;
   }
 
   void* Set(
       void* cmd, GLenum _face, GLenum _fail, GLenum _zfail, GLenum _zpass) {
     static_cast<ValueType*>(cmd)->Init(_face, _fail, _zfail, _zpass);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 face;
   uint32 fail;
   uint32 zfail;
   uint32 zpass;
 };
 
 COMPILE_ASSERT(sizeof(StencilOpSeparate) == 20,
                Sizeof_StencilOpSeparate_is_not_20);
 COMPILE_ASSERT(offsetof(StencilOpSeparate, header) == 0,
                OffsetOf_StencilOpSeparate_header_not_0);
@@ skipping 40 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLint _internalformat,
       GLsizei _width, GLsizei _height, GLint _border, GLenum _format,
       GLenum _type, uint32 _pixels_shm_id, uint32 _pixels_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border, _format,
             _type, _pixels_shm_id, _pixels_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 internalformat;
   uint32 width;
   uint32 height;
   uint32 border;
   uint32 format;
   uint32 type;
   uint32 pixels_shm_id;
   uint32 pixels_shm_offset;
@@ skipping 59 matching lines @@
       GLsizei _width, GLsizei _height, GLint _border, GLenum _format,
       GLenum _type) {
     uint32 total_size = 0;  // TODO(gman): get correct size.
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _internalformat, _width, _height, _border, _format,
             _type);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 internalformat;
   uint32 width;
   uint32 height;
   uint32 border;
   uint32 format;
   uint32 type;
 };
 
@@ skipping 36 matching lines @@
     target = _target;
     pname = _pname;
     param = _param;
   }
 
   void* Set(void* cmd, GLenum _target, GLenum _pname, GLfloat _param) {
     static_cast<ValueType*>(cmd)->Init(_target, _pname, _param);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   float param;
 };
 
 COMPILE_ASSERT(sizeof(TexParameterf) == 16,
                Sizeof_TexParameterf_is_not_16);
 COMPILE_ASSERT(offsetof(TexParameterf, header) == 0,
                OffsetOf_TexParameterf_header_not_0);
 COMPILE_ASSERT(offsetof(TexParameterf, target) == 4,
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(TexParameterfv) == 20,
                Sizeof_TexParameterfv_is_not_20);
 COMPILE_ASSERT(offsetof(TexParameterfv, header) == 0,
                OffsetOf_TexParameterfv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _params, ComputeDataSize());
   }
 
   void* Set(void* cmd, GLenum _target, GLenum _pname, const GLfloat* _params) {
     static_cast<ValueType*>(cmd)->Init(_target, _pname, _params);
     const uint32 size = ComputeSize();
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
 };
 
 COMPILE_ASSERT(sizeof(TexParameterfvImmediate) == 12,
                Sizeof_TexParameterfvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, header) == 0,
                OffsetOf_TexParameterfvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(TexParameterfvImmediate, target) == 4,
                OffsetOf_TexParameterfvImmediate_target_not_4);
@@ skipping 18 matching lines @@
     target = _target;
     pname = _pname;
     param = _param;
   }
 
   void* Set(void* cmd, GLenum _target, GLenum _pname, GLint _param) {
     static_cast<ValueType*>(cmd)->Init(_target, _pname, _param);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 param;
 };
 
 COMPILE_ASSERT(sizeof(TexParameteri) == 16,
                Sizeof_TexParameteri_is_not_16);
 COMPILE_ASSERT(offsetof(TexParameteri, header) == 0,
                OffsetOf_TexParameteri_header_not_0);
 COMPILE_ASSERT(offsetof(TexParameteri, target) == 4,
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
       uint32 _params_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
   uint32 params_shm_id;
   uint32 params_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(TexParameteriv) == 20,
                Sizeof_TexParameteriv_is_not_20);
 COMPILE_ASSERT(offsetof(TexParameteriv, header) == 0,
                OffsetOf_TexParameteriv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _params, ComputeDataSize());
   }
 
   void* Set(void* cmd, GLenum _target, GLenum _pname, const GLint* _params) {
     static_cast<ValueType*>(cmd)->Init(_target, _pname, _params);
     const uint32 size = ComputeSize();
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 pname;
 };
 
 COMPILE_ASSERT(sizeof(TexParameterivImmediate) == 12,
                Sizeof_TexParameterivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(TexParameterivImmediate, header) == 0,
                OffsetOf_TexParameterivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(TexParameterivImmediate, target) == 4,
                OffsetOf_TexParameterivImmediate_target_not_4);
@@ skipping 34 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset,
       GLsizei _width, GLsizei _height, GLenum _format, GLenum _type,
       uint32 _pixels_shm_id, uint32 _pixels_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _type, _pixels_shm_id, _pixels_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 xoffset;
   uint32 yoffset;
   uint32 width;
   uint32 height;
   uint32 format;
   uint32 type;
   uint32 pixels_shm_id;
   uint32 pixels_shm_offset;
@@ skipping 58 matching lines @@
       void* cmd, GLenum _target, GLint _level, GLint _xoffset, GLint _yoffset,
       GLsizei _width, GLsizei _height, GLenum _format, GLenum _type) {
     uint32 total_size = 0;  // TODO(gman): get correct size
     static_cast<ValueType*>(
         cmd)->Init(
             _target, _level, _xoffset, _yoffset, _width, _height, _format,
             _type);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 target;
   uint32 level;
   uint32 xoffset;
   uint32 yoffset;
   uint32 width;
   uint32 height;
   uint32 format;
   uint32 type;
 };
 
@@ skipping 35 matching lines @@
     SetHeader();
     location = _location;
     x = _x;
   }
 
   void* Set(void* cmd, GLint _location, GLfloat _x) {
     static_cast<ValueType*>(cmd)->Init(_location, _x);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   float x;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1f) == 12,
                Sizeof_Uniform1f_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1f, header) == 0,
                OffsetOf_Uniform1f_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1f, location) == 4,
                OffsetOf_Uniform1f_location_not_4);
@@ skipping 24 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1fv) == 20,
                Sizeof_Uniform1fv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform1fv, header) == 0,
                OffsetOf_Uniform1fv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1fvImmediate) == 12,
                Sizeof_Uniform1fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, header) == 0,
                OffsetOf_Uniform1fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1fvImmediate, location) == 4,
                OffsetOf_Uniform1fvImmediate_location_not_4);
@@ skipping 17 matching lines @@
     SetHeader();
     location = _location;
     x = _x;
   }
 
   void* Set(void* cmd, GLint _location, GLint _x) {
     static_cast<ValueType*>(cmd)->Init(_location, _x);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 x;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1i) == 12,
                Sizeof_Uniform1i_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1i, header) == 0,
                OffsetOf_Uniform1i_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1i, location) == 4,
                OffsetOf_Uniform1i_location_not_4);
@@ skipping 24 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1iv) == 20,
                Sizeof_Uniform1iv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform1iv, header) == 0,
                OffsetOf_Uniform1iv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform1ivImmediate) == 12,
                Sizeof_Uniform1ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, header) == 0,
                OffsetOf_Uniform1ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform1ivImmediate, location) == 4,
                OffsetOf_Uniform1ivImmediate_location_not_4);
@@ skipping 18 matching lines @@
     location = _location;
     x = _x;
     y = _y;
   }
 
   void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   float x;
   float y;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2f) == 16,
                Sizeof_Uniform2f_is_not_16);
 COMPILE_ASSERT(offsetof(Uniform2f, header) == 0,
                OffsetOf_Uniform2f_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2f, location) == 4,
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2fv) == 20,
                Sizeof_Uniform2fv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform2fv, header) == 0,
                OffsetOf_Uniform2fv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2fvImmediate) == 12,
                Sizeof_Uniform2fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, header) == 0,
                OffsetOf_Uniform2fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2fvImmediate, location) == 4,
                OffsetOf_Uniform2fvImmediate_location_not_4);
@@ skipping 18 matching lines @@
     location = _location;
     x = _x;
     y = _y;
   }
 
   void* Set(void* cmd, GLint _location, GLint _x, GLint _y) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 x;
   uint32 y;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2i) == 16,
                Sizeof_Uniform2i_is_not_16);
 COMPILE_ASSERT(offsetof(Uniform2i, header) == 0,
                OffsetOf_Uniform2i_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2i, location) == 4,
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2iv) == 20,
                Sizeof_Uniform2iv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform2iv, header) == 0,
                OffsetOf_Uniform2iv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform2ivImmediate) == 12,
                Sizeof_Uniform2ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, header) == 0,
                OffsetOf_Uniform2ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform2ivImmediate, location) == 4,
                OffsetOf_Uniform2ivImmediate_location_not_4);
@@ skipping 19 matching lines @@
     x = _x;
     y = _y;
     z = _z;
   }
 
   void* Set(void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   float x;
   float y;
   float z;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3f) == 20,
                Sizeof_Uniform3f_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform3f, header) == 0,
                OffsetOf_Uniform3f_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3fv) == 20,
                Sizeof_Uniform3fv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform3fv, header) == 0,
                OffsetOf_Uniform3fv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3fvImmediate) == 12,
                Sizeof_Uniform3fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, header) == 0,
                OffsetOf_Uniform3fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform3fvImmediate, location) == 4,
                OffsetOf_Uniform3fvImmediate_location_not_4);
@@ skipping 19 matching lines @@
     x = _x;
     y = _y;
     z = _z;
   }
 
   void* Set(void* cmd, GLint _location, GLint _x, GLint _y, GLint _z) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 x;
   uint32 y;
   uint32 z;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3i) == 20,
                Sizeof_Uniform3i_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform3i, header) == 0,
                OffsetOf_Uniform3i_header_not_0);
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3iv) == 20,
                Sizeof_Uniform3iv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform3iv, header) == 0,
                OffsetOf_Uniform3iv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform3ivImmediate) == 12,
                Sizeof_Uniform3ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, header) == 0,
                OffsetOf_Uniform3ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform3ivImmediate, location) == 4,
                OffsetOf_Uniform3ivImmediate_location_not_4);
@@ skipping 22 matching lines @@
     w = _w;
   }
 
   void* Set(
       void* cmd, GLint _location, GLfloat _x, GLfloat _y, GLfloat _z,
       GLfloat _w) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   float x;
   float y;
   float z;
   float w;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4f) == 24,
                Sizeof_Uniform4f_is_not_24);
 COMPILE_ASSERT(offsetof(Uniform4f, header) == 0,
@@ skipping 33 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4fv) == 20,
                Sizeof_Uniform4fv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform4fv, header) == 0,
                OffsetOf_Uniform4fv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLfloat* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4fvImmediate) == 12,
                Sizeof_Uniform4fvImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, header) == 0,
                OffsetOf_Uniform4fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform4fvImmediate, location) == 4,
                OffsetOf_Uniform4fvImmediate_location_not_4);
@@ skipping 21 matching lines @@
     z = _z;
     w = _w;
   }
 
   void* Set(
       void* cmd, GLint _location, GLint _x, GLint _y, GLint _z, GLint _w) {
     static_cast<ValueType*>(cmd)->Init(_location, _x, _y, _z, _w);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 x;
   uint32 y;
   uint32 z;
   uint32 w;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4i) == 24,
                Sizeof_Uniform4i_is_not_24);
 COMPILE_ASSERT(offsetof(Uniform4i, header) == 0,
@@ skipping 33 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, uint32 _v_shm_id,
       uint32 _v_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_location, _count, _v_shm_id, _v_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 v_shm_id;
   uint32 v_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4iv) == 20,
                Sizeof_Uniform4iv_is_not_20);
 COMPILE_ASSERT(offsetof(Uniform4iv, header) == 0,
                OffsetOf_Uniform4iv_header_not_0);
@@ skipping 32 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _v, ComputeDataSize(_count));
   }
 
   void* Set(void* cmd, GLint _location, GLsizei _count, const GLint* _v) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _v);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
 };
 
 COMPILE_ASSERT(sizeof(Uniform4ivImmediate) == 12,
                Sizeof_Uniform4ivImmediate_is_not_12);
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, header) == 0,
                OffsetOf_Uniform4ivImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(Uniform4ivImmediate, location) == 4,
                OffsetOf_Uniform4ivImmediate_location_not_4);
@@ skipping 26 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       uint32 _value_shm_id, uint32 _value_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _location, _count, _transpose, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 transpose;
   uint32 value_shm_id;
   uint32 value_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix2fv) == 24,
                Sizeof_UniformMatrix2fv_is_not_24);
 COMPILE_ASSERT(offsetof(UniformMatrix2fv, header) == 0,
@@ skipping 40 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       const GLfloat* _value) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 transpose;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix2fvImmediate) == 16,
                Sizeof_UniformMatrix2fvImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, header) == 0,
                OffsetOf_UniformMatrix2fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix2fvImmediate, location) == 4,
@@ skipping 29 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       uint32 _value_shm_id, uint32 _value_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _location, _count, _transpose, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 transpose;
   uint32 value_shm_id;
   uint32 value_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix3fv) == 24,
                Sizeof_UniformMatrix3fv_is_not_24);
 COMPILE_ASSERT(offsetof(UniformMatrix3fv, header) == 0,
@@ skipping 40 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       const GLfloat* _value) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 transpose;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix3fvImmediate) == 16,
                Sizeof_UniformMatrix3fvImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, header) == 0,
                OffsetOf_UniformMatrix3fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix3fvImmediate, location) == 4,
@@ skipping 29 matching lines @@
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       uint32 _value_shm_id, uint32 _value_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(
             _location, _count, _transpose, _value_shm_id, _value_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 transpose;
   uint32 value_shm_id;
   uint32 value_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix4fv) == 24,
                Sizeof_UniformMatrix4fv_is_not_24);
 COMPILE_ASSERT(offsetof(UniformMatrix4fv, header) == 0,
@@ skipping 40 matching lines @@
   }
 
   void* Set(
       void* cmd, GLint _location, GLsizei _count, GLboolean _transpose,
       const GLfloat* _value) {
     static_cast<ValueType*>(cmd)->Init(_location, _count, _transpose, _value);
     const uint32 size = ComputeSize(_count);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 location;
   uint32 count;
   uint32 transpose;
 };
 
 COMPILE_ASSERT(sizeof(UniformMatrix4fvImmediate) == 16,
                Sizeof_UniformMatrix4fvImmediate_is_not_16);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, header) == 0,
                OffsetOf_UniformMatrix4fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(UniformMatrix4fvImmediate, location) == 4,
@@ skipping 19 matching lines @@
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
   }
 
   void* Set(void* cmd, GLuint _program) {
     static_cast<ValueType*>(cmd)->Init(_program);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
 };
 
 COMPILE_ASSERT(sizeof(UseProgram) == 8,
                Sizeof_UseProgram_is_not_8);
 COMPILE_ASSERT(offsetof(UseProgram, header) == 0,
                OffsetOf_UseProgram_header_not_0);
 COMPILE_ASSERT(offsetof(UseProgram, program) == 4,
                OffsetOf_UseProgram_program_not_4);
 
@@ skipping 13 matching lines @@
   void Init(GLuint _program) {
     SetHeader();
     program = _program;
   }
 
   void* Set(void* cmd, GLuint _program) {
     static_cast<ValueType*>(cmd)->Init(_program);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 program;
 };
 
 COMPILE_ASSERT(sizeof(ValidateProgram) == 8,
                Sizeof_ValidateProgram_is_not_8);
 COMPILE_ASSERT(offsetof(ValidateProgram, header) == 0,
                OffsetOf_ValidateProgram_header_not_0);
 COMPILE_ASSERT(offsetof(ValidateProgram, program) == 4,
                OffsetOf_ValidateProgram_program_not_4);
 
@@ skipping 14 matching lines @@
     SetHeader();
     indx = _indx;
     x = _x;
   }
 
   void* Set(void* cmd, GLuint _indx, GLfloat _x) {
     static_cast<ValueType*>(cmd)->Init(_indx, _x);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   float x;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib1f) == 12,
                Sizeof_VertexAttrib1f_is_not_12);
 COMPILE_ASSERT(offsetof(VertexAttrib1f, header) == 0,
                OffsetOf_VertexAttrib1f_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib1f, indx) == 4,
                OffsetOf_VertexAttrib1f_indx_not_4);
@@ skipping 21 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _indx, uint32 _values_shm_id,
       uint32 _values_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_indx, _values_shm_id, _values_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   uint32 values_shm_id;
   uint32 values_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib1fv) == 16,
                Sizeof_VertexAttrib1fv_is_not_16);
 COMPILE_ASSERT(offsetof(VertexAttrib1fv, header) == 0,
                OffsetOf_VertexAttrib1fv_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib1fv, indx) == 4,
@@ skipping 28 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _values, ComputeDataSize());
   }
 
   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
     static_cast<ValueType*>(cmd)->Init(_indx, _values);
     const uint32 size = ComputeSize();
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib1fvImmediate) == 8,
                Sizeof_VertexAttrib1fvImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, header) == 0,
                OffsetOf_VertexAttrib1fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib1fvImmediate, indx) == 4,
                OffsetOf_VertexAttrib1fvImmediate_indx_not_4);
 
@@ skipping 15 matching lines @@
     indx = _indx;
     x = _x;
     y = _y;
   }
 
   void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y) {
     static_cast<ValueType*>(cmd)->Init(_indx, _x, _y);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   float x;
   float y;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib2f) == 16,
                Sizeof_VertexAttrib2f_is_not_16);
 COMPILE_ASSERT(offsetof(VertexAttrib2f, header) == 0,
                OffsetOf_VertexAttrib2f_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib2f, indx) == 4,
@@ skipping 24 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _indx, uint32 _values_shm_id,
       uint32 _values_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_indx, _values_shm_id, _values_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   uint32 values_shm_id;
   uint32 values_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib2fv) == 16,
                Sizeof_VertexAttrib2fv_is_not_16);
 COMPILE_ASSERT(offsetof(VertexAttrib2fv, header) == 0,
                OffsetOf_VertexAttrib2fv_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib2fv, indx) == 4,
@@ skipping 28 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _values, ComputeDataSize());
   }
 
   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
     static_cast<ValueType*>(cmd)->Init(_indx, _values);
     const uint32 size = ComputeSize();
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib2fvImmediate) == 8,
                Sizeof_VertexAttrib2fvImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, header) == 0,
                OffsetOf_VertexAttrib2fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib2fvImmediate, indx) == 4,
                OffsetOf_VertexAttrib2fvImmediate_indx_not_4);
 
@@ skipping 16 matching lines @@
     x = _x;
     y = _y;
     z = _z;
   }
 
   void* Set(void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z) {
     static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   float x;
   float y;
   float z;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib3f) == 20,
                Sizeof_VertexAttrib3f_is_not_20);
 COMPILE_ASSERT(offsetof(VertexAttrib3f, header) == 0,
                OffsetOf_VertexAttrib3f_header_not_0);
@@ skipping 27 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _indx, uint32 _values_shm_id,
       uint32 _values_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_indx, _values_shm_id, _values_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   uint32 values_shm_id;
   uint32 values_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib3fv) == 16,
                Sizeof_VertexAttrib3fv_is_not_16);
 COMPILE_ASSERT(offsetof(VertexAttrib3fv, header) == 0,
                OffsetOf_VertexAttrib3fv_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib3fv, indx) == 4,
@@ skipping 28 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _values, ComputeDataSize());
   }
 
   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
     static_cast<ValueType*>(cmd)->Init(_indx, _values);
     const uint32 size = ComputeSize();
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib3fvImmediate) == 8,
                Sizeof_VertexAttrib3fvImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, header) == 0,
                OffsetOf_VertexAttrib3fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib3fvImmediate, indx) == 4,
                OffsetOf_VertexAttrib3fvImmediate_indx_not_4);
 
@@ skipping 19 matching lines @@
     w = _w;
   }
 
   void* Set(
       void* cmd, GLuint _indx, GLfloat _x, GLfloat _y, GLfloat _z,
       GLfloat _w) {
     static_cast<ValueType*>(cmd)->Init(_indx, _x, _y, _z, _w);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   float x;
   float y;
   float z;
   float w;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib4f) == 24,
                Sizeof_VertexAttrib4f_is_not_24);
 COMPILE_ASSERT(offsetof(VertexAttrib4f, header) == 0,
@@ skipping 30 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _indx, uint32 _values_shm_id,
       uint32 _values_shm_offset) {
     static_cast<ValueType*>(
         cmd)->Init(_indx, _values_shm_id, _values_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   uint32 values_shm_id;
   uint32 values_shm_offset;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib4fv) == 16,
                Sizeof_VertexAttrib4fv_is_not_16);
 COMPILE_ASSERT(offsetof(VertexAttrib4fv, header) == 0,
                OffsetOf_VertexAttrib4fv_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib4fv, indx) == 4,
@@ skipping 28 matching lines @@
     memcpy(ImmediateDataAddress(this),
            _values, ComputeDataSize());
   }
 
   void* Set(void* cmd, GLuint _indx, const GLfloat* _values) {
     static_cast<ValueType*>(cmd)->Init(_indx, _values);
     const uint32 size = ComputeSize();
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, size);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttrib4fvImmediate) == 8,
                Sizeof_VertexAttrib4fvImmediate_is_not_8);
 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, header) == 0,
                OffsetOf_VertexAttrib4fvImmediate_header_not_0);
 COMPILE_ASSERT(offsetof(VertexAttrib4fvImmediate, indx) == 4,
                OffsetOf_VertexAttrib4fvImmediate_indx_not_4);
 
@@ skipping 23 matching lines @@
   }
 
   void* Set(
       void* cmd, GLuint _indx, GLint _size, GLenum _type, GLboolean _normalized,
       GLsizei _stride, GLuint _offset) {
     static_cast<ValueType*>(
         cmd)->Init(_indx, _size, _type, _normalized, _stride, _offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 indx;
   uint32 size;
   uint32 type;
   uint32 normalized;
   uint32 stride;
   uint32 offset;
 };
 
 COMPILE_ASSERT(sizeof(VertexAttribPointer) == 28,
                Sizeof_VertexAttribPointer_is_not_28);
@@ skipping 31 matching lines @@
     y = _y;
     width = _width;
     height = _height;
   }
 
   void* Set(void* cmd, GLint _x, GLint _y, GLsizei _width, GLsizei _height) {
     static_cast<ValueType*>(cmd)->Init(_x, _y, _width, _height);
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
   uint32 x;
   uint32 y;
   uint32 width;
   uint32 height;
 };
 
 COMPILE_ASSERT(sizeof(Viewport) == 20,
                Sizeof_Viewport_is_not_20);
 COMPILE_ASSERT(offsetof(Viewport, header) == 0,
                OffsetOf_Viewport_header_not_0);
@@ skipping 21 matching lines @@
 
   void Init() {
     SetHeader();
   }
 
   void* Set(void* cmd) {
     static_cast<ValueType*>(cmd)->Init();
     return NextCmdAddress<ValueType>(cmd);
   }
 
-  command_buffer::CommandHeader header;
+  gpu::CommandHeader header;
 };
 
 COMPILE_ASSERT(sizeof(SwapBuffers) == 4,
                Sizeof_SwapBuffers_is_not_4);
 COMPILE_ASSERT(offsetof(SwapBuffers, header) == 0,
                OffsetOf_SwapBuffers_header_not_0);
 
 #pragma pack(pop)