Added temporary #ifdefs to support incompatible ANGLE API upgrade.

gpu/command_buffer/service/shader_translator.cc

 // Copyright (c) 2012 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 <algorithm>
 
 #include "base/at_exit.h"
 #include "base/logging.h"
 
 namespace {
 
 using gpu::gles2::ShaderTranslator;
 
 void FinalizeShaderTranslator(void* /* dummy */) {
   ShFinalize();
 }
 
 bool InitializeShaderTranslator() {
   static bool initialized = false;
   if (!initialized && ShInitialize()) {
     base::AtExitManager::RegisterCallback(&FinalizeShaderTranslator, NULL);
     initialized = true;
   }
   return initialized;
 }
 
+#if !defined(ANGLE_SH_VERSION) || ANGLE_SH_VERSION < 108
+typedef int ANGLEGetInfoType;
+#else
+typedef size_t ANGLEGetInfoType;
+#endif
+
 void GetVariableInfo(ShHandle compiler, ShShaderInfo var_type,
                      ShaderTranslator::VariableMap* var_map) {
-  int name_len = 0, mapped_name_len = 0;
+  ANGLEGetInfoType 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();
   }
   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;
+  ANGLEGetInfoType num_vars = 0;
   ShGetInfo(compiler, var_type, &num_vars);
-  for (int i = 0; i < num_vars; ++i) {
-    int len = 0;
+  for (ANGLEGetInfoType i = 0; i < num_vars; ++i) {
+    ANGLEGetInfoType len = 0;
     int size = 0;
     ShDataType type = SH_NONE;
 
     switch (var_type) {
       case SH_ACTIVE_ATTRIBUTES:
         ShGetActiveAttrib(
             compiler, i, &len, &size, &type, name.get(), mapped_name.get());
         break;
       case SH_ACTIVE_UNIFORMS:
         ShGetActiveUniform(
             compiler, i, &len, &size, &type, name.get(), mapped_name.get());
         break;
       default: NOTREACHED();
     }
 
     // In theory we should CHECK(len <= name_len - 1) here, but ANGLE needs
     // to handle long struct field name mapping before we can do this.
     // Also, we should modify the ANGLE interface to also return a length
     // for mapped_name.
     std::string name_string(name.get(), std::min(len, name_len - 1));
     mapped_name.get()[mapped_name_len - 1] = '\0';
 
     ShaderTranslator::VariableInfo info(type, size, name_string);
     (*var_map)[mapped_name.get()] = info;
   }
 }
 
 void GetNameHashingInfo(
     ShHandle compiler, ShaderTranslator::NameMap* name_map) {
-  int hashed_names_count = 0;
+  ANGLEGetInfoType hashed_names_count = 0;
   ShGetInfo(compiler, SH_HASHED_NAMES_COUNT, &hashed_names_count);
   if (hashed_names_count == 0)
     return;
 
-  int name_max_len = 0, hashed_name_max_len = 0;
+  ANGLEGetInfoType name_max_len = 0, hashed_name_max_len = 0;
   ShGetInfo(compiler, SH_NAME_MAX_LENGTH, &name_max_len);
   ShGetInfo(compiler, SH_HASHED_NAME_MAX_LENGTH, &hashed_name_max_len);
 
   scoped_array<char> name(new char[name_max_len]);
   scoped_array<char> hashed_name(new char[hashed_name_max_len]);
 
-  for (int i = 0; i < hashed_names_count; ++i) {
+  for (ANGLEGetInfoType i = 0; i < hashed_names_count; ++i) {
     ShGetNameHashingEntry(compiler, i, name.get(), hashed_name.get());
     (*name_map)[hashed_name.get()] = name.get();
   }
 }
 
 }  // namespace
 
 namespace gpu {
 namespace gles2 {
 
@@ skipping 47 matching lines @@
       SH_OBJECT_CODE | SH_ATTRIBUTES_UNIFORMS |
       SH_MAP_LONG_VARIABLE_NAMES | SH_ENFORCE_PACKING_RESTRICTIONS;
 
   compile_options |= SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
 
   if (needs_built_in_function_emulation_)
     compile_options |= SH_EMULATE_BUILT_IN_FUNCTIONS;
   if (ShCompile(compiler_, &shader, 1, compile_options)) {
     success = true;
     // Get translated shader.
-    int obj_code_len = 0;
+    ANGLEGetInfoType 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());
     }
     // Get info for attribs and uniforms.
     GetVariableInfo(compiler_, SH_ACTIVE_ATTRIBUTES, &attrib_map_);
     GetVariableInfo(compiler_, SH_ACTIVE_UNIFORMS, &uniform_map_);
     // Get info for name hashing.
     GetNameHashingInfo(compiler_, &name_map_);
   }
 
   // Get info log.
-  int info_log_len = 0;
+  ANGLEGetInfoType info_log_len = 0;
   ShGetInfo(compiler_, SH_INFO_LOG_LENGTH, &info_log_len);
   if (info_log_len > 1) {
     info_log_.reset(new char[info_log_len]);
     ShGetInfoLog(compiler_, info_log_.get());
   } else {
     info_log_.reset();
   }
 
   return success;
 }
@@ skipping 44 matching lines @@
   translated_shader_.reset();
   info_log_.reset();
   attrib_map_.clear();
   uniform_map_.clear();
   name_map_.clear();
 }
 
 }  // namespace gles2
 }  // namespace gpu