Hook up shader long variable name mapping with GPU command buffer port.

gpu/command_buffer/service/shader_translator.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/shader_translator.h"
 
 #include <string.h>
 
 #include "base/at_exit.h"
 #include "base/logging.h"
 
 namespace {
 void FinalizeShaderTranslator(void* /* dummy */) {
   ShFinalize();
 }
 
 bool InitializeShaderTranslator() {
   static bool initialized = false;
   if (!initialized && ShInitialize()) {
     base::AtExitManager::RegisterCallback(&FinalizeShaderTranslator, NULL);
     initialized = true;
   }
   return initialized;
 }
 
 using gpu::gles2::ShaderTranslator;
 void GetVariableInfo(ShHandle compiler, ShShaderInfo var_type,
                      ShaderTranslator::VariableMap* var_map) {
-  int name_len = 0;
+  int name_len = 0, mapped_name_len = 0;
   switch (var_type) {
     case SH_ACTIVE_ATTRIBUTES:
       ShGetInfo(compiler, SH_ACTIVE_ATTRIBUTE_MAX_LENGTH, &name_len);
       break;
     case SH_ACTIVE_UNIFORMS:
       ShGetInfo(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH, &name_len);
       break;
     default: NOTREACHED();
   }
-  if (name_len <= 1) return;
+  ShGetInfo(compiler, SH_MAPPED_NAME_MAX_LENGTH, &mapped_name_len);
+  if (name_len <= 1 || mapped_name_len <= 1) return;
   scoped_array<char> name(new char[name_len]);
+  scoped_array<char> mapped_name(new char[mapped_name_len]);
 
   int num_vars = 0;
   ShGetInfo(compiler, var_type, &num_vars);
   for (int i = 0; i < num_vars; ++i) {
     int size = 0;
     ShDataType type = SH_NONE;
 
     switch (var_type) {
       case SH_ACTIVE_ATTRIBUTES:
-        ShGetActiveAttrib(compiler, i, NULL, &size, &type, name.get(), NULL);
+        ShGetActiveAttrib(
+            compiler, i, NULL, &size, &type, name.get(), mapped_name.get());
         break;
       case SH_ACTIVE_UNIFORMS:
-        ShGetActiveUniform(compiler, i, NULL, &size, &type, name.get(), NULL);
+        ShGetActiveUniform(
+            compiler, i, NULL, &size, &type, name.get(), mapped_name.get());
         break;
       default: NOTREACHED();
     }
 
-    ShaderTranslator::VariableInfo info(type, size);
-    (*var_map)[name.get()] = info;
+    ShaderTranslator::VariableInfo info(type, size, name.get());
+    (*var_map)[mapped_name.get()] = info;
   }
 }
 }  // namespace
 
 namespace gpu {
 namespace gles2 {
 
 ShaderTranslator::ShaderTranslator()
     : compiler_(NULL),
       implementation_is_glsl_es_(false) {
@@ skipping 22 matching lines @@
   return compiler_ != NULL;
 }
 
 bool ShaderTranslator::Translate(const char* shader) {
   // Make sure this instance is initialized.
   DCHECK(compiler_ != NULL);
   DCHECK(shader != NULL);
   ClearResults();
 
   bool success = false;
-  int compile_options = SH_OBJECT_CODE | SH_ATTRIBUTES_UNIFORMS;
+  int compile_options =
+      SH_OBJECT_CODE | SH_ATTRIBUTES_UNIFORMS | SH_MAP_LONG_VARIABLE_NAMES;
   if (ShCompile(compiler_, &shader, 1, compile_options)) {
     success = true;
     if (!implementation_is_glsl_es_) {
       // Get translated shader.
       int obj_code_len = 0;
       ShGetInfo(compiler_, SH_OBJECT_CODE_LENGTH, &obj_code_len);
       if (obj_code_len > 1) {
         translated_shader_.reset(new char[obj_code_len]);
         ShGetObjectCode(compiler_, translated_shader_.get());
       }
@@ skipping 46 matching lines @@
 void ShaderTranslator::ClearResults() {
   translated_shader_.reset();
   info_log_.reset();
   attrib_map_.clear();
   uniform_map_.clear();
 }
 
 }  // namespace gles2
 }  // namespace gpu