Update from https://crrev.com/316786

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 224 matching lines @@
     ASSERT_TRUE(fragment_shader != NULL);
     TestHelper::SetShaderStates(gl_.get(), vertex_shader, true);
     TestHelper::SetShaderStates(gl_.get(), fragment_shader, true);
 
     program_ = manager_.CreateProgram(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_ != NULL);
 
     program_->AttachShader(&shader_manager_, vertex_shader);
     program_->AttachShader(&shader_manager_, fragment_shader);
-    program_->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+    program_->Link(NULL, Program::kCountOnlyStaticallyUsed,
                    base::Bind(&ShaderCacheCb));
   }
 
   void SetupShader(AttribInfo* attribs, size_t num_attribs,
                    UniformInfo* uniforms, size_t num_uniforms,
                    GLuint service_id) {
     TestHelper::SetupShader(
         gl_.get(), attribs, num_attribs, uniforms, num_uniforms, service_id);
   }
 
   void SetupDefaultShaderExpectations() {
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
   }
 
   void SetupExpectationsForClearingUniforms(
       UniformInfo* uniforms, size_t num_uniforms) {
     TestHelper::SetupExpectationsForClearingUniforms(
         gl_.get(), uniforms, num_uniforms);
   }
 
   // Return true if link status matches expected_link_status
   bool LinkAsExpected(Program* program,
                       bool expected_link_status) {
     GLuint service_id = program->service_id();
     if (expected_link_status) {
       SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                   service_id);
     }
-    program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+    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) {
@@ skipping 422 matching lines @@
   TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   TestHelper::SetShaderStates(gl_.get(), fshader, true);
   Program* program =
       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
-  program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+  program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
   GLint value = 0;
   program->GetProgramiv(GL_ACTIVE_ATTRIBUTES, &value);
   EXPECT_EQ(3, value);
   // Check that we skipped the "gl_" uniform.
   program->GetProgramiv(GL_ACTIVE_UNIFORMS, &value);
   EXPECT_EQ(2, value);
   // Check that our max length adds room for the array spec and is not as long
   // as the "gl_" uniform we skipped.
   // +4u is to account for "gl_" and NULL terminator.
@@ skipping 48 matching lines @@
   TestHelper::SetShaderStates(gl_.get(), vshader, true);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   TestHelper::SetShaderStates(gl_.get(), fshader, true);
   Program* program =
       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program != NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
-  program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+  program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
 
   // Check that we get the correct locations.
   EXPECT_EQ(kUniform2FakeLocation,
             program->GetUniformFakeLocation(kUniform2Name));
   EXPECT_EQ(kUniform3FakeLocation,
             program->GetUniformFakeLocation(kUniform3Name));
 }
 
 // Some GL drivers incorrectly return the wrong type. For example they return
@@ skipping 75 matching lines @@
   const size_t kNumUniforms = arraysize(kUniforms);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
   Program* program = manager_.CreateProgram(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program!= NULL);
   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
-  program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+  program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
   // Check that we got the good type, not the bad.
   // Check Attribs
   for (unsigned index = 0; index < kNumAttribs; ++index) {
     const Program::VertexAttrib* attrib_info =
         program->GetAttribInfo(index);
     ASSERT_TRUE(attrib_info != NULL);
     size_t pos = attrib_info->name.find_first_of("[.");
     std::string top_name;
     if (pos == std::string::npos)
@@ skipping 326 matching lines @@
             kIndices[ii], kIndices[ii] + data.entry[ii].active_uniforms))
         .RetiresOnSaturation();
   }
   program->GetUniformBlocks(&bucket);
   EXPECT_EQ(sizeof(Data), bucket.size());
   Data* bucket_data = bucket.GetDataAs<Data*>(0, sizeof(Data));
   EXPECT_TRUE(bucket_data != NULL);
   EXPECT_EQ(0, memcmp(&data, bucket_data, sizeof(Data)));
 }
 
+TEST_F(ProgramManagerWithShaderTest,
+       ProgramInfoGetTransformFeedbackVaryingsNone) {
+  CommonDecoder::Bucket bucket;
+  const Program* program = manager_.GetProgram(kClientProgramId);
+  ASSERT_TRUE(program != NULL);
+  // The program's previous link failed.
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
+      .WillOnce(SetArgPointee<2>(GL_FALSE))
+      .RetiresOnSaturation();
+  EXPECT_TRUE(program->GetTransformFeedbackVaryings(&bucket));
+  EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket.size());
+  TransformFeedbackVaryingsHeader* header =
+      bucket.GetDataAs<TransformFeedbackVaryingsHeader*>(
+          0, sizeof(TransformFeedbackVaryingsHeader));
+  EXPECT_TRUE(header != NULL);
+  EXPECT_EQ(0u, header->num_transform_feedback_varyings);
+  // Zero uniform blocks.
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
+      .WillOnce(SetArgPointee<2>(GL_TRUE))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(
+                  kServiceProgramId, GL_TRANSFORM_FEEDBACK_VARYINGS, _))
+      .WillOnce(SetArgPointee<2>(0))
+      .RetiresOnSaturation();
+  EXPECT_TRUE(program->GetTransformFeedbackVaryings(&bucket));
+  EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket.size());
+  header = bucket.GetDataAs<TransformFeedbackVaryingsHeader*>(
+      0, sizeof(TransformFeedbackVaryingsHeader));
+  EXPECT_TRUE(header != NULL);
+  EXPECT_EQ(0u, header->num_transform_feedback_varyings);
+}
+
+TEST_F(ProgramManagerWithShaderTest,
+       ProgramInfoGetTransformFeedbackVaryingsValid) {
+  CommonDecoder::Bucket bucket;
+  const Program* program = manager_.GetProgram(kClientProgramId);
+  ASSERT_TRUE(program != NULL);
+  struct Data {
+    TransformFeedbackVaryingsHeader header;
+    TransformFeedbackVaryingInfo entry[2];
+    char name0[4];
+    char name1[8];
+  };
+  Data data;
+  // The names needs to be of size 4*k-1 to avoid padding in the struct Data.
+  // This is a testing only problem.
+  const char* kName[] = { "cow", "chicken" };
+  data.header.num_transform_feedback_varyings = 2;
+  data.entry[0].size = 1;
+  data.entry[0].type = GL_FLOAT_VEC2;
+  data.entry[0].name_offset = ComputeOffset(&data, data.name0);
+  data.entry[0].name_length = arraysize(data.name0);
+  data.entry[1].size = 2;
+  data.entry[1].type = GL_FLOAT;
+  data.entry[1].name_offset = ComputeOffset(&data, data.name1);
+  data.entry[1].name_length = arraysize(data.name1);
+  memcpy(data.name0, kName[0], arraysize(data.name0));
+  memcpy(data.name1, kName[1], arraysize(data.name1));
+
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
+      .WillOnce(SetArgPointee<2>(GL_TRUE))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(
+                  kServiceProgramId, GL_TRANSFORM_FEEDBACK_VARYINGS, _))
+      .WillOnce(SetArgPointee<2>(data.header.num_transform_feedback_varyings))
+      .RetiresOnSaturation();
+  GLsizei max_length = 1 + std::max(strlen(kName[0]), strlen(kName[1]));
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId,
+                           GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, _))
+      .WillOnce(SetArgPointee<2>(max_length))
+      .RetiresOnSaturation();
+  for (uint32_t ii = 0; ii < data.header.num_transform_feedback_varyings;
+       ++ii) {
+    EXPECT_CALL(*(gl_.get()),
+                GetTransformFeedbackVarying(
+                    kServiceProgramId, ii, max_length, _, _, _, _))
+        .WillOnce(DoAll(
+            SetArgPointee<3>(data.entry[ii].name_length - 1),
+            SetArgPointee<4>(data.entry[ii].size),
+            SetArgPointee<5>(data.entry[ii].type),
+            SetArrayArgument<6>(
+                kName[ii], kName[ii] + data.entry[ii].name_length)))
+        .RetiresOnSaturation();
+  }
+  program->GetTransformFeedbackVaryings(&bucket);
+  EXPECT_EQ(sizeof(Data), bucket.size());
+  Data* bucket_data = bucket.GetDataAs<Data*>(0, sizeof(Data));
+  EXPECT_TRUE(bucket_data != NULL);
+  EXPECT_EQ(0, memcmp(&data, bucket_data, sizeof(Data)));
+}
+
+TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetUniformsES3None) {
+  CommonDecoder::Bucket bucket;
+  const Program* program = manager_.GetProgram(kClientProgramId);
+  ASSERT_TRUE(program != NULL);
+  // The program's previous link failed.
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
+      .WillOnce(SetArgPointee<2>(GL_FALSE))
+      .RetiresOnSaturation();
+  EXPECT_TRUE(program->GetUniformsES3(&bucket));
+  EXPECT_EQ(sizeof(UniformsES3Header), bucket.size());
+  UniformsES3Header* header =
+      bucket.GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header));
+  EXPECT_TRUE(header != NULL);
+  EXPECT_EQ(0u, header->num_uniforms);
+  // Zero uniform blocks.
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
+      .WillOnce(SetArgPointee<2>(GL_TRUE))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
+      .WillOnce(SetArgPointee<2>(0))
+      .RetiresOnSaturation();
+  EXPECT_TRUE(program->GetUniformsES3(&bucket));
+  EXPECT_EQ(sizeof(UniformsES3Header), bucket.size());
+  header =
+      bucket.GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header));
+  EXPECT_TRUE(header != NULL);
+  EXPECT_EQ(0u, header->num_uniforms);
+}
+
+TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetUniformsES3Valid) {
+  CommonDecoder::Bucket bucket;
+  const Program* program = manager_.GetProgram(kClientProgramId);
+  ASSERT_TRUE(program != NULL);
+  struct Data {
+    UniformsES3Header header;
+    UniformES3Info entry[2];
+  };
+  Data data;
+  const GLint kBlockIndex[] = { -1, 2 };
+  const GLint kOffset[] = { 3, 4 };
+  const GLint kArrayStride[] = { 7, 8 };
+  const GLint kMatrixStride[] = { 9, 10 };
+  const GLint kIsRowMajor[] = { 0, 1 };
+  data.header.num_uniforms = 2;
+  for (uint32_t ii = 0; ii < data.header.num_uniforms; ++ii) {
+    data.entry[ii].block_index = kBlockIndex[ii];
+    data.entry[ii].offset = kOffset[ii];
+    data.entry[ii].array_stride = kArrayStride[ii];
+    data.entry[ii].matrix_stride = kMatrixStride[ii];
+    data.entry[ii].is_row_major = kIsRowMajor[ii];
+  }
+
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
+      .WillOnce(SetArgPointee<2>(GL_TRUE))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*(gl_.get()),
+              GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
+      .WillOnce(SetArgPointee<2>(data.header.num_uniforms))
+      .RetiresOnSaturation();
+
+  const GLenum kPname[] = {
+    GL_UNIFORM_BLOCK_INDEX,
+    GL_UNIFORM_OFFSET,
+    GL_UNIFORM_ARRAY_STRIDE,
+    GL_UNIFORM_MATRIX_STRIDE,
+    GL_UNIFORM_IS_ROW_MAJOR,
+  };
+  const GLint* kParams[] = {
+    kBlockIndex,
+    kOffset,
+    kArrayStride,
+    kMatrixStride,
+    kIsRowMajor,
+  };
+  const size_t kNumIterations = arraysize(kPname);
+  for (size_t ii = 0; ii < kNumIterations; ++ii) {
+    EXPECT_CALL(*(gl_.get()),
+                GetActiveUniformsiv(
+                    kServiceProgramId, data.header.num_uniforms, _,
+                    kPname[ii], _))
+      .WillOnce(SetArrayArgument<4>(
+          kParams[ii], kParams[ii] + data.header.num_uniforms))
+      .RetiresOnSaturation();
+  }
+
+  program->GetUniformsES3(&bucket);
+  EXPECT_EQ(sizeof(Data), bucket.size());
+  Data* bucket_data = bucket.GetDataAs<Data*>(0, sizeof(Data));
+  EXPECT_TRUE(bucket_data != NULL);
+  EXPECT_EQ(0, memcmp(&data, bucket_data, sizeof(Data)));
+}
+
 // Some drivers optimize out unused uniform array elements, so their
 // location would be -1.
 TEST_F(ProgramManagerWithShaderTest, UnusedUniformArrayElements) {
   CommonDecoder::Bucket bucket;
   const Program* program = manager_.GetProgram(kClientProgramId);
   ASSERT_TRUE(program != NULL);
   // Emulate the situation that only the first element has a valid location.
   // TODO(zmo): Don't assume these are in order.
   for (size_t ii = 0; ii < arraysize(kUniforms); ++ii) {
     Program::UniformInfo* uniform = const_cast<Program::UniformInfo*>(
@@ skipping 384 matching lines @@
         kUniform3FakeLocation,
         kUniform3RealLocation,
         kUniform3DesiredLocation,
         kUniform3NameWithArrayIndex,
       },
     };
     const size_t kNumAttribs = arraysize(kAttribs);
     const size_t kNumUniforms = arraysize(kUniforms);
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
-    program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+    program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                   base::Bind(&ShaderCacheCb));
     SetupExpectationsForClearingUniforms(kUniforms, kNumUniforms);
     manager_.ClearUniforms(program);
   }
 }
 
 TEST_F(ProgramManagerWithShaderTest, BindUniformLocation) {
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
@@ skipping 52 matching lines @@
       kUniform3RealLocation,
       kUniform3DesiredLocation,
       kUniform3NameWithArrayIndex,
     },
   };
 
   const size_t kNumAttribs = arraysize(kAttribs);
   const size_t kNumUniforms = arraysize(kUniforms);
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
-  program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
+  program->Link(NULL, Program::kCountOnlyStaticallyUsed,
                 base::Bind(&ShaderCacheCb));
 
   EXPECT_EQ(kUniform1DesiredLocation,
             program->GetUniformFakeLocation(kUniform1Name));
   EXPECT_EQ(kUniform3DesiredLocation,
             program->GetUniformFakeLocation(kUniform3Name));
   EXPECT_EQ(kUniform3DesiredLocation,
             program->GetUniformFakeLocation(kUniform3NameWithArrayIndex));
 }
 
@@ skipping 40 matching lines @@
   }
 
   void SetShadersCompiled() {
     TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
     TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
   }
 
   void SetProgramCached() {
     cache_->LinkedProgramCacheSuccess(
         vertex_shader_->source(),
-        NULL,
         fragment_shader_->source(),
-        NULL,
         &program_->bind_attrib_location_map());
   }
 
   void SetExpectationsForProgramCached() {
     SetExpectationsForProgramCached(program_,
                                     vertex_shader_,
                                     fragment_shader_);
   }
 
   void SetExpectationsForProgramCached(
       Program* program,
       Shader* vertex_shader,
       Shader* fragment_shader) {
     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
         program->service_id(),
         vertex_shader,
-        NULL,
         fragment_shader,
-        NULL,
         &program->bind_attrib_location_map(),
         _)).Times(1);
   }
 
   void SetExpectationsForNotCachingProgram() {
     SetExpectationsForNotCachingProgram(program_,
                                         vertex_shader_,
                                         fragment_shader_);
   }
 
   void SetExpectationsForNotCachingProgram(
       Program* program,
       Shader* vertex_shader,
       Shader* fragment_shader) {
     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
         program->service_id(),
         vertex_shader,
-        NULL,
         fragment_shader,
-        NULL,
         &program->bind_attrib_location_map(),
         _)).Times(0);
   }
 
   void SetExpectationsForProgramLoad(ProgramCache::ProgramLoadResult result) {
     SetExpectationsForProgramLoad(kServiceProgramId,
                                   program_,
                                   vertex_shader_,
                                   fragment_shader_,
                                   result);
   }
 
   void SetExpectationsForProgramLoad(
       GLuint service_program_id,
       Program* program,
       Shader* vertex_shader,
       Shader* fragment_shader,
       ProgramCache::ProgramLoadResult result) {
     EXPECT_CALL(*cache_.get(),
                 LoadLinkedProgram(service_program_id,
                                   vertex_shader,
-                                  NULL,
                                   fragment_shader,
-                                  NULL,
                                   &program->bind_attrib_location_map(),
                                   _))
         .WillOnce(Return(result));
   }
 
   void SetExpectationsForProgramLoadSuccess() {
     SetExpectationsForProgramLoadSuccess(kServiceProgramId);
   }
 
   void SetExpectationsForProgramLoadSuccess(GLuint service_program_id) {
@@ skipping 70 matching lines @@
 const GLuint ProgramManagerWithCacheTest::kVertexShaderClientId;
 const GLuint ProgramManagerWithCacheTest::kFragmentShaderClientId;
 const GLuint ProgramManagerWithCacheTest::kVertexShaderServiceId;
 const GLuint ProgramManagerWithCacheTest::kFragmentShaderServiceId;
 #endif
 
 TEST_F(ProgramManagerWithCacheTest, CacheProgramOnSuccessfulLink) {
   SetShadersCompiled();
   SetExpectationsForProgramLink();
   SetExpectationsForProgramCached();
-  EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
-      Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
+  EXPECT_TRUE(program_->Link(NULL, Program::kCountOnlyStaticallyUsed,
+                             base::Bind(&ShaderCacheCb)));
 }
 
 TEST_F(ProgramManagerWithCacheTest, LoadProgramOnProgramCacheHit) {
   SetShadersCompiled();
   SetProgramCached();
 
   SetExpectationsForNoCompile(vertex_shader_);
   SetExpectationsForNoCompile(fragment_shader_);
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
-  EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
-      Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
+  EXPECT_TRUE(program_->Link(NULL, Program::kCountOnlyStaticallyUsed,
+                             base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu