More work in Command Buffers...

command_buffer/service/cross/gl/effect_gl.cc

 /*
  * 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 44 matching lines @@
 
 EffectParamGL::~EffectParamGL() {
   if (effect_)
     effect_->UnlinkParam(this);
 }
 
 static effect_param::DataType CgTypeToCBType(CGtype cg_type) {
   switch (cg_type) {
     case CG_FLOAT:
     case CG_FLOAT1:
-      return effect_param::FLOAT1;
+      return effect_param::kFloat1;
     case CG_FLOAT2:
-      return effect_param::FLOAT2;
+      return effect_param::kFloat2;
     case CG_FLOAT3:
-      return effect_param::FLOAT3;
+      return effect_param::kFloat3;
     case CG_FLOAT4:
-      return effect_param::FLOAT4;
+      return effect_param::kFloat4;
     case CG_INT:
     case CG_INT1:
-      return effect_param::INT;
+      return effect_param::kInt;
     case CG_BOOL:
     case CG_BOOL1:
-      return effect_param::BOOL;
+      return effect_param::kBool;
     case CG_FLOAT4x4:
-      return effect_param::MATRIX4;
+      return effect_param::kMatrix4;
     case CG_SAMPLER:
     case CG_SAMPLER1D:
     case CG_SAMPLER2D:
     case CG_SAMPLER3D:
     case CG_SAMPLERCUBE:
-      return effect_param::SAMPLER;
+      return effect_param::kSampler;
     case CG_TEXTURE:
-      return effect_param::TEXTURE;
+      return effect_param::kTexture;
     default : {
       DLOG(INFO) << "Cannot convert CGtype "
                  << cgGetTypeString(cg_type)
                  << " to a Param type.";
-      return effect_param::UNKNOWN;
+      return effect_param::kUnknown;
     }
   }
 }
 
 EffectParamGL *EffectParamGL::Create(EffectGL *effect,
                                      unsigned int index) {
   DCHECK(effect);
   const EffectGL::LowLevelParam &low_level_param =
       effect->low_level_params_[index];
   CGparameter cg_param = EffectGL::GetEitherCgParameter(low_level_param);
   CGtype cg_type = cgGetParameterType(cg_param);
   if (cg_type == CG_ARRAY) {
     cg_type = cgGetParameterType(cgGetArrayParameter(cg_param, 0));
   }
   effect_param::DataType type = CgTypeToCBType(cg_type);
 
-  if (type == effect_param::UNKNOWN)
+  if (type == effect_param::kUnknown)
     return NULL;
   return new EffectParamGL(type, effect, index);
 }
 
 // Fills the Desc structure, appending name and semantic if any, and if enough
 // room is available in the buffer.
 bool EffectParamGL::GetDesc(unsigned int size, void *data) {
   using effect_param::Desc;
   if (size < sizeof(Desc))  // NOLINT
     return false;
@@ skipping 50 matching lines @@
     return false;
   }
 
   CGparameter vp_param = low_level_param.vp_param;
   CGparameter fp_param = low_level_param.fp_param;
   effect_param::DataType type = data_type();
   if (size < effect_param::GetDataSize(type))
     return false;
 
   switch (type) {
-    case effect_param::FLOAT1:
+    case effect_param::kFloat1:
       if (vp_param)
         cgSetParameter1f(vp_param, *static_cast<const float *>(data));
       if (fp_param)
         cgSetParameter1f(fp_param, *static_cast<const float *>(data));
       break;
-    case effect_param::FLOAT2:
+    case effect_param::kFloat2:
       if (vp_param)
         cgSetParameter2fv(vp_param, static_cast<const float *>(data));
       if (fp_param)
         cgSetParameter2fv(fp_param, static_cast<const float *>(data));
       break;
-    case effect_param::FLOAT3:
+    case effect_param::kFloat3:
       if (vp_param)
         cgSetParameter3fv(vp_param, static_cast<const float *>(data));
       if (fp_param)
         cgSetParameter3fv(fp_param, static_cast<const float *>(data));
       break;
-    case effect_param::FLOAT4:
+    case effect_param::kFloat4:
       if (vp_param)
         cgSetParameter4fv(vp_param, static_cast<const float *>(data));
       if (fp_param)
         cgSetParameter4fv(fp_param, static_cast<const float *>(data));
       break;
-    case effect_param::MATRIX4:
+    case effect_param::kMatrix4:
       if (vp_param)
         cgSetMatrixParameterfr(vp_param, static_cast<const float *>(data));
       if (fp_param)
         cgSetMatrixParameterfr(fp_param, static_cast<const float *>(data));
       break;
-    case effect_param::INT:
+    case effect_param::kInt:
       if (vp_param) cgSetParameter1i(vp_param, *static_cast<const int *>(data));
       if (fp_param) cgSetParameter1i(fp_param, *static_cast<const int *>(data));
       break;
-    case effect_param::BOOL: {
+    case effect_param::kBool: {
       int bool_value = *static_cast<const bool *>(data)?1:0;
       if (vp_param) cgSetParameter1i(vp_param, bool_value);
       if (fp_param) cgSetParameter1i(fp_param, bool_value);
       break;
     }
-    case effect_param::SAMPLER: {
+    case effect_param::kSampler: {
       DCHECK_GE(low_level_param.sampler_ids.size(), 1);
-      low_level_param.sampler_ids[0] = *static_cast<const ResourceID *>(data);
+      low_level_param.sampler_ids[0] = *static_cast<const ResourceId *>(data);
       if (effect_ == gapi->current_effect()) {
         gapi->DirtyEffect();
       }
       break;
     }
     default:
       DLOG(ERROR) << "Invalid parameter type.";
       return false;
   }
   return true;
@@ skipping 205 matching lines @@
       continue;
     const char *name = cgGetParameterName(cg_param);
     if (!name)
       continue;
 
     CGtype cg_type = cgGetParameterType(cg_param);
 
     int num_elements;
     if (cg_type == CG_ARRAY) {
       num_elements = cgGetArraySize(cg_param, 0);
-      // Substitute the first element's type for our type.      
+      // Substitute the first element's type for our type.
       cg_type = cgGetParameterType(cgGetArrayParameter(cg_param, 0));
     } else {
       num_elements = 0;
     }
 
     int index = GetLowLevelParamIndexByName(name);
     if (index < 0) {
       LowLevelParam param;
       param.name = name;
       param.vp_param = NULL;
       param.fp_param = NULL;
       param.num_elements = num_elements;
 
       index = low_level_params_.size();
       if (cg_type == CG_SAMPLER ||
           cg_type == CG_SAMPLER1D ||
           cg_type == CG_SAMPLER2D ||
           cg_type == CG_SAMPLER3D ||
           cg_type == CG_SAMPLERCUBE) {
         sampler_params_.push_back(index);
         if (num_elements == 0) {
           param.sampler_ids.push_back(kInvalidResource);
         } else {
           param.sampler_ids.resize(num_elements);
-          std::vector<ResourceID>::iterator iter;
+          std::vector<ResourceId>::iterator iter;
           for (iter = param.sampler_ids.begin();
                iter != param.sampler_ids.end();
                ++iter) {
             *iter = kInvalidResource;
           }
         }
       }
       low_level_params_.push_back(param);
     }
 
     if (vp) {
       low_level_params_[index].vp_param = cg_param;
     } else {
       low_level_params_[index].fp_param = cg_param;
     }
   }
 }
 
 typedef std::pair<String, effect_stream::Desc> SemanticMapElement;
 typedef std::map<String, effect_stream::Desc> SemanticMap;
 
 // The map batween the semantics on vertex program varying parameters names
 // and vertex attribute indices under the VP_30 profile.
+// TODO(gman): remove this.
 SemanticMapElement semantic_map_array[] = {
   SemanticMapElement("POSITION",
-      effect_stream::Desc(vertex_struct::POSITION, 0)),
+      effect_stream::Desc(vertex_struct::kPosition, 0)),
   SemanticMapElement("ATTR0",
-      effect_stream::Desc(vertex_struct::POSITION, 0)),
+      effect_stream::Desc(vertex_struct::kPosition, 0)),
   SemanticMapElement("BLENDWEIGHT",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("ATTR1",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("NORMAL",
-      effect_stream::Desc(vertex_struct::NORMAL, 0)),
+      effect_stream::Desc(vertex_struct::kNormal, 0)),
   SemanticMapElement("ATTR2",
-      effect_stream::Desc(vertex_struct::NORMAL, 0)),
+      effect_stream::Desc(vertex_struct::kNormal, 0)),
   SemanticMapElement("COLOR0",
-      effect_stream::Desc(vertex_struct::COLOR, 0)),
+      effect_stream::Desc(vertex_struct::kColor, 0)),
   SemanticMapElement("DIFFUSE",
-      effect_stream::Desc(vertex_struct::COLOR, 0)),
+      effect_stream::Desc(vertex_struct::kColor, 0)),
   SemanticMapElement("ATTR3",
-      effect_stream::Desc(vertex_struct::COLOR, 0)),
+      effect_stream::Desc(vertex_struct::kColor, 0)),
   SemanticMapElement("COLOR1",
-      effect_stream::Desc(vertex_struct::COLOR, 1)),
+      effect_stream::Desc(vertex_struct::kColor, 1)),
   SemanticMapElement("SPECULAR",
-      effect_stream::Desc(vertex_struct::COLOR, 1)),
+      effect_stream::Desc(vertex_struct::kColor, 1)),
   SemanticMapElement("ATTR4",
-      effect_stream::Desc(vertex_struct::COLOR, 1)),
+      effect_stream::Desc(vertex_struct::kColor, 1)),
   SemanticMapElement("TESSFACTOR",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("FOGCOORD",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("ATTR5",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("PSIZE",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("ATTR6",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("BLENDINDICES",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("ATTR7",
-      effect_stream::Desc(vertex_struct::UNKNOWN_SEMANTIC, 0)),
+      effect_stream::Desc(vertex_struct::kUnknownSemantic, 0)),
   SemanticMapElement("TEXCOORD0",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 0)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 0)),
   SemanticMapElement("ATTR8",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 0)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 0)),
   SemanticMapElement("TEXCOORD1",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 1)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 1)),
   SemanticMapElement("ATTR9",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 1)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 1)),
   SemanticMapElement("TEXCOORD2",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 2)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 2)),
   SemanticMapElement("ATTR10",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 2)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 2)),
   SemanticMapElement("TEXCOORD3",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 3)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 3)),
   SemanticMapElement("ATTR11",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 3)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 3)),
   SemanticMapElement("TEXCOORD4",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 4)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 4)),
   SemanticMapElement("ATTR12",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 4)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 4)),
   SemanticMapElement("TEXCOORD5",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 5)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 5)),
   SemanticMapElement("ATTR13",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 5)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 5)),
   SemanticMapElement("TEXCOORD6",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 6)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 6)),
   SemanticMapElement("TANGENT",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 6)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 6)),
   SemanticMapElement("ATTR14",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 7)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 7)),
   SemanticMapElement("TEXCOORD7",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 7)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 7)),
   SemanticMapElement("BINORMAL",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 8)),
+      effect_stream::Desc(vertex_struct::kTexCoord, 8)),
   SemanticMapElement("ATTR15",
-      effect_stream::Desc(vertex_struct::TEX_COORD, 8))
+      effect_stream::Desc(vertex_struct::kTexCoord, 8))
 };
 
 static SemanticMap semantic_map(semantic_map_array,
                                 semantic_map_array +
                                     arraysize(semantic_map_array));
 
 void EffectGL::Initialize() {
   AddLowLevelParams(vertex_program_, CG_PROGRAM, true);
   AddLowLevelParams(vertex_program_, CG_GLOBAL, true);
   AddLowLevelParams(fragment_program_, CG_PROGRAM, false);
@@ skipping 15 matching lines @@
     CGenum direction = cgGetParameterDirection(cg_param);
     if (direction != CG_IN)
       continue;
     const char* cg_semantic = cgGetParameterSemantic(cg_param);
     if (cg_semantic == NULL)
       continue;
 
     SemanticMap::iterator iter = semantic_map.find(String(cg_semantic));
     if (iter == semantic_map.end()) {
       streams_.push_back(effect_stream::Desc(
-          vertex_struct::UNKNOWN_SEMANTIC, 0));
+          vertex_struct::kUnknownSemantic, 0));
     } else {
       streams_.push_back(iter->second);
     }
   }
 }
 
 // Begins rendering with the effect, setting all the appropriate states.
 bool EffectGL::Begin(GAPIGL *gapi) {
   cgGLBindProgram(vertex_program_);
   cgGLBindProgram(fragment_program_);
 
   // sampler->ApplyStates will mess with the texture binding on unit 0, so we
   // do 2 passes.
   // First to set the sampler states on the texture
   for (unsigned int i = 0; i < sampler_params_.size(); ++i) {
     unsigned int param_index = sampler_params_[i];
-    std::vector<ResourceID> &ids = low_level_params_[param_index].sampler_ids;
-    for (std::vector<ResourceID>::iterator iter = ids.begin();
+    std::vector<ResourceId> &ids = low_level_params_[param_index].sampler_ids;
+    for (std::vector<ResourceId>::iterator iter = ids.begin();
          iter != ids.end();
          ++iter) {
-      ResourceID id = *iter;
+      ResourceId id = *iter;
       if (id != kInvalidResource) {
         SamplerGL *sampler = gapi->GetSampler(id);
         if (!sampler->ApplyStates(gapi)) {
           return false;
         }
       }
     }
   }
   // Second to enable/disable the sampler params.
   for (unsigned int i = 0; i < sampler_params_.size(); ++i) {
     unsigned int param_index = sampler_params_[i];
     const LowLevelParam &ll_param = low_level_params_[param_index];
-    std::vector<ResourceID> &ids = low_level_params_[param_index].sampler_ids;
+    std::vector<ResourceId> &ids = low_level_params_[param_index].sampler_ids;
     // TODO(petersont): Rewrite the following so it handles arrays of samplers
     // instead of simply bailing.
     if (cgGetParameterType(ll_param.fp_param) == CG_ARRAY)
       return false;
-    for (std::vector<ResourceID>::iterator iter = ids.begin();
+    for (std::vector<ResourceId>::iterator iter = ids.begin();
          iter != ids.end();
          ++iter) {
-      ResourceID id = *iter;
+      ResourceId id = *iter;
       if (id != kInvalidResource) {
         SamplerGL *sampler = gapi->GetSampler(id);
         GLuint gl_texture = sampler->gl_texture();
         cgGLSetTextureParameter(ll_param.fp_param, gl_texture);
         cgGLEnableTextureParameter(ll_param.fp_param);
       } else {
         cgGLSetTextureParameter(ll_param.fp_param, 0);
         cgGLDisableTextureParameter(ll_param.fp_param);
       }
     }
@@ skipping 38 matching lines @@
 }
 
 // Gets a handle to the selected parameter, and wraps it into an
 // EffectParamGL if successful.
 EffectParamGL *EffectGL::CreateParamByName(const char *name) {
   int index = GetLowLevelParamIndexByName(name);
   if (index < 0) return NULL;
   return EffectParamGL::Create(this, index);
 }
 
-BufferSyncInterface::ParseError GAPIGL::CreateEffect(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::CreateEffect(ResourceId id,
                                                      unsigned int size,
                                                      const void *data) {
   if (id == current_effect_id_) DirtyEffect();
   // Even though Assign would Destroy the effect at id, we do it explicitly in
   // case the creation fails.
   effects_.Destroy(id);
   // Data is vp_main \0 fp_main \0 effect_text.
   String vertex_program_entry;
   String fragment_program_entry;
   String effect_code;
   if (!ParseEffectData(size, data,
                        &vertex_program_entry,
                        &fragment_program_entry,
                        &effect_code)) {
     return BufferSyncInterface::kParseInvalidArguments;
   }
   EffectGL * effect = EffectGL::Create(this, effect_code,
                                        vertex_program_entry,
                                        fragment_program_entry);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   effects_.Assign(id, effect);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::DestroyEffect(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::DestroyEffect(ResourceId id) {
   if (id == current_effect_id_) DirtyEffect();
   return effects_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::SetEffect(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::SetEffect(ResourceId id) {
   DirtyEffect();
   current_effect_id_ = id;
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::GetParamCount(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::GetParamCount(ResourceId id,
                                                       unsigned int size,
                                                       void *data) {
   EffectGL *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
     return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetParamCount();
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::CreateParam(ResourceID param_id,
-                                                    ResourceID effect_id,
+BufferSyncInterface::ParseError GAPIGL::CreateParam(ResourceId param_id,
+                                                    ResourceId effect_id,
                                                     unsigned int index) {
   EffectGL *effect = effects_.Get(effect_id);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   EffectParamGL *param = effect->CreateParam(index);
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::CreateParamByName(ResourceID param_id,
-                                                          ResourceID effect_id,
+BufferSyncInterface::ParseError GAPIGL::CreateParamByName(ResourceId param_id,
+                                                          ResourceId effect_id,
                                                           unsigned int size,
                                                           const void *name) {
   EffectGL *effect = effects_.Get(effect_id);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   std::string string_name(static_cast<const char *>(name), size);
   EffectParamGL *param = effect->CreateParamByName(string_name.c_str());
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::DestroyParam(ResourceID id) {
+BufferSyncInterface::ParseError GAPIGL::DestroyParam(ResourceId id) {
   return effect_params_.Destroy(id) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::SetParamData(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::SetParamData(ResourceId id,
                                                      unsigned int size,
                                                      const void *data) {
   EffectParamGL *param = effect_params_.Get(id);
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->SetData(this, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
-BufferSyncInterface::ParseError GAPIGL::GetParamDesc(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::GetParamDesc(ResourceId id,
                                                      unsigned int size,
                                                      void *data) {
   EffectParamGL *param = effect_params_.Get(id);
   if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->GetDesc(size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetStreamCount(
-    ResourceID id,
+    ResourceId id,
     unsigned int size,
     void *data) {
   EffectGL *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
     return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetStreamCount();
   return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIGL::GetStreamDesc(ResourceID id,
+BufferSyncInterface::ParseError GAPIGL::GetStreamDesc(ResourceId id,
                                                       unsigned int index,
                                                       unsigned int size,
                                                       void *data) {
   EffectGL *effect = effects_.Get(id);
   if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   return effect->GetStreamDesc(index, size, data) ?
       BufferSyncInterface::kParseNoError :
       BufferSyncInterface::kParseInvalidArguments;
 }
 
@@ skipping 12 matching lines @@
   DCHECK(validate_effect_);
   DCHECK(!current_effect_);
   current_effect_ = effects_.Get(current_effect_id_);
   if (!current_effect_) return false;
   validate_effect_ = false;
   return current_effect_->Begin(this);
 }
 
 }  // namespace command_buffer
 }  // namespace o3d