Change command buffer client code to use structures....

command_buffer/common/cross/gapi_interface.h

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 162 matching lines @@
                      const RGBA &color,
                      float depth,
                      unsigned int stencil) = 0;
 
   // Creates a vertex buffer.
   // Parameters:
   //   id: the resource ID for the new vertex buffer.
   //   size: the size of the vertex buffer, in bytes.
   //   flags: the vertex buffer flags, as a combination of vertex_buffer::Flags
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateVertexBuffer(ResourceID id,
                                         unsigned int size,
                                         unsigned int flags) = 0;
 
   // Destroys a vertex buffer.
   // Parameters:
   //   id: the resource ID of the vertex buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid vertex buffer
-  //   ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid vertex buffer
+  //   ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyVertexBuffer(ResourceID id) = 0;
 
   // Sets data into a vertex buffer.
   // Parameters:
   //   id: the resource ID of the vertex buffer.
   //   offset: the offset into the vertex buffer where to place the data.
   //   size: the size of the data.
   //   data: the source data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetVertexBufferData(ResourceID id,
                                          unsigned int offset,
                                          unsigned int size,
                                          const void *data) = 0;
 
   // Gets data from a vertex buffer.
   // Parameters:
   //   id: the resource ID of the vertex buffer.
   //   offset: the offset into the vertex buffer where to get the data.
   //   size: the size of the data.
   //   data: the destination buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetVertexBufferData(ResourceID id,
                                          unsigned int offset,
                                          unsigned int size,
                                          void *data) = 0;
 
   // Creates an index buffer.
   // Parameters:
   //   id: the resource ID for the new index buffer.
   //   size: the size of the index buffer, in bytes.
   //   flags: the index buffer flags, as a combination of index_buffer::Flags.
   //          Note that indices are 16 bits unless the index_buffer::INDEX_32BIT
   //          flag is specified.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateIndexBuffer(ResourceID id,
                                        unsigned int size,
                                        unsigned int flags) = 0;
 
   // Destroys an index buffer.
   // Parameters:
   //   id: the resource ID of the index buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid index buffer
-  //   ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid index buffer
+  //   ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyIndexBuffer(ResourceID id) = 0;
 
   // Sets data into an index buffer.
   // Parameters:
   //   id: the resource ID of the index buffer.
   //   offset: the offset into the index buffer where to place the data.
   //   size: the size of the data.
   //   data: the source data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetIndexBufferData(ResourceID id,
                                         unsigned int offset,
                                         unsigned int size,
                                         const void *data) = 0;
 
   // Gets data from an index buffer.
   // Parameters:
   //   id: the resource ID of the index buffer.
   //   offset: the offset into the index buffer where to get the data.
   //   size: the size of the data.
   //   data: the destination buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetIndexBufferData(ResourceID id,
                                         unsigned int offset,
                                         unsigned int size,
                                         void *data) = 0;
 
   // Creates a vertex struct. A vertex struct describes the input vertex
   // attribute streams.
   // Parameters:
   //   id: the resource ID of the vertex struct.
   //   input_count: the number of input vertex attributes.
   // returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateVertexStruct(ResourceID id,
                                         unsigned int input_count) = 0;
 
   // Destroys a vertex struct.
   // Parameters:
   //   id: the resource ID of the vertex struct.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid vertex struct
-  //   ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid vertex struct
+  //   ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyVertexStruct(ResourceID id) = 0;
 
   // Sets an input into a vertex struct.
   // Parameters:
   //   vertex_struct_id: the resource ID of the vertex struct.
   //   input_index: the index of the input being set.
   //   vertex_buffer_id: the resource ID of the vertex buffer containing the
   //                     data.
   //   offset: the offset into the vertex buffer of the input data, in bytes.
   //   stride: the stride of the input data, in bytes.
   //   type: the type of the input data.
   //   semantic: the semantic of the input.
   //   semantic_index: the semantic index of the input.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetVertexInput(ResourceID vertex_struct_id,
                                     unsigned int input_index,
                                     ResourceID vertex_buffer_id,
                                     unsigned int offset,
                                     unsigned int stride,
                                     vertex_struct::Type type,
                                     vertex_struct::Semantic semantic,
                                     unsigned int semantic_index) = 0;
 
   // Sets the current vertex struct for drawing.
   // Parameters:
   //   id: the resource ID of the vertex struct.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed (invalid vertex struct), BufferSyncInterface::PARSE_NO_ERROR
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed (invalid vertex struct), BufferSyncInterface::kParseNoError
   //   otherwise.
   virtual ParseError SetVertexStruct(ResourceID id) = 0;
 
   // Draws primitives, using the current vertex struct and the current effect.
   // Parameters:
   //   primitive_type: the type of primitive to draw.
   //   first: the index of the first vertex.
   //   count: the number of primitives to draw.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError Draw(PrimitiveType primitive_type,
                           unsigned int first,
                           unsigned int count) = 0;
 
   // Draws primitives, using the current vertex struct and the current effect,
   // as well as an index buffer.
   // Parameters:
   //   primitive_type: the type of primitive to draw.
   //   index_buffer_id: the resource ID of the index buffer.
   //   first: the index into the index buffer of the first index to draw.
   //   count: the number of primitives to draw.
   //   min_index: the lowest index being drawn.
   //   max_index: the highest index being drawn.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DrawIndexed(PrimitiveType primitive_type,
                                  ResourceID index_buffer_id,
                                  unsigned int first,
                                  unsigned int count,
                                  unsigned int min_index,
                                  unsigned int max_index) = 0;
 
   // Creates an effect, from source code.
   // Parameters:
   //   id: the resource ID of the effect.
   //   size: the size of data.
   //   data: the source code for the effect.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed or the effect failed to compile,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateEffect(ResourceID id,
                                   unsigned int size,
                                   const void *data) = 0;
 
   // Destroys an effect.
   // Parameters:
   //   id: the resource ID of the effect.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid effect ID
-  //   was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid effect ID
+  //   was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyEffect(ResourceID id) = 0;
 
   // Sets the active effect for drawing.
   // Parameters:
   //   id: the resource ID of the effect.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetEffect(ResourceID id) = 0;
 
   // Gets the number of parameters in an effect, returning it in a memory
   // buffer as a Uint32.
   // Parameters:
   //   id: the resource ID of the effect.
   //   size: the size of the data buffer. Must be at least 4 (the size of the
   //   Uint32).
   //   data: the buffer receiving the data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetParamCount(ResourceID id,
                                    unsigned int size,
                                    void *data) = 0;
 
   // Creates an effect parameter by index.
   // Parameters:
   //   param_id: the resource ID of the parameter being created.
   //   effect_id: the resource ID of the effect containing the parameter.
   //   data_type: the data type for the parameter. Must match the data type in
   //     the effect source.
   //   index: the index of the parameter.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid effect ID, unmatching data type or invalid
-  //   index, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   index, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateParam(ResourceID param_id,
                                  ResourceID effect_id,
                                  unsigned int index) = 0;
 
   // Creates an effect parameter by name.
   // Parameters:
   //   param_id: the resource ID of the parameter being created.
   //   effect_id: the resource ID of the effect containing the parameter.
   //   data_type: the data type for the parameter. Must match the data type in
   //     the effect source.
   //   size: the size of the parameter name.
   //   name: the parameter name, as an array of char. Doesn't have to be
   //     nul-terminated (though nul will terminate the string).
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid effect ID, unmatching data type or no parameter
-  //   was found with this name, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   was found with this name, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateParamByName(ResourceID param_id,
                                        ResourceID effect_id,
                                        unsigned int size,
                                        const void *name) = 0;
 
   // Destroys an effect parameter.
   // Parameters:
   //   id: the resource ID of the parameter.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid parameter ID
-  //   was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid parameter ID
+  //   was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyParam(ResourceID id) = 0;
 
   // Sets the effect parameter data.
   // Parameters:
   //   id: the resource ID of the parameter.
   //   size: the size of the data. Must be at least the size of the parameter
   //     as described by its type.
   //   data: the parameter data.
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid parameter ID, or unmatching data size,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetParamData(ResourceID id,
                                   unsigned int size,
                                   const void *data) = 0;
 
   // Gets the parameter description, storing it into a memory buffer. The
   // parameter is described by a effect_param::Desc structure. The size must be
   // at least the size of that structure. The name and semantic fields are only
   // filled if the character strings fit into the memory buffer. In any case,
   // the size field (in the effect_param::Desc) is filled with the size needed
   // to fill in the structure, the name and the semantic (if any). Thus to get
   // the complete information, GetParamDesc can be called twice, once to get
   // the size, and, after allocating a big enough buffer, again to fill in the
   // complete information including the text strings.
   // Parameters:
   //   id: the resource ID of the parameter.
   //   size: the size of the memory buffer that wil receive the parameter
   //     description. Must be at least sizeof(effect_param::Desc).
   //   data: the memory buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid parameter ID, or unsufficient data size,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise. Note that
-  //   BufferSyncInterface::PARSE_NO_ERROR will be returned if the structure
+  //   BufferSyncInterface::kParseNoError otherwise. Note that
+  //   BufferSyncInterface::kParseNoError will be returned if the structure
   //   itself fits, not necessarily the names. To make sure all the information
   //   is available, the caller should compare the returned size member of the
   //   effect_param::Desc structure to the size parameter passed in.
   virtual ParseError GetParamDesc(ResourceID id,
                                   unsigned int size,
                                   void *data) = 0;
 
   // Gets the number of input streams for an effect, returning it in a memory
   // buffer as a Uint32.
   // Parameters:
   //   id: the resource ID of the effect.
   //   size: the size of the data buffer. Must be at least 4 (the size of the
   //   Uint32).
   //   data: the buffer receiving the data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetStreamCount(ResourceID id,
                                     unsigned int size,
                                     void *data) = 0;
 
   // Gets the stream semantics, storing them in the data buffer. The stream
   // is described by an effect_stream::Desc structure which contains a
   // semantic type and a semantic index.
   // Parameters:
   //   id: the resource ID of the effect.
   //   index: which stream semantic to get
   //   size: the size of the data buffer. Must be at least 8 (the size of two
   //   Uint32).
   //   data: the buffer receiving the data.
   virtual ParseError GetStreamDesc(ResourceID id,
                                    unsigned int index,
                                    unsigned int size,
                                    void *data) = 0;
 
   // Creates a 2D texture resource.
   // Parameters:
   //   id: the resource ID of the texture.
   //   width: the texture width. Must be positive.
   //   height: the texture height. Must be positive.
   //   levels: the number of mipmap levels in the texture, or 0 to use the
   //     maximum.
   //   format: the format of the texels in the texture.
   //   flags: the texture flags, as a combination of texture::Flags.
   //   enable_render_surfaces: bool for whether to enable render surfaces
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateTexture2D(ResourceID id,
                                      unsigned int width,
                                      unsigned int height,
                                      unsigned int levels,
                                      texture::Format format,
                                      unsigned int flags,
                                      bool enable_render_surfaces) = 0;
 
   // Creates a 3D texture resource.
   // Parameters:
   //   id: the resource ID of the texture.
   //   width: the texture width. Must be positive.
   //   height: the texture height. Must be positive.
   //   depth: the texture depth. Must be positive.
   //   levels: the number of mipmap levels in the texture, or 0 to use the
   //     maximum.
   //   format: the format of the pixels in the texture.
   //   flags: the texture flags, as a combination of texture::Flags.
   //   enable_render_surfaces: bool for whether to enable render surfaces
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateTexture3D(ResourceID id,
                                      unsigned int width,
                                      unsigned int height,
                                      unsigned int depth,
                                      unsigned int levels,
                                      texture::Format format,
                                      unsigned int flags,
                                      bool enable_render_surfaces) = 0;
 
   // Creates a cube map texture resource.
   // Parameters:
   //   id: the resource ID of the texture.
   //   side: the texture side length. Must be positive.
   //   levels: the number of mipmap levels in the texture, or 0 to use the
   //     maximum.
   //   format: the format of the pixels in the texture.
   //   flags: the texture flags, as a combination of texture::Flags.
   //   enable_render_surfaces: bool for whether to enable render surfaces
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateTextureCube(ResourceID id,
                                        unsigned int side,
                                        unsigned int levels,
                                        texture::Format format,
                                        unsigned int flags,
                                        bool enable_render_surfaces) = 0;
 
   // Sets texel data into a texture resource. This is a common function for
   // each of the texture types, but some restrictions exist based on the
   // texture type. The specified rectangle or volume of data, defined by x, y,
@@ skipping 14 matching lines @@
   //   level: the mipmap level to put the data into.
   //   face: which face of the cube to put the data into. Is ignored for
   //     non-cube map textures.
   //   row_pitch: the number of bytes between two consecutive rows of blocks,
   //     in the source data.
   //   slice_pitch: the number of bytes between two consecutive slices of
   //     blocks, in the source data. Is ignored for non-3D textures.
   //   size: the size of the data.
   //   data: the texel data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, for example invalid size, or out-of-bounds rectangle/volume,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetTextureData(ResourceID id,
                                     unsigned int x,
                                     unsigned int y,
                                     unsigned int z,
                                     unsigned int width,
                                     unsigned int height,
                                     unsigned int depth,
                                     unsigned int level,
                                     texture::Face face,
                                     unsigned int pitch,
@@ skipping 21 matching lines @@
   //   level: the mipmap level to put the data into.
   //   face: which face of the cube to put the data into. Is ignored for
   //     non-cube map textures.
   //   row_pitch: the number of bytes between two consecutive rows of blocks,
   //     in the destination buffer.
   //   slice_pitch: the number of bytes between two consecutive slices of
   //     blocks, in the destination buffer. Is ignored for non-3D textures.
   //   size: the size of the data.
   //   data: the destination buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, for example invalid size, or out-of-bounds rectangle/volume,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetTextureData(ResourceID id,
                                     unsigned int x,
                                     unsigned int y,
                                     unsigned int z,
                                     unsigned int width,
                                     unsigned int height,
                                     unsigned int depth,
                                     unsigned int level,
                                     texture::Face face,
                                     unsigned int pitch,
                                     unsigned int slice_pitch,
                                     unsigned int size,
                                     void *data) = 0;
 
   // Destroys a texture resource.
   // Parameters:
   //   id: the resource ID of the texture.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid texture
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid texture
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyTexture(ResourceID id) = 0;
 
   // Creates a sampler resource.
   // Parameters:
   //   id: the resource ID of the sampler.
   // Returns:
-  //   BufferSyncInterface::PARSE_NO_ERROR.
+  //   BufferSyncInterface::kParseNoError.
   virtual ParseError CreateSampler(ResourceID id) = 0;
 
   // Destroys a sampler resource.
   // Parameters:
   //   id: the resource ID of the sampler.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroySampler(ResourceID id) = 0;
 
   // Sets the states in a sampler resource.
   // Parameters:
   //   id: the resource ID of the sampler.
   //   addressing_u: the addressing mode for the U coordinate.
   //   addressing_v: the addressing mode for the V coordinate.
   //   addressing_w: the addressing mode for the W coordinate.
   //   mag_filter: the filtering mode when magnifying textures.
   //   min_filter: the filtering mode when minifying textures.
   //   mip_filter: the filtering mode for mip-map interpolation textures.
   //   max_anisotropy: the maximum anisotropy.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetSamplerStates(ResourceID id,
                                       sampler::AddressingMode addressing_u,
                                       sampler::AddressingMode addressing_v,
                                       sampler::AddressingMode addressing_w,
                                       sampler::FilteringMode mag_filter,
                                       sampler::FilteringMode min_filter,
                                       sampler::FilteringMode mip_filter,
                                       unsigned int max_anisotropy) = 0;
 
   // Sets the color of border pixels.
   // Parameters:
   //   id: the resource ID of the sampler.
   //   color: the border color.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetSamplerBorderColor(ResourceID id,
                                            const RGBA &color) = 0;
 
   // Sets the texture resource used by a sampler resource.
   // Parameters:
   //   id: the resource ID of the sampler.
   //   texture_id: the resource id of the texture.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetSamplerTexture(ResourceID id,
                                        ResourceID texture_id) = 0;
 
   // Sets the viewport, and depth range.
   // Parameters:
   //   x, y: upper left corner of the viewport.
   //   width, height: dimensions of the viewport.
   //   z_min, z_max: depth range.
   virtual void SetViewport(unsigned int x,
                            unsigned int y,
@@ skipping 118 matching lines @@
   // Sets the blending color.
   virtual void SetBlendingColor(const RGBA &color) = 0;
 
   // Creates a render surface resource.
   // Parameters:
   //   id: the resource ID of the render surface.
   //   width: the texture width. Must be positive.
   //   height: the texture height. Must be positive.
   //   texture_id: the resource id of the texture.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateRenderSurface(ResourceID id,
                                          unsigned int width,
                                          unsigned int height,
                                          unsigned int mip_level,
                                          unsigned int side,
                                          ResourceID texture_id) = 0;
 
   // Destroys a render surface resource.
   // Parameters:
   //   id: the resource ID of the render surface.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid render
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid render
   //     surface
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyRenderSurface(ResourceID id) = 0;
 
   // Creates a depth stencil surface resource.
   // Parameters:
   //   id: the resource ID of the depth stencil surface.
   //   width: the texture width. Must be positive.
   //   height: the texture height. Must be positive.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateDepthSurface(ResourceID id,
                                         unsigned int width,
                                         unsigned int height) = 0;
 
   // Destroys a depth stencil surface resource.
   // Parameters:
   //   id: the resource ID of the depth stencil surface.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid render
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid render
   //     surface
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyDepthSurface(ResourceID id) = 0;
 
   // Switches the render surface and depth stencil surface to those
   // corresponding to the passed in IDs.
   // Parameters:
   //   render_surface_id: the resource ID of the render surface.
   //   depth_stencil_id: the resource ID of the render depth stencil surface.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetRenderSurface(ResourceID render_surface_id,
                                       ResourceID depth_stencil_id) = 0;
 
   // Switch the render surface and depth stencil surface back to the main
   // surfaces stored in the render
   virtual void SetBackSurfaces() = 0;
 };
 
 }  // namespace command_buffer
 }  // namespace o3d
 
 #endif  // O3D_COMMAND_BUFFER_COMMON_CROSS_GAPI_INTERFACE_H_