Check for shader version mismatch

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"
 
 namespace gpu {
@@ skipping 35 matching lines @@
 };
 
 TEST_F(ShaderTranslatorTest, ValidVertexShader) {
   const char* shader =
       "void main() {\n"
       "  gl_Position = vec4(1.0);\n"
       "}";
 
   // A valid shader should be successfully translated.
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   EXPECT_TRUE(vertex_translator_->Translate(shader,
                                             &info_log,
                                             &translated_source,
+                                            &shader_version,
                                             &attrib_map,
                                             &uniform_map,
                                             &varying_map,
                                             &name_map));
   // Info log must be NULL.
   EXPECT_TRUE(info_log.empty());
   // Translated shader must be valid and non-empty.
   ASSERT_FALSE(translated_source.empty());
   // There should be no attributes, uniforms, and only one built-in
   // varying: gl_Position.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_EQ(1u, varying_map.size());
   // There should be no name mapping.
   EXPECT_TRUE(name_map.empty());
 }
 
 TEST_F(ShaderTranslatorTest, InvalidVertexShader) {
   const char* bad_shader = "foo-bar";
   const char* good_shader =
       "void main() {\n"
       "  gl_Position = vec4(1.0);\n"
       "}";
 
   // An invalid shader should fail.
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   EXPECT_FALSE(vertex_translator_->Translate(bad_shader,
                                              &info_log,
                                              &translated_source,
+                                             &shader_version,
                                              &attrib_map,
                                              &uniform_map,
                                              &varying_map,
                                              &name_map));
   // Info log must be valid and non-empty.
   ASSERT_FALSE(info_log.empty());
   // Translated shader must be NULL.
   EXPECT_TRUE(translated_source.empty());
   // There should be no attributes, uniforms, varyings, or name mapping.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
   EXPECT_TRUE(name_map.empty());
 
   // Try a good shader after bad.
   info_log.clear();
   EXPECT_TRUE(vertex_translator_->Translate(good_shader,
                                             &info_log,
                                             &translated_source,
+                                            &shader_version,
                                             &attrib_map,
                                             &uniform_map,
                                             &varying_map,
                                             &name_map));
   EXPECT_TRUE(info_log.empty());
   EXPECT_FALSE(translated_source.empty());
 }
 
 TEST_F(ShaderTranslatorTest, ValidFragmentShader) {
   const char* shader =
       "void main() {\n"
       "  gl_FragColor = vec4(1.0);\n"
       "}";
 
   // A valid shader should be successfully translated.
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   EXPECT_TRUE(fragment_translator_->Translate(shader,
                                               &info_log,
                                               &translated_source,
+                                              &shader_version,
                                               &attrib_map,
                                               &uniform_map,
                                               &varying_map,
                                               &name_map));
   // Info log must be NULL.
   EXPECT_TRUE(info_log.empty());
   // Translated shader must be valid and non-empty.
   ASSERT_FALSE(translated_source.empty());
   // There should be no attributes, uniforms, varyings, or name mapping.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
   EXPECT_TRUE(name_map.empty());
 }
 
 TEST_F(ShaderTranslatorTest, InvalidFragmentShader) {
   const char* shader = "foo-bar";
 
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   // An invalid shader should fail.
   EXPECT_FALSE(fragment_translator_->Translate(shader,
                                                &info_log,
                                                &translated_source,
+                                               &shader_version,
                                                &attrib_map,
                                                &uniform_map,
                                                &varying_map,
                                                &name_map));
   // Info log must be valid and non-empty.
   EXPECT_FALSE(info_log.empty());
   // Translated shader must be NULL.
   EXPECT_TRUE(translated_source.empty());
   // There should be no attributes or uniforms.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
   EXPECT_TRUE(name_map.empty());
 }
 
 TEST_F(ShaderTranslatorTest, GetAttributes) {
   const char* shader =
       "attribute vec4 vPosition;\n"
       "void main() {\n"
       "  gl_Position = vPosition;\n"
       "}";
 
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   EXPECT_TRUE(vertex_translator_->Translate(shader,
                                             &info_log,
                                             &translated_source,
+                                            &shader_version,
                                             &attrib_map,
                                             &uniform_map,
                                             &varying_map,
                                             &name_map));
   // Info log must be NULL.
   EXPECT_TRUE(info_log.empty());
   // Translated shader must be valid and non-empty.
   EXPECT_FALSE(translated_source.empty());
   // There should be no uniforms.
   EXPECT_TRUE(uniform_map.empty());
@@ skipping 15 matching lines @@
       "};\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"
       "}";
 
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   EXPECT_TRUE(fragment_translator_->Translate(shader,
                                               &info_log,
                                               &translated_source,
+                                              &shader_version,
                                               &attrib_map,
                                               &uniform_map,
                                               &varying_map,
                                               &name_map));
   // Info log must be NULL.
   EXPECT_TRUE(info_log.empty());
   // Translated shader must be valid and non-empty.
   EXPECT_FALSE(translated_source.empty());
   // There should be no attributes.
   EXPECT_TRUE(attrib_map.empty());
@@ skipping 26 matching lines @@
 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 =
       "void main() {\n"
       "  gl_Position = vec4(dot(1.0, 1.0), 1.0, 1.0, 1.0);\n"
       "}";
 
   std::string info_log, translated_source;
+  int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   NameMap name_map;
   EXPECT_TRUE(vertex_translator_->Translate(shader,
                                             &info_log,
                                             &translated_source,
+                                            &shader_version,
                                             &attrib_map,
                                             &uniform_map,
                                             &varying_map,
                                             &name_map));
   // Info log must be NULL.
   EXPECT_TRUE(info_log.empty());
   // Translated shader must be valid and non-empty.
   ASSERT_FALSE(translated_source.empty());
   EXPECT_TRUE(strstr(translated_source.c_str(),
                      "webgl_dot_emu") != NULL);
@@ skipping 33 matching lines @@
 
   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