command_buffer: Implement EXT_blend_func_extended

gpu/command_buffer/service/memory_program_cache_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 "gpu/command_buffer/service/memory_program_cache.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
@@ skipping 82 matching lines @@
                                                   GL_VERTEX_SHADER);
     fragment_shader_ = shader_manager_.CreateShader(
         kFragmentShaderClientId,
         kFragmentShaderServiceId,
         GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader_ != NULL);
     ASSERT_TRUE(fragment_shader_ != NULL);
     AttributeMap vertex_attrib_map;
     UniformMap vertex_uniform_map;
     VaryingMap vertex_varying_map;
+    OutputVariableList vertex_output_variable_list;
     AttributeMap fragment_attrib_map;
     UniformMap fragment_uniform_map;
     VaryingMap fragment_varying_map;
+    OutputVariableList fragment_output_variable_list;
 
     vertex_attrib_map["a"] = TestHelper::ConstructAttribute(
         GL_FLOAT_VEC2, 34, GL_LOW_FLOAT, false, "a");
     vertex_uniform_map["a"] = TestHelper::ConstructUniform(
         GL_FLOAT, 10, GL_MEDIUM_FLOAT, true, "a");
     vertex_uniform_map["b"] = TestHelper::ConstructUniform(
         GL_FLOAT_VEC3, 3114, GL_HIGH_FLOAT, true, "b");
     vertex_varying_map["c"] = TestHelper::ConstructVarying(
         GL_FLOAT_VEC4, 2, GL_HIGH_FLOAT, true, "c");
+    vertex_output_variable_list.push_back(TestHelper::ConstructOutputVariable(
+        GL_FLOAT, 0, GL_HIGH_FLOAT, true, "d"));
     fragment_attrib_map["jjjbb"] = TestHelper::ConstructAttribute(
         GL_FLOAT_MAT4, 1114, GL_MEDIUM_FLOAT, false, "jjjbb");
     fragment_uniform_map["k"] = TestHelper::ConstructUniform(
         GL_FLOAT_MAT2, 34413, GL_MEDIUM_FLOAT, true, "k");
     fragment_varying_map["c"] = TestHelper::ConstructVarying(
         GL_FLOAT_VEC4, 2, GL_HIGH_FLOAT, true, "c");
+    fragment_output_variable_list.push_back(TestHelper::ConstructOutputVariable(
+        GL_FLOAT, 0, GL_HIGH_FLOAT, true, "d"));
 
     vertex_shader_->set_source("bbbalsldkdkdkd");
     fragment_shader_->set_source("bbbal   sldkdkdkas 134 ad");
 
+    TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true, nullptr,
+                                nullptr, nullptr, &vertex_attrib_map,
+                                &vertex_uniform_map, &vertex_varying_map,
+                                nullptr, &vertex_output_variable_list, nullptr);
     TestHelper::SetShaderStates(
-        gl_.get(), vertex_shader_, true, NULL, NULL, NULL,
-        &vertex_attrib_map, &vertex_uniform_map, &vertex_varying_map,
-        NULL, NULL);
-    TestHelper::SetShaderStates(
-        gl_.get(), fragment_shader_, true, NULL, NULL, NULL,
+        gl_.get(), fragment_shader_, true, nullptr, nullptr, nullptr,
         &fragment_attrib_map, &fragment_uniform_map, &fragment_varying_map,
-        NULL, NULL);
+        nullptr, &fragment_output_variable_list, nullptr);
   }
 
   void SetExpectationsForSaveLinkedProgram(
       const GLint program_id,
       ProgramBinaryEmulator* emulator) const {
     EXPECT_CALL(*gl_.get(),
                 GetProgramiv(program_id, GL_PROGRAM_BINARY_LENGTH_OES, _))
         .WillOnce(SetArgPointee<2>(emulator->length()));
     EXPECT_CALL(*gl_.get(),
                 GetProgramBinary(program_id, emulator->length(), _, _, _))
@@ skipping 104 matching lines @@
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_,
                             fragment_shader_, NULL, varyings_, GL_NONE,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
   EXPECT_EQ(1, shader_cache_count());
 
   AttributeMap vertex_attrib_map = vertex_shader_->attrib_map();
   UniformMap vertex_uniform_map = vertex_shader_->uniform_map();
   VaryingMap vertex_varying_map = vertex_shader_->varying_map();
+  OutputVariableList vertex_output_variable_list =
+      vertex_shader_->output_variable_list();
   AttributeMap fragment_attrib_map = fragment_shader_->attrib_map();
   UniformMap fragment_uniform_map = fragment_shader_->uniform_map();
   VaryingMap fragment_varying_map = fragment_shader_->varying_map();
+  OutputVariableList fragment_output_variable_list =
+      fragment_shader_->output_variable_list();
 
   vertex_shader_->set_attrib_map(AttributeMap());
   vertex_shader_->set_uniform_map(UniformMap());
   vertex_shader_->set_varying_map(VaryingMap());
+  vertex_shader_->set_output_variable_list(OutputVariableList());
   fragment_shader_->set_attrib_map(AttributeMap());
   fragment_shader_->set_uniform_map(UniformMap());
   fragment_shader_->set_varying_map(VaryingMap());
-
+  fragment_shader_->set_output_variable_list(OutputVariableList());
   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 
   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
       kProgramId,
       vertex_shader_,
       fragment_shader_,
       NULL,
       varyings_,
       GL_NONE,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 
   // apparently the hash_map implementation on android doesn't have the
   // equality operator
 #if !defined(OS_ANDROID)
   EXPECT_EQ(vertex_attrib_map, vertex_shader_->attrib_map());
   EXPECT_EQ(vertex_uniform_map, vertex_shader_->uniform_map());
   EXPECT_EQ(vertex_varying_map, vertex_shader_->varying_map());
+  EXPECT_EQ(vertex_output_variable_list,
+            vertex_shader_->output_variable_list());
   EXPECT_EQ(fragment_attrib_map, fragment_shader_->attrib_map());
   EXPECT_EQ(fragment_uniform_map, fragment_shader_->uniform_map());
   EXPECT_EQ(fragment_varying_map, fragment_shader_->varying_map());
+  EXPECT_EQ(fragment_output_variable_list,
+            fragment_shader_->output_variable_list());
 #endif
 }
 
 TEST_F(MemoryProgramCacheTest, LoadProgramMatchesSave) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
     test_binary[i] = i;
   }
   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_,
                             fragment_shader_, NULL, varyings_, GL_NONE,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
   EXPECT_EQ(1, shader_cache_count());
 
   AttributeMap vertex_attrib_map = vertex_shader_->attrib_map();
   UniformMap vertex_uniform_map = vertex_shader_->uniform_map();
   VaryingMap vertex_varying_map = vertex_shader_->varying_map();
+  OutputVariableList vertex_output_variable_list =
+      vertex_shader_->output_variable_list();
   AttributeMap fragment_attrib_map = fragment_shader_->attrib_map();
   UniformMap fragment_uniform_map = fragment_shader_->uniform_map();
   VaryingMap fragment_varying_map = fragment_shader_->varying_map();
+  OutputVariableList fragment_output_variable_list =
+      fragment_shader_->output_variable_list();
 
   vertex_shader_->set_attrib_map(AttributeMap());
   vertex_shader_->set_uniform_map(UniformMap());
   vertex_shader_->set_varying_map(VaryingMap());
+  vertex_shader_->set_output_variable_list(OutputVariableList());
   fragment_shader_->set_attrib_map(AttributeMap());
   fragment_shader_->set_uniform_map(UniformMap());
   fragment_shader_->set_varying_map(VaryingMap());
+  fragment_shader_->set_output_variable_list(OutputVariableList());
 
   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 
   cache_->Clear();
   cache_->LoadProgram(shader_cache_shader());
 
   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
       kProgramId,
       vertex_shader_,
       fragment_shader_,
       NULL,
       varyings_,
       GL_NONE,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 
   // apparently the hash_map implementation on android doesn't have the
   // equality operator
 #if !defined(OS_ANDROID)
   EXPECT_EQ(vertex_attrib_map, vertex_shader_->attrib_map());
   EXPECT_EQ(vertex_uniform_map, vertex_shader_->uniform_map());
   EXPECT_EQ(vertex_varying_map, vertex_shader_->varying_map());
+  EXPECT_EQ(vertex_output_variable_list,
+            vertex_shader_->output_variable_list());
   EXPECT_EQ(fragment_attrib_map, fragment_shader_->attrib_map());
   EXPECT_EQ(fragment_uniform_map, fragment_shader_->uniform_map());
   EXPECT_EQ(fragment_varying_map, fragment_shader_->varying_map());
+  EXPECT_EQ(fragment_output_variable_list,
+            fragment_shader_->output_variable_list());
 #endif
 }
 
 TEST_F(MemoryProgramCacheTest, LoadFailOnLinkFalse) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
     test_binary[i] = i;
@@ skipping 295 matching lines @@
       fragment_shader_,
       NULL,
       varyings_,
       GL_NONE,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
 
 }  // namespace gles2
 }  // namespace gpu