Remove outdated ANGLE_SH_VERSION if-def stuff.

gpu/command_buffer/service/shader_translator_unittest.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 <GLES2/gl2.h>
 
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-// The ANGLE shader translator now uses native GLenums
-// TODO(jmadill): delete these defines when the ANGLE
-//   roll reliably passes translator version 126
-#if (ANGLE_SH_VERSION >= 126)
-#define SH_VERTEX_SHADER GL_VERTEX_SHADER
-#define SH_FRAGMENT_SHADER GL_FRAGMENT_SHADER
-#define SH_FLOAT_VEC4 GL_FLOAT_VEC4
-#endif
-
 namespace gpu {
 namespace gles2 {
 
 class ShaderTranslatorTest : public testing::Test {
  public:
   ShaderTranslatorTest() {
   }
 
   virtual ~ShaderTranslatorTest() {
   }
 
  protected:
   virtual void SetUp() {
     ShBuiltInResources resources;
     ShInitBuiltInResources(&resources);
     resources.MaxExpressionComplexity = 32;
     resources.MaxCallStackDepth = 32;
 
     vertex_translator_ = new ShaderTranslator();
     fragment_translator_ = new ShaderTranslator();
 
     ASSERT_TRUE(vertex_translator_->Init(
-        SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
+        GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
         ShaderTranslatorInterface::kGlsl,
         SH_EMULATE_BUILT_IN_FUNCTIONS));
     ASSERT_TRUE(fragment_translator_->Init(
-        SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
+        GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
         ShaderTranslatorInterface::kGlsl,
         static_cast<ShCompileOptions>(0)));
     // Post-init the results must be empty.
     // Vertex translator results.
     EXPECT_TRUE(vertex_translator_->translated_shader() == NULL);
     EXPECT_TRUE(vertex_translator_->info_log() == NULL);
     EXPECT_TRUE(vertex_translator_->attrib_map().empty());
     EXPECT_TRUE(vertex_translator_->uniform_map().empty());
     // Fragment translator results.
     EXPECT_TRUE(fragment_translator_->translated_shader() == NULL);
@@ skipping 95 matching lines @@
 
   EXPECT_TRUE(vertex_translator_->Translate(shader));
   // Info log must be NULL.
   EXPECT_TRUE(vertex_translator_->info_log() == NULL);
   // Translated shader must be valid and non-empty.
   ASSERT_TRUE(vertex_translator_->translated_shader() != NULL);
   EXPECT_GT(strlen(vertex_translator_->translated_shader()), 0u);
   // There should be no uniforms.
   EXPECT_TRUE(vertex_translator_->uniform_map().empty());
   // There should be one attribute with following characteristics:
-  // name:vPosition type:SH_FLOAT_VEC4 size:1.
+  // name:vPosition type:GL_FLOAT_VEC4 size:1.
   const ShaderTranslator::VariableMap& attrib_map =
       vertex_translator_->attrib_map();
   EXPECT_EQ(1u, attrib_map.size());
   ShaderTranslator::VariableMap::const_iterator iter =
       attrib_map.find("vPosition");
   EXPECT_TRUE(iter != attrib_map.end());
-  EXPECT_EQ(SH_FLOAT_VEC4, iter->second.type);
+  EXPECT_EQ(GL_FLOAT_VEC4, iter->second.type);
   EXPECT_EQ(1, iter->second.size);
   EXPECT_EQ("vPosition", iter->second.name);
 }
 
 TEST_F(ShaderTranslatorTest, GetUniforms) {
   const char* shader =
       "precision mediump float;\n"
       "struct Foo {\n"
       "  vec4 color[1];\n"
       "};\n"
       "struct Bar {\n"
       "  Foo foo;\n"
       "};\n"
       "uniform Bar bar[2];\n"
       "void main() {\n"
       "  gl_FragColor = bar[0].foo.color[0] + bar[1].foo.color[0];\n"
       "}";
 
   EXPECT_TRUE(fragment_translator_->Translate(shader));
   // Info log must be NULL.
   EXPECT_TRUE(fragment_translator_->info_log() == NULL);
   // Translated shader must be valid and non-empty.
   ASSERT_TRUE(fragment_translator_->translated_shader() != NULL);
   EXPECT_GT(strlen(fragment_translator_->translated_shader()), 0u);
   // There should be no attributes.
   EXPECT_TRUE(fragment_translator_->attrib_map().empty());
   // There should be two uniforms with following characteristics:
-  // 1. name:bar[0].foo.color[0] type:SH_FLOAT_VEC4 size:1
-  // 2. name:bar[1].foo.color[0] type:SH_FLOAT_VEC4 size:1
+  // 1. name:bar[0].foo.color[0] type:GL_FLOAT_VEC4 size:1
+  // 2. name:bar[1].foo.color[0] type:GL_FLOAT_VEC4 size:1
   const ShaderTranslator::VariableMap& uniform_map =
       fragment_translator_->uniform_map();
   EXPECT_EQ(2u, uniform_map.size());
   // First uniform.
   ShaderTranslator::VariableMap::const_iterator iter =
       uniform_map.find("bar[0].foo.color[0]");
   EXPECT_TRUE(iter != uniform_map.end());
-  EXPECT_EQ(SH_FLOAT_VEC4, iter->second.type);
+  EXPECT_EQ(GL_FLOAT_VEC4, iter->second.type);
   EXPECT_EQ(1, iter->second.size);
   EXPECT_EQ("bar[0].foo.color[0]", iter->second.name);
   // Second uniform.
   iter = uniform_map.find("bar[1].foo.color[0]");
   EXPECT_TRUE(iter != uniform_map.end());
-  EXPECT_EQ(SH_FLOAT_VEC4, iter->second.type);
+  EXPECT_EQ(GL_FLOAT_VEC4, iter->second.type);
   EXPECT_EQ(1, iter->second.size);
   EXPECT_EQ("bar[1].foo.color[0]", iter->second.name);
 }
 
 #if defined(OS_MACOSX)
 TEST_F(ShaderTranslatorTest, BuiltInFunctionEmulation) {
   // This test might become invalid in the future when ANGLE Translator is no
   // longer emulate dot(float, float) in Mac, or the emulated function name is
   // no longer webgl_dot_emu.
   const char* shader =
@@ skipping 13 matching lines @@
 
 TEST_F(ShaderTranslatorTest, OptionsString) {
   scoped_refptr<ShaderTranslator> translator_1 = new ShaderTranslator();
   scoped_refptr<ShaderTranslator> translator_2 = new ShaderTranslator();
   scoped_refptr<ShaderTranslator> translator_3 = new ShaderTranslator();
 
   ShBuiltInResources resources;
   ShInitBuiltInResources(&resources);
 
   ASSERT_TRUE(translator_1->Init(
-      SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
+      GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
       ShaderTranslatorInterface::kGlsl,
       SH_EMULATE_BUILT_IN_FUNCTIONS));
   ASSERT_TRUE(translator_2->Init(
-      SH_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
+      GL_FRAGMENT_SHADER, SH_GLES2_SPEC, &resources,
       ShaderTranslatorInterface::kGlsl,
       static_cast<ShCompileOptions>(0)));
   resources.EXT_draw_buffers = 1;
   ASSERT_TRUE(translator_3->Init(
-      SH_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
+      GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
       ShaderTranslatorInterface::kGlsl,
       SH_EMULATE_BUILT_IN_FUNCTIONS));
 
   std::string options_1(
       translator_1->GetStringForOptionsThatWouldAffectCompilation());
   std::string options_2(
       translator_1->GetStringForOptionsThatWouldAffectCompilation());
   std::string options_3(
       translator_2->GetStringForOptionsThatWouldAffectCompilation());
   std::string options_4(
       translator_3->GetStringForOptionsThatWouldAffectCompilation());
 
   EXPECT_EQ(options_1, options_2);
   EXPECT_NE(options_1, options_3);
   EXPECT_NE(options_1, options_4);
   EXPECT_NE(options_3, options_4);
 }
 
 }  // namespace gles2
 }  // namespace gpu