command_buffer: Implement EXT_blend_func_extended

gpu/command_buffer/service/program_manager_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/program_manager.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_mock.h"
+#include "ui/gl/gl_version_info.h"
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgPointee;
 using ::testing::StrEq;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 const uint32 kMaxVaryingVectors = 8;
+const uint32 kMaxDrawBuffers = 8;
+const uint32 kMaxDualSourceDrawBuffers = 8;
 
 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
 
 uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
          static_cast<const uint8*>(start);
 }
 
 }  // namespace anonymous
 
 class ProgramManagerTestBase : public GpuServiceTest {
  protected:
   virtual void SetupProgramManager() {
-    manager_.reset(
-        new ProgramManager(NULL, kMaxVaryingVectors, feature_info_.get()));
+    manager_.reset(new ProgramManager(nullptr, kMaxVaryingVectors,
+                                      kMaxDualSourceDrawBuffers,
+                                      feature_info_.get()));
   }
   void SetUpBase(const char* gl_version,
                  const char* gl_extensions,
                  FeatureInfo* feature_info = NULL) {
     GpuServiceTest::SetUpWithGLVersion(gl_version, gl_extensions);
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
         gl_.get(), gl_extensions, "", gl_version);
     if (!feature_info) {
       feature_info = new FeatureInfo();
     }
@@ skipping 143 matching lines @@
   static const GLint kUniform3RealLocation = 33;
   static const GLint kUniform1DesiredLocation = -1;
   static const GLint kUniform2DesiredLocation = -1;
   static const GLint kUniform3DesiredLocation = -1;
   static const GLenum kUniform1Type = GL_FLOAT_VEC4;
   static const GLenum kUniform2Type = GL_INT_VEC2;
   static const GLenum kUniform3Type = GL_FLOAT_VEC3;
   static const GLint kInvalidUniformLocation = 30;
   static const GLint kBadUniformIndex = 1000;
 
+  static const char* kOutputVariable1Name;
+  static const GLint kOutputVariable1Size = 1;
+  static const GLenum kOutputVariable1Precision = GL_MEDIUM_FLOAT;
+  static const bool kOutputVariable1StaticUse = true;
+  static const GLint kOutputVariable1Location = -1;
+  static const GLenum kOutputVariable1Type = GL_FLOAT_VEC4;
+
   static const size_t kNumAttribs;
   static const size_t kNumUniforms;
 
  protected:
   typedef TestHelper::AttribInfo AttribInfo;
   typedef TestHelper::UniformInfo UniformInfo;
 
   typedef enum {
     kVarUniform,
     kVarVarying,
-    kVarAttribute
+    kVarAttribute,
+    kVarOutput,
   } VarCategory;
 
   typedef struct {
     GLenum type;
     GLint size;
     GLenum precision;
     bool static_use;
     std::string name;
     VarCategory category;
   } VarInfo;
@@ skipping 53 matching lines @@
       SetupShaderExpectations(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                               service_id);
     }
     program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                   base::Bind(&ShaderCacheCb));
     GLint link_status;
     program->GetProgramiv(GL_LINK_STATUS, &link_status);
     return (static_cast<bool>(link_status) == expected_link_status);
   }
 
-  Program* SetupShaderVariableTest(const VarInfo* vertex_variables,
-                                   size_t vertex_variable_size,
-                                   const VarInfo* fragment_variables,
-                                   size_t fragment_variable_size) {
+  Program* SetupProgramForVariables(const VarInfo* vertex_variables,
+                                    size_t vertex_variable_size,
+                                    const VarInfo* fragment_variables,
+                                    size_t fragment_variable_size,
+                                    const int* const shader_version = nullptr) {
     // Set up shader
     AttributeMap vertex_attrib_map;
     UniformMap vertex_uniform_map;
     VaryingMap vertex_varying_map;
+    OutputVariableList vertex_output_variable_list;
     for (size_t ii = 0; ii < vertex_variable_size; ++ii) {
       switch (vertex_variables[ii].category) {
         case kVarAttribute:
           vertex_attrib_map[vertex_variables[ii].name] =
               TestHelper::ConstructAttribute(
                   vertex_variables[ii].type,
                   vertex_variables[ii].size,
                   vertex_variables[ii].precision,
                   vertex_variables[ii].static_use,
                   vertex_variables[ii].name);
           break;
         case kVarUniform:
           vertex_uniform_map[vertex_variables[ii].name] =
               TestHelper::ConstructUniform(
                   vertex_variables[ii].type,
                   vertex_variables[ii].size,
                   vertex_variables[ii].precision,
                   vertex_variables[ii].static_use,
                   vertex_variables[ii].name);
           break;
         case kVarVarying:
           vertex_varying_map[vertex_variables[ii].name] =
               TestHelper::ConstructVarying(
                   vertex_variables[ii].type,
                   vertex_variables[ii].size,
                   vertex_variables[ii].precision,
                   vertex_variables[ii].static_use,
                   vertex_variables[ii].name);
           break;
+        case kVarOutput:
+          vertex_output_variable_list.push_back(
+              TestHelper::ConstructOutputVariable(
+                  vertex_variables[ii].type, vertex_variables[ii].size,
+                  vertex_variables[ii].precision,
+                  vertex_variables[ii].static_use, vertex_variables[ii].name));
+          break;
         default:
           NOTREACHED();
       }
     }
 
     AttributeMap frag_attrib_map;
     UniformMap frag_uniform_map;
     VaryingMap frag_varying_map;
+    OutputVariableList frag_output_variable_list;
     for (size_t ii = 0; ii < fragment_variable_size; ++ii) {
       switch (fragment_variables[ii].category) {
         case kVarAttribute:
           frag_attrib_map[fragment_variables[ii].name] =
               TestHelper::ConstructAttribute(
                   fragment_variables[ii].type,
                   fragment_variables[ii].size,
                   fragment_variables[ii].precision,
                   fragment_variables[ii].static_use,
                   fragment_variables[ii].name);
           break;
         case kVarUniform:
           frag_uniform_map[fragment_variables[ii].name] =
               TestHelper::ConstructUniform(
                   fragment_variables[ii].type,
                   fragment_variables[ii].size,
                   fragment_variables[ii].precision,
                   fragment_variables[ii].static_use,
                   fragment_variables[ii].name);
           break;
         case kVarVarying:
           frag_varying_map[fragment_variables[ii].name] =
               TestHelper::ConstructVarying(
                   fragment_variables[ii].type,
                   fragment_variables[ii].size,
                   fragment_variables[ii].precision,
                   fragment_variables[ii].static_use,
                   fragment_variables[ii].name);
           break;
+        case kVarOutput:
+          frag_output_variable_list.push_back(
+              TestHelper::ConstructOutputVariable(
+                  fragment_variables[ii].type, fragment_variables[ii].size,
+                  fragment_variables[ii].precision,
+                  fragment_variables[ii].static_use,
+                  fragment_variables[ii].name));
+          break;
         default:
           NOTREACHED();
       }
     }
 
     // Check we can create shader.
     Shader* vshader = shader_manager_.CreateShader(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     Shader* fshader = shader_manager_.CreateShader(
         kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
     // Check shader got created.
     EXPECT_TRUE(vshader != NULL && fshader != NULL);
     // Set Status
-    TestHelper::SetShaderStates(
-        gl_.get(), vshader, true, NULL, NULL, NULL,
-        &vertex_attrib_map, &vertex_uniform_map, &vertex_varying_map, NULL);
-    TestHelper::SetShaderStates(
-        gl_.get(), fshader, true, NULL, NULL, NULL,
-        &frag_attrib_map, &frag_uniform_map, &frag_varying_map, NULL);
+    TestHelper::SetShaderStates(gl_.get(), vshader, true, nullptr, nullptr,
+                                shader_version, &vertex_attrib_map,
+                                &vertex_uniform_map, &vertex_varying_map,
+                                &vertex_output_variable_list, nullptr);
+    TestHelper::SetShaderStates(gl_.get(), fshader, true, nullptr, nullptr,
+                                shader_version, &frag_attrib_map,
+                                &frag_uniform_map, &frag_varying_map,
+                                &frag_output_variable_list, nullptr);
 
     // Set up program
     Program* program =
         manager_->CreateProgram(kClientProgramId, kServiceProgramId);
     EXPECT_TRUE(program != NULL);
     EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
     EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
     return program;
   }
 
@@ skipping 90 matching lines @@
 const char* ProgramManagerWithShaderTest::kAttrib1Name = "attrib1";
 const char* ProgramManagerWithShaderTest::kAttrib2Name = "attrib2";
 const char* ProgramManagerWithShaderTest::kAttrib3Name = "attrib3";
 const char* ProgramManagerWithShaderTest::kUniform1Name = "uniform1";
 const char* ProgramManagerWithShaderTest::kUniform2Name = "uniform2";
 const char* ProgramManagerWithShaderTest::kUniform2NameWithArrayIndex =
     "uniform2[0]";
 const char* ProgramManagerWithShaderTest::kUniform3Name = "uniform3";
 const char* ProgramManagerWithShaderTest::kUniform3NameWithArrayIndex =
     "uniform3[0]";
+const char* ProgramManagerWithShaderTest::kOutputVariable1Name = "outputVar1";
 
 TEST_F(ProgramManagerWithShaderTest, GetAttribInfos) {
   const Program* program = SetupDefaultProgram();
   ASSERT_TRUE(program != NULL);
   const Program::AttribInfoVector& infos =
       program->GetAttribInfos();
   ASSERT_EQ(kNumAttribs, infos.size());
   for (size_t ii = 0; ii < kNumAttribs; ++ii) {
     const Program::VertexAttrib& info = infos[ii];
     const AttribInfo& expected = kAttribs[ii];
@@ skipping 283 matching lines @@
 // Some GL drivers incorrectly return the wrong type. For example they return
 // GL_FLOAT_VEC2 when they should return GL_FLOAT_MAT2. Check we handle this.
 TEST_F(ProgramManagerWithShaderTest, GLDriverReturnsWrongTypeInfo) {
   static GLenum kAttrib2BadType = GL_FLOAT_VEC2;
   static GLenum kAttrib2GoodType = GL_FLOAT_MAT2;
   static GLenum kUniform2BadType = GL_FLOAT_VEC3;
   static GLenum kUniform2GoodType = GL_FLOAT_MAT3;
   AttributeMap attrib_map;
   UniformMap uniform_map;
   VaryingMap varying_map;
+  OutputVariableList output_variable_list;
   attrib_map[kAttrib1Name] = TestHelper::ConstructAttribute(
       kAttrib1Type, kAttrib1Size, kAttrib1Precision,
       kAttribStaticUse, kAttrib1Name);
   attrib_map[kAttrib2Name] = TestHelper::ConstructAttribute(
       kAttrib2GoodType, kAttrib2Size, kAttrib2Precision,
       kAttribStaticUse, kAttrib2Name);
   attrib_map[kAttrib3Name] = TestHelper::ConstructAttribute(
       kAttrib3Type, kAttrib3Size, kAttrib3Precision,
       kAttribStaticUse, kAttrib3Name);
   uniform_map[kUniform1Name] = TestHelper::ConstructUniform(
       kUniform1Type, kUniform1Size, kUniform1Precision,
       kUniform1StaticUse, kUniform1Name);
   uniform_map[kUniform2Name] = TestHelper::ConstructUniform(
       kUniform2GoodType, kUniform2Size, kUniform2Precision,
       kUniform2StaticUse, kUniform2Name);
   uniform_map[kUniform3Name] = TestHelper::ConstructUniform(
       kUniform3Type, kUniform3Size, kUniform3Precision,
       kUniform3StaticUse, kUniform3Name);
+  output_variable_list.push_back(TestHelper::ConstructOutputVariable(
+      kOutputVariable1Type, kOutputVariable1Size, kOutputVariable1Precision,
+      kOutputVariable1StaticUse, kOutputVariable1Name));
+
   Shader* vshader = shader_manager_.CreateShader(
       kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
-  TestHelper::SetShaderStates(
-      gl_.get(), vshader, true, NULL, NULL, NULL,
-      &attrib_map, &uniform_map, &varying_map, NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true, nullptr, nullptr,
+                              nullptr, &attrib_map, &uniform_map, &varying_map,
+                              &output_variable_list, nullptr);
   Shader* fshader = shader_manager_.CreateShader(
       kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
-  TestHelper::SetShaderStates(
-      gl_.get(), fshader, true, NULL, NULL, NULL,
-      &attrib_map, &uniform_map, &varying_map, NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true, nullptr, nullptr,
+                              nullptr, &attrib_map, &uniform_map, &varying_map,
+                              &output_variable_list, nullptr);
   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
     { kAttrib2Name, kAttrib2Size, kAttrib2BadType, kAttrib2Location, },
     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
   };
   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
     { kUniform1Name,
       kUniform1Size,
       kUniform1Type,
       kUniform1FakeLocation,
@@ skipping 642 matching lines @@
       kAttribStaticUse,
       kAttribMatName);
   // Check we can create shader.
   Shader* vshader = shader_manager_.CreateShader(
       kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
   Shader* fshader = shader_manager_.CreateShader(
       kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
   // Check shader got created.
   ASSERT_TRUE(vshader != NULL && fshader != NULL);
   // Set Status
-  TestHelper::SetShaderStates(
-      gl_.get(), vshader, true, NULL, NULL, NULL, &attrib_map, NULL, NULL,
-      NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true, nullptr, nullptr,
+                              nullptr, &attrib_map, nullptr, nullptr, nullptr,
+                              nullptr);
   // Check attrib infos got copied.
   for (AttributeMap::const_iterator it = attrib_map.begin();
        it != attrib_map.end(); ++it) {
     const sh::Attribute* variable_info =
         vshader->GetAttribInfo(it->first);
     ASSERT_TRUE(variable_info != NULL);
     EXPECT_EQ(it->second.type, variable_info->type);
     EXPECT_EQ(it->second.arraySize, variable_info->arraySize);
     EXPECT_EQ(it->second.precision, variable_info->precision);
     EXPECT_EQ(it->second.staticUse, variable_info->staticUse);
     EXPECT_EQ(it->second.name, variable_info->name);
   }
-  TestHelper::SetShaderStates(
-      gl_.get(), fshader, true, NULL, NULL, NULL, &attrib_map, NULL, NULL,
-      NULL);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true, nullptr, nullptr,
+                              nullptr, &attrib_map, nullptr, nullptr, nullptr,
+                              nullptr);
 
   // Set up program
   Program* program =
       manager_->CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 
   EXPECT_FALSE(program->DetectAttribLocationBindingConflicts());
   EXPECT_TRUE(LinkAsExpected(program, true));
@@ skipping 46 matching lines @@
       GL_FLOAT, 3, GL_LOW_FLOAT, true, "a");
 
   // Check we can create shader.
   Shader* vshader = shader_manager_.CreateShader(
       kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
   Shader* fshader = shader_manager_.CreateShader(
       kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
   // Check shader got created.
   ASSERT_TRUE(vshader != NULL && fshader != NULL);
   // Set Status
-  TestHelper::SetShaderStates(
-      gl_.get(), vshader, true, NULL, NULL, NULL, NULL,
-      &vertex_uniform_map, NULL, NULL);
-  TestHelper::SetShaderStates(
-      gl_.get(), fshader, true, NULL, NULL, NULL, NULL,
-      &frag_uniform_map, NULL, NULL);
+  TestHelper::SetShaderStates(gl_.get(), vshader, true, nullptr, nullptr,
+                              nullptr, nullptr, &vertex_uniform_map, nullptr,
+                              nullptr, nullptr);
+  TestHelper::SetShaderStates(gl_.get(), fshader, true, nullptr, nullptr,
+                              nullptr, nullptr, &frag_uniform_map, nullptr,
+                              nullptr, nullptr);
 
   // Set up program
   Program* program =
       manager_->CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 
   std::string conflicting_name;
 
   EXPECT_TRUE(program->DetectUniformsMismatch(&conflicting_name));
   EXPECT_EQ("a", conflicting_name);
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different type in the vertex and fragment
 // shader, linking should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingTypeMismatch) {
   const VarInfo kVertexVarying =
       { GL_FLOAT_VEC3, 1, GL_MEDIUM_FLOAT, true, "a", kVarVarying };
   const VarInfo kFragmentVarying =
       { GL_FLOAT_VEC4, 1, GL_MEDIUM_FLOAT, true, "a", kVarVarying };
-  Program* program = SetupShaderVariableTest(
-      &kVertexVarying, 1, &kFragmentVarying, 1);
+  Program* program =
+      SetupProgramForVariables(&kVertexVarying, 1, &kFragmentVarying, 1);
 
   std::string conflicting_name;
 
   EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
   EXPECT_EQ("a", conflicting_name);
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different array size in the vertex and fragment
 // shader, linking should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingArraySizeMismatch) {
   const VarInfo kVertexVarying =
       { GL_FLOAT, 2, GL_MEDIUM_FLOAT, true, "a", kVarVarying };
   const VarInfo kFragmentVarying =
       { GL_FLOAT, 3, GL_MEDIUM_FLOAT, true, "a", kVarVarying };
-  Program* program = SetupShaderVariableTest(
-      &kVertexVarying, 1, &kFragmentVarying, 1);
+  Program* program =
+      SetupProgramForVariables(&kVertexVarying, 1, &kFragmentVarying, 1);
 
   std::string conflicting_name;
 
   EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
   EXPECT_EQ("a", conflicting_name);
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different precision in the vertex and fragment
 // shader, linking should succeed.
 TEST_F(ProgramManagerWithShaderTest, VaryingPrecisionMismatch) {
   const VarInfo kVertexVarying =
       { GL_FLOAT, 2, GL_HIGH_FLOAT, true, "a", kVarVarying };
   const VarInfo kFragmentVarying =
       { GL_FLOAT, 2, GL_MEDIUM_FLOAT, true, "a", kVarVarying };
-  Program* program = SetupShaderVariableTest(
-      &kVertexVarying, 1, &kFragmentVarying, 1);
+  Program* program =
+      SetupProgramForVariables(&kVertexVarying, 1, &kFragmentVarying, 1);
 
   std::string conflicting_name;
 
   EXPECT_FALSE(program->DetectVaryingsMismatch(&conflicting_name));
   EXPECT_TRUE(conflicting_name.empty());
   EXPECT_TRUE(LinkAsExpected(program, true));
 }
 
 // If a varying is statically used in fragment shader but not
 // declared in vertex shader, link should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingMissing) {
   const VarInfo kFragmentVarying =
       { GL_FLOAT, 3, GL_MEDIUM_FLOAT, true, "a", kVarVarying };
-  Program* program = SetupShaderVariableTest(
-      NULL, 0, &kFragmentVarying, 1);
+  Program* program = SetupProgramForVariables(nullptr, 0, &kFragmentVarying, 1);
 
   std::string conflicting_name;
 
   EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
   EXPECT_EQ("a", conflicting_name);
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying is declared but not statically used in fragment
 // shader, even if it's not declared in vertex shader, link should
 // succeed.
 TEST_F(ProgramManagerWithShaderTest, InactiveVarying) {
   const VarInfo kFragmentVarying =
       { GL_FLOAT, 3, GL_MEDIUM_FLOAT, false, "a", kVarVarying };
-  Program* program = SetupShaderVariableTest(
-      NULL, 0, &kFragmentVarying, 1);
+  Program* program = SetupProgramForVariables(nullptr, 0, &kFragmentVarying, 1);
 
   std::string conflicting_name;
 
   EXPECT_FALSE(program->DetectVaryingsMismatch(&conflicting_name));
   EXPECT_TRUE(conflicting_name.empty());
   EXPECT_TRUE(LinkAsExpected(program, true));
 }
 
 // Uniforms and attributes are both global variables, thus sharing
 // the same namespace. Any name conflicts should cause link
 // failure.
 TEST_F(ProgramManagerWithShaderTest, AttribUniformNameConflict) {
   const VarInfo kVertexAttribute =
       { GL_FLOAT_VEC4, 1, GL_MEDIUM_FLOAT, true, "a", kVarAttribute };
   const VarInfo kFragmentUniform =
       { GL_FLOAT_VEC4, 1, GL_MEDIUM_FLOAT, true, "a", kVarUniform };
-  Program* program = SetupShaderVariableTest(
-      &kVertexAttribute, 1, &kFragmentUniform, 1);
+  Program* program =
+      SetupProgramForVariables(&kVertexAttribute, 1, &kFragmentUniform, 1);
 
   std::string conflicting_name;
 
   EXPECT_TRUE(program->DetectGlobalNameConflicts(&conflicting_name));
   EXPECT_EQ("a", conflicting_name);
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // Varyings go over 8 rows.
 TEST_F(ProgramManagerWithShaderTest, TooManyVaryings) {
   const VarInfo kVertexVaryings[] = {
       { GL_FLOAT_VEC4, 4, GL_MEDIUM_FLOAT, true, "a", kVarVarying },
       { GL_FLOAT_VEC4, 5, GL_MEDIUM_FLOAT, true, "b", kVarVarying }
   };
   const VarInfo kFragmentVaryings[] = {
       { GL_FLOAT_VEC4, 4, GL_MEDIUM_FLOAT, true, "a", kVarVarying },
       { GL_FLOAT_VEC4, 5, GL_MEDIUM_FLOAT, true, "b", kVarVarying }
   };
-  Program* program = SetupShaderVariableTest(
-      kVertexVaryings, 2, kFragmentVaryings, 2);
+  Program* program =
+      SetupProgramForVariables(kVertexVaryings, 2, kFragmentVaryings, 2);
 
   EXPECT_FALSE(
       program->CheckVaryingsPacking(Program::kCountOnlyStaticallyUsed));
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // Varyings go over 8 rows but some are inactive
 TEST_F(ProgramManagerWithShaderTest, TooManyInactiveVaryings) {
   const VarInfo kVertexVaryings[] = {
       { GL_FLOAT_VEC4, 4, GL_MEDIUM_FLOAT, true, "a", kVarVarying },
       { GL_FLOAT_VEC4, 5, GL_MEDIUM_FLOAT, true, "b", kVarVarying }
   };
   const VarInfo kFragmentVaryings[] = {
       { GL_FLOAT_VEC4, 4, GL_MEDIUM_FLOAT, false, "a", kVarVarying },
       { GL_FLOAT_VEC4, 5, GL_MEDIUM_FLOAT, true, "b", kVarVarying }
   };
-  Program* program = SetupShaderVariableTest(
-      kVertexVaryings, 2, kFragmentVaryings, 2);
+  Program* program =
+      SetupProgramForVariables(kVertexVaryings, 2, kFragmentVaryings, 2);
 
   EXPECT_TRUE(
       program->CheckVaryingsPacking(Program::kCountOnlyStaticallyUsed));
   EXPECT_TRUE(LinkAsExpected(program, true));
 }
 
 // Varyings go over 8 rows but some are inactive.
 // However, we still fail the check if kCountAll option is used.
 TEST_F(ProgramManagerWithShaderTest, CountAllVaryingsInPacking) {
   const VarInfo kVertexVaryings[] = {
       { GL_FLOAT_VEC4, 4, GL_MEDIUM_FLOAT, true, "a", kVarVarying },
       { GL_FLOAT_VEC4, 5, GL_MEDIUM_FLOAT, true, "b", kVarVarying }
   };
   const VarInfo kFragmentVaryings[] = {
       { GL_FLOAT_VEC4, 4, GL_MEDIUM_FLOAT, false, "a", kVarVarying },
       { GL_FLOAT_VEC4, 5, GL_MEDIUM_FLOAT, true, "b", kVarVarying }
   };
-  Program* program = SetupShaderVariableTest(
-      kVertexVaryings, 2, kFragmentVaryings, 2);
+  Program* program =
+      SetupProgramForVariables(kVertexVaryings, 2, kFragmentVaryings, 2);
 
   EXPECT_FALSE(program->CheckVaryingsPacking(Program::kCountAll));
 }
 
 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) {
   Shader* vshader = shader_manager_.CreateShader(
       kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
@@ skipping 139 matching lines @@
   ProgramManagerWithCacheTest()
       : cache_(new MockProgramCache()),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         program_(NULL) {
   }
 
  protected:
   void SetupProgramManager() override {
     manager_.reset(new ProgramManager(cache_.get(), kMaxVaryingVectors,
+                                      kMaxDualSourceDrawBuffers,
                                       feature_info_.get()));
   }
 
   void SetUp() override {
     ProgramManagerTestBase::SetUp();
 
     vertex_shader_ = shader_manager_.CreateShader(
        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     fragment_shader_ = shader_manager_.CreateShader(
        kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader_ != NULL);
     ASSERT_TRUE(fragment_shader_ != NULL);
     vertex_shader_->set_source("lka asjf bjajsdfj");
     fragment_shader_->set_source("lka asjf a   fasgag 3rdsf3 bjajsdfj");
 
     program_ = manager_->CreateProgram(kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_ != NULL);
 
     program_->AttachShader(&shader_manager_, vertex_shader_);
     program_->AttachShader(&shader_manager_, fragment_shader_);
   }
+
   void TearDown() override {
     shader_manager_.Destroy(false);
     ProgramManagerTestBase::TearDown();
   }
+
   void SetShadersCompiled() {
     TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
     TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
   }
 
   void SetProgramCached() {
     cache_->LinkedProgramCacheSuccess(
         vertex_shader_->source(),
         fragment_shader_->source(),
         &program_->bind_attrib_location_map(),
@@ skipping 64 matching lines @@
                                   program_->transform_feedback_buffer_mode(),
                                   _))
         .WillOnce(Return(result));
   }
 
   void SetExpectationsForProgramLoadSuccess() {
     SetExpectationsForProgramLoadSuccess(kServiceProgramId);
   }
 
   void SetExpectationsForProgramLoadSuccess(GLuint service_program_id) {
-    TestHelper::SetupProgramSuccessExpectations(gl_.get(), feature_info_.get(),
-                                                nullptr, 0, nullptr, 0, nullptr,
-                                                0, service_program_id);
+    TestHelper::SetupProgramSuccessExpectations(
+        gl_.get(), feature_info_.get(), nullptr, 0, nullptr, 0, nullptr, 0,
+        nullptr, 0, service_program_id);
   }
 
   void SetExpectationsForProgramLink() {
     SetExpectationsForProgramLink(kServiceProgramId);
   }
 
   void SetExpectationsForProgramLink(GLuint service_program_id) {
     TestHelper::SetupShaderExpectations(gl_.get(), feature_info_.get(), nullptr,
                                         0, nullptr, 0, service_program_id);
     if (gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
@@ skipping 87 matching lines @@
   void SetUp() override {
     base::CommandLine command_line(*base::CommandLine::ForCurrentProcess());
     command_line.AppendSwitch(switches::kEnableGLPathRendering);
     FeatureInfo* feature_info = new FeatureInfo(command_line);
     SetUpBase(testing::get<0>(GetParam()), testing::get<1>(GetParam()),
               feature_info);
   }
   static const char* kFragmentInput1Name;
   static const char* kFragmentInput1GoodName;
   static const char* kFragmentInput2Name;
-  static const char* kFragmentInput2GoodName;
   static const char* kFragmentInput3Name;
   static const char* kFragmentInput3GoodName;
   static const GLint kFragmentInput1Size = 1;
   static const GLint kFragmentInput2Size = 3;
   static const GLint kFragmentInput3Size = 2;
   static const int kFragmentInput1Precision = GL_LOW_FLOAT;
   static const int kFragmentInput2Precision = GL_MEDIUM_INT;
   static const int kFragmentInput3Precision = GL_HIGH_FLOAT;
   static const int kFragmentInput1StaticUse = 1;
   static const int kFragmentInput2StaticUse = 1;
@@ skipping 26 matching lines @@
 const GLint ProgramManagerWithPathRenderingTest::kFragmentInput3RealLocation;
 const GLenum ProgramManagerWithPathRenderingTest::kFragmentInput1Type;
 const GLenum ProgramManagerWithPathRenderingTest::kFragmentInput2Type;
 const GLenum ProgramManagerWithPathRenderingTest::kFragmentInput3Type;
 #endif
 
 const char* ProgramManagerWithPathRenderingTest::kFragmentInput1Name = "color1";
 const char* ProgramManagerWithPathRenderingTest::kFragmentInput1GoodName =
     "color1[0]";
 const char* ProgramManagerWithPathRenderingTest::kFragmentInput2Name = "color2";
-const char* ProgramManagerWithPathRenderingTest::kFragmentInput2GoodName =
-    "color2[0]";
 const char* ProgramManagerWithPathRenderingTest::kFragmentInput3Name = "color3";
 const char* ProgramManagerWithPathRenderingTest::kFragmentInput3GoodName =
     "color3[0]";
 
 TEST_P(ProgramManagerWithPathRenderingTest, BindFragmentInputLocation) {
   const GLint kFragmentInput1DesiredLocation = 10;
   const GLint kFragmentInput2DesiredLocation = -1;
   const GLint kFragmentInput3DesiredLocation = 5;
 
   Shader* vshader = shader_manager_.CreateShader(
       kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   Shader* fshader = shader_manager_.CreateShader(
       kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   VaryingMap varying_map;
   varying_map[kFragmentInput1Name] = TestHelper::ConstructVarying(
       kFragmentInput1Type, kFragmentInput1Size, kFragmentInput1Precision,
       kFragmentInput1StaticUse, kFragmentInput1Name);
   varying_map[kFragmentInput2Name] = TestHelper::ConstructVarying(
       kFragmentInput2Type, kFragmentInput2Size, kFragmentInput2Precision,
       kFragmentInput2StaticUse, kFragmentInput2Name);
   varying_map[kFragmentInput3Name] = TestHelper::ConstructVarying(
       kFragmentInput3Type, kFragmentInput3Size, kFragmentInput3Precision,
       kFragmentInput3StaticUse, kFragmentInput3Name);
   TestHelper::SetShaderStates(gl_.get(), vshader, true, nullptr, nullptr,
-                              nullptr, nullptr, nullptr, &varying_map, nullptr);
+                              nullptr, nullptr, nullptr, &varying_map, nullptr,
+                              nullptr);
   TestHelper::SetShaderStates(gl_.get(), fshader, true, nullptr, nullptr,
-                              nullptr, nullptr, nullptr, &varying_map, nullptr);
+                              nullptr, nullptr, nullptr, &varying_map, nullptr,
+                              nullptr);
   Program* program =
       manager_->CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
   EXPECT_TRUE(program->SetFragmentInputLocationBinding(
       kFragmentInput1Name, kFragmentInput1DesiredLocation));
   EXPECT_TRUE(program->SetFragmentInputLocationBinding(
       kFragmentInput3Name, kFragmentInput3DesiredLocation));
   TestHelper::VaryingInfo kFragmentInputExpectationInfos[] = {
       {
           kFragmentInput1Name, kFragmentInput1Size, kFragmentInput1Type,
           kFragmentInput1FakeLocation, kFragmentInput1RealLocation,
           kFragmentInput1DesiredLocation,
       },
       {
           kFragmentInput2Name, kFragmentInput2Size, kFragmentInput2Type,
           kFragmentInput2FakeLocation, kFragmentInput2RealLocation,
           kFragmentInput2DesiredLocation,
       },
       {
           kFragmentInput3Name, kFragmentInput3Size, kFragmentInput3Type,
           kFragmentInput3FakeLocation, kFragmentInput3RealLocation,
           kFragmentInput3DesiredLocation,
       },
   };
   TestHelper::SetupShaderExpectationsWithVaryings(
       gl_.get(), feature_info_.get(), nullptr, 0, nullptr, 0,
       kFragmentInputExpectationInfos, arraysize(kFragmentInputExpectationInfos),
-      kServiceProgramId);
+      nullptr, 0, kServiceProgramId);
   program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
   GLint loc1 = 0;
   const Program::FragmentInputInfo* info1 =
       program->GetFragmentInputInfoByFakeLocation(
           kFragmentInput1DesiredLocation, &loc1);
   ASSERT_NE(info1, nullptr);
   EXPECT_EQ(kFragmentInput1GoodName, info1->name);
   EXPECT_EQ(kFragmentInput1RealLocation, info1->location);
   EXPECT_EQ(kFragmentInput1RealLocation, loc1);
@@ skipping 20 matching lines @@
 INSTANTIATE_TEST_CASE_P(
     SupportedContexts,
     ProgramManagerWithPathRenderingTest,
     testing::Values(
         make_gl_ext_tuple("3.2",
                           "GL_ARB_program_interface_query "
                           "GL_EXT_direct_state_access GL_NV_path_rendering"),
         make_gl_ext_tuple("4.5", "GL_NV_path_rendering"),
         make_gl_ext_tuple("opengl es 3.1", "GL_NV_path_rendering")));
 
+class ProgramManagerDualSourceBlendingTest
+    : public ProgramManagerWithShaderTest,
+      public testing::WithParamInterface<
+          testing::tuple<const char*, const char*>> {
+ public:
+  ProgramManagerDualSourceBlendingTest() {}
+
+ protected:
+  void SetUpWithFeatureInfo(FeatureInfo* feature_info) {
+    const char* gl_version = testing::get<0>(GetParam());
+    const char* gl_extensions = testing::get<1>(GetParam());
+    SetUpBase(gl_version, gl_extensions, feature_info);
+  }
+
+  void SetUp() override { SetUpWithFeatureInfo(nullptr); }
+};
+
+class ProgramManagerDualSourceBlendingES2Test
+    : public ProgramManagerDualSourceBlendingTest {};
+
+TEST_P(ProgramManagerDualSourceBlendingES2Test, UseSecondaryFragCoord) {
+  DCHECK(feature_info_->feature_flags().ext_blend_func_extended);
+
+  const VarInfo kFragmentVaryings[] = {
+      {GL_FLOAT_VEC4, 0, GL_MEDIUM_FLOAT, true, "gl_SecondaryFragColorEXT",
+       kVarOutput},
+      {GL_FLOAT_VEC4, 0, GL_MEDIUM_FLOAT, true, "gl_FragColor", kVarOutput},
+  };
+
+  int shader_version = 100;
+  Program* program =
+      SetupProgramForVariables(nullptr, 0, kFragmentVaryings,
+                               arraysize(kFragmentVaryings), &shader_version);
+
+  const gfx::GLVersionInfo& gl_version = feature_info_->gl_version_info();
+  if (!gl_version.is_es) {
+    // The call is expected only for OpenGL. OpenGL ES expects to
+    // output GLES SL 1.00, which does not bind.
+    EXPECT_CALL(*(gl_.get()),
+                BindFragDataLocationIndexed(kServiceProgramId, 0, 1,
+                                            StrEq("angle_SecondaryFragColor")))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+
+  EXPECT_TRUE(LinkAsExpected(program, true));
+}
+
+TEST_P(ProgramManagerDualSourceBlendingES2Test, UseSecondaryFragData) {
+  const VarInfo kFragmentVaryings[] = {
+      {GL_FLOAT_VEC4, kMaxDualSourceDrawBuffers, GL_MEDIUM_FLOAT, true,
+       "gl_SecondaryFragDataEXT", kVarOutput},
+      {GL_FLOAT_VEC4, kMaxDrawBuffers, GL_MEDIUM_FLOAT, true, "gl_FragData",
+       kVarOutput},
+  };
+
+  int shader_version = 100;
+  Program* program =
+      SetupProgramForVariables(nullptr, 0, kFragmentVaryings,
+                               arraysize(kFragmentVaryings), &shader_version);
+
+  const gfx::GLVersionInfo& gl_version = feature_info_->gl_version_info();
+  if (!gl_version.is_es) {
+    // The call is expected only for OpenGL. OpenGL ES expects to
+    // output GLES SL 1.00, which does not bind.
+    EXPECT_CALL(*(gl_.get()),
+                BindFragDataLocationIndexed(kServiceProgramId, 0, 1,
+                                            StrEq("angle_SecondaryFragData")))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+
+  EXPECT_TRUE(LinkAsExpected(program, true));
+}
+
+INSTANTIATE_TEST_CASE_P(
+    SupportedContexts,
+    ProgramManagerDualSourceBlendingES2Test,
+    testing::Values(
+        testing::make_tuple("3.2",
+                            "GL_ARB_draw_buffers GL_ARB_blend_func_extended "
+                            "GL_ARB_program_interface_query"),
+        testing::make_tuple("opengl es 3.1",
+                            "GL_EXT_draw_buffers GL_EXT_blend_func_extended")));
+
 }  // namespace gles2
 }  // namespace gpu