Apply varying packing rule.

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/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 18 matching lines @@
 using ::testing::ReturnRef;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
+const uint32 kMaxVaryingVectors = 8;
+
 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
-}  // namespace
+}  // namespace anonymous
 
 class ProgramManagerTest : public testing::Test {
  public:
-  ProgramManagerTest() : manager_(NULL) { }
+  ProgramManagerTest() : manager_(NULL, kMaxVaryingVectors) { }
   virtual ~ProgramManagerTest() {
     manager_.Destroy(false);
   }
 
  protected:
   virtual void SetUp() {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
   }
 
@@ skipping 77 matching lines @@
   EXPECT_FALSE(program1->InUse());
   EXPECT_FALSE(program1->IsValid());
   EXPECT_FALSE(program1->IsDeleted());
   EXPECT_FALSE(program1->CanLink());
   EXPECT_TRUE(program1->log_info() == NULL);
 }
 
 class ProgramManagerWithShaderTest : public testing::Test {
  public:
   ProgramManagerWithShaderTest()
-      :  manager_(NULL), program_(NULL) {
+      :  manager_(NULL, kMaxVaryingVectors), program_(NULL) {
   }
 
   virtual ~ProgramManagerWithShaderTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
   static const GLint kNumVertexAttribs = 16;
 
   static const GLuint kClientProgramId = 123;
@@ skipping 49 matching lines @@
   static const GLenum kUniform3Type = GL_FLOAT_VEC3;
   static const GLint kInvalidUniformLocation = 30;
   static const GLint kBadUniformIndex = 1000;
 
   static const size_t kNumAttribs;
   static const size_t kNumUniforms;
 
  protected:
   typedef TestHelper::AttribInfo AttribInfo;
   typedef TestHelper::UniformInfo UniformInfo;
+  typedef struct {
+    int type;
+    int size;
+    int precision;
+    int static_use;
+    std::string name;
+  } VarInfo;
 
   virtual void SetUp() {
     gl_.reset(new StrictMock<gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
 
     SetupDefaultShaderExpectations();
 
     Shader* vertex_shader = shader_manager_.CreateShader(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     Shader* fragment_shader =
@@ skipping 43 matching lines @@
     if (expected_link_status) {
       SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                   service_id);
     }
     program->Link(NULL, NULL, NULL, NULL, base::Bind(&ShaderCacheCb));
     GLint link_status;
     program->GetProgramiv(GL_LINK_STATUS, &link_status);
     return (static_cast<bool>(link_status) == expected_link_status);
   }
 
-  Program* SetupVaryingsMatchingTest(bool vertex_varying_declare,
-                                     int vertex_varying_type,
-                                     int vertex_varying_size,
-                                     int vertex_varying_precision,
-                                     int vertex_varying_static_use,
-                                     bool frag_varying_declare,
-                                     int frag_varying_type,
-                                     int frag_varying_size,
-                                     int frag_varying_precision,
-                                     int frag_varying_static_use) {
+  Program* SetupVaryingsTest(const VarInfo* vertex_varyings,
+                             size_t vertex_varying_size,
+                             const VarInfo* fragment_varyings,
+                             size_t fragment_varying_size) {
     // Set up shader
     const GLuint kVShaderClientId = 1;
     const GLuint kVShaderServiceId = 11;
     const GLuint kFShaderClientId = 2;
     const GLuint kFShaderServiceId = 12;
 
     MockShaderTranslator vertex_shader_translator;
     ShaderTranslator::VariableMap vertex_attrib_map;
     ShaderTranslator::VariableMap vertex_uniform_map;
     ShaderTranslator::VariableMap vertex_varying_map;
-    if (vertex_varying_declare) {
-      vertex_varying_map["a"] = ShaderTranslator::VariableInfo(
-          vertex_varying_type, vertex_varying_size,
-          vertex_varying_precision, vertex_varying_static_use, "a");
+    for (size_t ii = 0; ii < vertex_varying_size; ++ii) {
+      vertex_varying_map[vertex_varyings[ii].name] =
+          ShaderTranslator::VariableInfo(vertex_varyings[ii].type,
+                                         vertex_varyings[ii].size,
+                                         vertex_varyings[ii].precision,
+                                         vertex_varyings[ii].static_use,
+                                         vertex_varyings[ii].name);
     }
     ShaderTranslator::NameMap vertex_name_map;
     EXPECT_CALL(vertex_shader_translator, attrib_map())
         .WillRepeatedly(ReturnRef(vertex_attrib_map));
     EXPECT_CALL(vertex_shader_translator, uniform_map())
         .WillRepeatedly(ReturnRef(vertex_uniform_map));
     EXPECT_CALL(vertex_shader_translator, varying_map())
         .WillRepeatedly(ReturnRef(vertex_varying_map));
     EXPECT_CALL(vertex_shader_translator, name_map())
       .WillRepeatedly(ReturnRef(vertex_name_map));
 
     MockShaderTranslator frag_shader_translator;
     ShaderTranslator::VariableMap frag_attrib_map;
     ShaderTranslator::VariableMap frag_uniform_map;
     ShaderTranslator::VariableMap frag_varying_map;
-    if (frag_varying_declare) {
-      frag_varying_map["a"] = ShaderTranslator::VariableInfo(
-          frag_varying_type, frag_varying_size,
-          frag_varying_precision, frag_varying_static_use, "a");
+    for (size_t ii = 0; ii < fragment_varying_size; ++ii) {
+      frag_varying_map[fragment_varyings[ii].name] =
+          ShaderTranslator::VariableInfo(fragment_varyings[ii].type,
+                                         fragment_varyings[ii].size,
+                                         fragment_varyings[ii].precision,
+                                         fragment_varyings[ii].static_use,
+                                         fragment_varyings[ii].name);
     }
     ShaderTranslator::NameMap frag_name_map;
     EXPECT_CALL(frag_shader_translator, attrib_map())
         .WillRepeatedly(ReturnRef(frag_attrib_map));
     EXPECT_CALL(frag_shader_translator, uniform_map())
         .WillRepeatedly(ReturnRef(frag_uniform_map));
     EXPECT_CALL(frag_shader_translator, varying_map())
         .WillRepeatedly(ReturnRef(frag_varying_map));
     EXPECT_CALL(frag_shader_translator, name_map())
       .WillRepeatedly(ReturnRef(frag_name_map));
@@ skipping 832 matching lines @@
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 
   EXPECT_TRUE(program->DetectUniformsMismatch());
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different type in the vertex and fragment
 // shader, linking should fail.
 TEST_F(ProgramManagerWithShaderTest, VaryingTypeMismatch) {
-  Program* program = SetupVaryingsMatchingTest(
-      true, SH_FLOAT_VEC3, 1, SH_PRECISION_MEDIUMP, 1,
-      true, SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1);
+  const VarInfo kVertexVarying =
+      { SH_FLOAT_VEC3, 1, SH_PRECISION_MEDIUMP, 1, "a" };
+  const VarInfo kFragmentVarying =
+      { SH_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a" };
+  Program* program = SetupVaryingsTest(
+      &kVertexVarying, 1, &kFragmentVarying, 1);
 
   EXPECT_TRUE(program->DetectVaryingsMismatch());
   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) {
-  Program* program = SetupVaryingsMatchingTest(
-      true, SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1,
-      true, SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1);
+  const VarInfo kVertexVarying =
+      { SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a" };
+  const VarInfo kFragmentVarying =
+      { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a" };
+  Program* program = SetupVaryingsTest(
+      &kVertexVarying, 1, &kFragmentVarying, 1);
 
   EXPECT_TRUE(program->DetectVaryingsMismatch());
   EXPECT_TRUE(LinkAsExpected(program, false));
 }
 
 // If a varying has different precision in the vertex and fragment
 // shader, linking should succeed.
 TEST_F(ProgramManagerWithShaderTest, VaryingPrecisionMismatch) {
-  Program* program = SetupVaryingsMatchingTest(
-      true, SH_FLOAT, 2, SH_PRECISION_HIGHP, 1,
-      true, SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1);
+  const VarInfo kVertexVarying =
+      { SH_FLOAT, 2, SH_PRECISION_HIGHP, 1, "a" };
+  const VarInfo kFragmentVarying =
+      { SH_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a" };
+  Program* program = SetupVaryingsTest(
+      &kVertexVarying, 1, &kFragmentVarying, 1);
 
   EXPECT_FALSE(program->DetectVaryingsMismatch());
   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) {
-  Program* program = SetupVaryingsMatchingTest(
-      false, 0, 0, 0, 0,
-      true, SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1);
+  const VarInfo kFragmentVarying =
+      { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a" };
+  Program* program = SetupVaryingsTest(
+      NULL, 0, &kFragmentVarying, 1);
 
   EXPECT_TRUE(program->DetectVaryingsMismatch());
   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) {
-  Program* program = SetupVaryingsMatchingTest(
-      false, 0, 0, 0, 0,
-      true, SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 0);
+  const VarInfo kFragmentVarying =
+      { SH_FLOAT, 3, SH_PRECISION_MEDIUMP, 0, "a" };
+  Program* program = SetupVaryingsTest(
+      NULL, 0, &kFragmentVarying, 1);
 
   EXPECT_FALSE(program->DetectVaryingsMismatch());
   EXPECT_TRUE(LinkAsExpected(program, true));
 }
 
+// Varyings go over 8 rows.
+TEST_F(ProgramManagerWithShaderTest, TooManyVaryings) {
+  const VarInfo kVertexVaryings[] = {
+      { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a" },
+      { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" }
+  };
+  const VarInfo kFragmentVaryings[] = {
+      { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a" },
+      { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" }
+  };
+  Program* program = SetupVaryingsTest(
+      kVertexVaryings, 2, kFragmentVaryings, 2);
+
+  EXPECT_FALSE(program->CheckVaryingsPacking());
+  EXPECT_TRUE(LinkAsExpected(program, false));
+}
+
+// Varyings go over 8 rows but some are inactive
+TEST_F(ProgramManagerWithShaderTest, TooManyInactiveVaryings) {
+  const VarInfo kVertexVaryings[] = {
+      { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a" },
+      { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" }
+  };
+  const VarInfo kFragmentVaryings[] = {
+      { SH_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 0, "a" },
+      { SH_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b" }
+  };
+  Program* program = SetupVaryingsTest(
+      kVertexVaryings, 2, kFragmentVaryings, 2);
+
+  EXPECT_TRUE(program->CheckVaryingsPacking());
+  EXPECT_TRUE(LinkAsExpected(program, true));
+}
+
 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) {
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   ASSERT_TRUE(vshader != NULL);
   vshader->SetStatus(true, NULL, NULL);
   Shader* fshader = shader_manager_.CreateShader(
@@ skipping 138 matching lines @@
  public:
   static const GLuint kClientProgramId = 1;
   static const GLuint kServiceProgramId = 10;
   static const GLuint kVertexShaderClientId = 2;
   static const GLuint kFragmentShaderClientId = 20;
   static const GLuint kVertexShaderServiceId = 3;
   static const GLuint kFragmentShaderServiceId = 30;
 
   ProgramManagerWithCacheTest()
       : cache_(new MockProgramCache()),
-        manager_(cache_.get()),
+        manager_(cache_.get(), kMaxVaryingVectors),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         program_(NULL) {
   }
   virtual ~ProgramManagerWithCacheTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
  protected:
@@ skipping 201 matching lines @@
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
   EXPECT_TRUE(program_->Link(NULL, NULL, NULL, NULL,
                              base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu