command_buffer: Implement EXT_blend_func_extended

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"
 #include "ui/gl/gl_version_info.h"
 
@@ skipping 80 matching lines @@
       "  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;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_TRUE(vertex_translator_->Translate(shader,
-                                            &info_log,
-                                            &translated_source,
-                                            &shader_version,
-                                            &attrib_map,
-                                            &uniform_map,
-                                            &varying_map,
-                                            &interface_block_map,
-                                            &name_map));
+  EXPECT_TRUE(vertex_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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_TRUE(interface_block_map.empty());
   EXPECT_EQ(1u, varying_map.size());
+  EXPECT_TRUE(output_variable_list.empty());
   // 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;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_FALSE(vertex_translator_->Translate(bad_shader,
-                                             &info_log,
-                                             &translated_source,
-                                             &shader_version,
-                                             &attrib_map,
-                                             &uniform_map,
-                                             &varying_map,
-                                             &interface_block_map,
-                                             &name_map));
+  EXPECT_FALSE(vertex_translator_->Translate(
+      bad_shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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, interface block or
   // name mapping.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
   EXPECT_TRUE(interface_block_map.empty());
+  EXPECT_TRUE(output_variable_list.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,
-                                            &interface_block_map,
-                                            &name_map));
+  EXPECT_TRUE(vertex_translator_->Translate(
+      good_shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &name_map));
   EXPECT_TRUE(info_log.empty());
   EXPECT_FALSE(translated_source.empty());
   EXPECT_TRUE(interface_block_map.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;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_TRUE(fragment_translator_->Translate(shader,
-                                              &info_log,
-                                              &translated_source,
-                                              &shader_version,
-                                              &attrib_map,
-                                              &uniform_map,
-                                              &varying_map,
-                                              &interface_block_map,
-                                              &name_map));
+  EXPECT_TRUE(fragment_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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, interface block or
   // name mapping.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
   EXPECT_TRUE(interface_block_map.empty());
   EXPECT_TRUE(name_map.empty());
+  // gl_FragColor.
+  EXPECT_EQ(1u, output_variable_list.size());
 }
 
 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;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   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,
-                                               &interface_block_map,
-                                               &name_map));
+  EXPECT_FALSE(fragment_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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, uniforms, varyings, interface block or
   // name mapping.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
+  EXPECT_TRUE(output_variable_list.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;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_TRUE(vertex_translator_->Translate(shader,
-                                            &info_log,
-                                            &translated_source,
-                                            &shader_version,
-                                            &attrib_map,
-                                            &uniform_map,
-                                            &varying_map,
-                                            &interface_block_map,
-                                            &name_map));
+  EXPECT_TRUE(vertex_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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());
   // There should be no interface blocks.
   EXPECT_TRUE(interface_block_map.empty());
   // There should be one attribute with following characteristics:
   // name:vPosition type:GL_FLOAT_VEC4 size:0.
@@ skipping 18 matching lines @@
       "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;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_TRUE(fragment_translator_->Translate(shader,
-                                              &info_log,
-                                              &translated_source,
-                                              &shader_version,
-                                              &attrib_map,
-                                              &uniform_map,
-                                              &varying_map,
-                                              &interface_block_map,
-                                              &name_map));
+  EXPECT_TRUE(fragment_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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());
   // There should be no interface blocks.
   EXPECT_TRUE(interface_block_map.empty());
   // There should be two uniforms with following characteristics:
   // 1. name:bar[0].foo.color[0] type:GL_FLOAT_VEC4 size:1
@@ skipping 11 matching lines @@
   EXPECT_EQ(1u, info->arraySize);
   EXPECT_STREQ("color", info->name.c_str());
   EXPECT_STREQ("bar[0].foo.color[0]", original_name.c_str());
   // Second uniform.
   EXPECT_TRUE(iter->second.findInfoByMappedName(
       "bar[1].foo.color[0]", &info, &original_name));
   EXPECT_EQ(static_cast<GLenum>(GL_FLOAT_VEC4), info->type);
   EXPECT_EQ(1u, info->arraySize);
   EXPECT_STREQ("color", info->name.c_str());
   EXPECT_STREQ("bar[1].foo.color[0]", original_name.c_str());
+  EXPECT_EQ(1u, output_variable_list.size());
+  ASSERT_TRUE(output_variable_list.size() > 0);
+  EXPECT_EQ(output_variable_list[0].mappedName, "gl_FragColor");
 }
 
 
 TEST_F(ES3ShaderTranslatorTest, InvalidInterfaceBlocks) {
   const char* shader =
       "#version 300 es\n"
       "precision mediump float;\n"
       "layout(location=0) out vec4 oColor;\n"
       "uniform Color {\n"
       "  float red;\n"
       "  float green;\n"
       "  float blue;\n"
       "};\n"
       "uniform Color2 {\n"
       "  float R;\n"
       "  float green;\n"
       "  float B;\n"
       "};\n"
       "void main() {\n"
       "  oColor = vec4(red * R, green * green, blue * B, 1.0);\n"
       "}";
 
   std::string info_log, translated_source;
   int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_FALSE(fragment_translator_->Translate(shader,
-                                               &info_log,
-                                               &translated_source,
-                                               &shader_version,
-                                               &attrib_map,
-                                               &uniform_map,
-                                               &varying_map,
-                                               &interface_block_map,
-                                               &name_map));
+  EXPECT_FALSE(fragment_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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, interface block or
   // name mapping.
   EXPECT_TRUE(attrib_map.empty());
   EXPECT_TRUE(uniform_map.empty());
   EXPECT_TRUE(varying_map.empty());
   EXPECT_TRUE(interface_block_map.empty());
@@ skipping 13 matching lines @@
       "void main() {\n"
       "  oColor = vec4(red, green, blue, 1.0);\n"
       "}";
 
   std::string info_log, translated_source;
   int shader_version;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
   InterfaceBlockMap interface_block_map;
+  OutputVariableList output_variable_list;
   NameMap name_map;
-  EXPECT_TRUE(fragment_translator_->Translate(shader,
-                                              &info_log,
-                                              &translated_source,
-                                              &shader_version,
-                                              &attrib_map,
-                                              &uniform_map,
-                                              &varying_map,
-                                              &interface_block_map,
-                                              &name_map));
+  EXPECT_TRUE(fragment_translator_->Translate(
+      shader, &info_log, &translated_source, &shader_version, &attrib_map,
+      &uniform_map, &varying_map, &interface_block_map, &output_variable_list,
+      &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());
   // There should be one block in interface_block_map
   EXPECT_EQ(1u, interface_block_map.size());
   InterfaceBlockMap::const_iterator iter;
   for (iter = interface_block_map.begin();
@@ skipping 64 matching lines @@
   ShShaderOutput shader_output_language =
       ShaderTranslator::GetShaderOutputLanguageForContext(
           output_context_version);
   ASSERT_TRUE(translator->Init(GL_VERTEX_SHADER, SH_GLES2_SPEC, &resources,
                                shader_output_language, compile_options));
 
   std::string translated_source;
   int shader_version;
   EXPECT_TRUE(translator->Translate(kShader, nullptr, &translated_source,
                                     &shader_version, nullptr, nullptr, nullptr,
-                                    nullptr, nullptr));
+                                    nullptr, nullptr, nullptr));
 
   std::string expected_version_directive = testing::get<1>(GetParam());
   if (expected_version_directive.empty()) {
     EXPECT_TRUE(translated_source.find("#version") == std::string::npos)
         << "Translation was:\n" << translated_source;
   } else {
     EXPECT_TRUE(translated_source.find(expected_version_directive) !=
                 std::string::npos)
         << "Translation was:\n" << translated_source;
   }
@@ skipping 56 matching lines @@
                         ShaderTranslatorOutputVersionTest,
                         testing::Values(make_gl_glsl_tuple("opengl es 2.0", ""),
                                         make_gl_glsl_tuple("opengl es 3.0", ""),
                                         make_gl_glsl_tuple("opengl es 3.1", ""),
                                         make_gl_glsl_tuple("opengl es 3.2",
                                                            "")));
 
 }  // namespace gles2
 }  // namespace gpu