Add support for GL_CHROMIUM_consistent_uniform_locations

gpu/command_buffer/service/test_helper.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/test_helper.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_tokenizer.h"
 #include "gpu/command_buffer/common/gl_mock.h"
 #include "gpu/command_buffer/common/types.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#include <algorithm>
 #include <string.h>
 
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
@@ skipping 336 matching lines @@
           .Times(1)
           .RetiresOnSaturation();
       break;
     default:
       NOTREACHED();
       break;
     }
   }
 }
 
+namespace {
+
+struct UniformInfoComparer {
+  bool operator()(const TestHelper::UniformInfo& lhs,
+                  const TestHelper::UniformInfo& rhs) const {
+    return strcmp(lhs.name, rhs.name) < 0;
+  }
+};
+
+}  // anonymous namespace.
+
 void TestHelper::SetupShader(
     ::gfx::MockGLInterface* gl,
     AttribInfo* attribs, size_t num_attribs,
     UniformInfo* uniforms, size_t num_uniforms,
     GLuint service_id) {
   InSequence s;
 
   EXPECT_CALL(*gl,
       LinkProgram(service_id))
       .Times(1)
@@ skipping 12 matching lines @@
       .RetiresOnSaturation();
   size_t max_attrib_len = 0;
   for (size_t ii = 0; ii < num_attribs; ++ii) {
     size_t len = strlen(attribs[ii].name) + 1;
     max_attrib_len = std::max(max_attrib_len, len);
   }
   EXPECT_CALL(*gl,
       GetProgramiv(service_id, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
       .WillOnce(SetArgumentPointee<2>(max_attrib_len))
       .RetiresOnSaturation();
+
   for (size_t ii = 0; ii < num_attribs; ++ii) {
     const AttribInfo& info = attribs[ii];
     EXPECT_CALL(*gl,
         GetActiveAttrib(service_id, ii,
                         max_attrib_len, _, _, _, _))
         .WillOnce(DoAll(
             SetArgumentPointee<3>(strlen(info.name)),
             SetArgumentPointee<4>(info.size),
             SetArgumentPointee<5>(info.type),
             SetArrayArgument<6>(info.name,
                                 info.name + strlen(info.name) + 1)))
         .RetiresOnSaturation();
     if (!ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) {
       EXPECT_CALL(*gl, GetAttribLocation(service_id, StrEq(info.name)))
           .WillOnce(Return(info.location))
           .RetiresOnSaturation();
     }
   }
   EXPECT_CALL(*gl,
       GetProgramiv(service_id, GL_ACTIVE_UNIFORMS, _))
       .WillOnce(SetArgumentPointee<2>(num_uniforms))
       .RetiresOnSaturation();
+
+  scoped_array<UniformInfo> sorted_uniforms(new UniformInfo[num_uniforms]);
+  size_t num_valid_uniforms = 0;
+
   size_t max_uniform_len = 0;
   for (size_t ii = 0; ii < num_uniforms; ++ii) {
     size_t len = strlen(uniforms[ii].name) + 1;
     max_uniform_len = std::max(max_uniform_len, len);
   }
   EXPECT_CALL(*gl,
       GetProgramiv(service_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, _))
       .WillOnce(SetArgumentPointee<2>(max_uniform_len))
       .RetiresOnSaturation();
   for (size_t ii = 0; ii < num_uniforms; ++ii) {
     const UniformInfo& info = uniforms[ii];
     EXPECT_CALL(*gl,
         GetActiveUniform(service_id, ii,
                          max_uniform_len, _, _, _, _))
         .WillOnce(DoAll(
             SetArgumentPointee<3>(strlen(info.name)),
             SetArgumentPointee<4>(info.size),
             SetArgumentPointee<5>(info.type),
             SetArrayArgument<6>(info.name,
                                 info.name + strlen(info.name) + 1)))
         .RetiresOnSaturation();
     if (!ProgramManager::IsInvalidPrefix(info.name, strlen(info.name))) {
-      EXPECT_CALL(*gl, GetUniformLocation(service_id, StrEq(info.name)))
-          .WillOnce(Return(info.real_location))
-          .RetiresOnSaturation();
-      if (info.size > 1) {
-        std::string base_name = info.name;
-        size_t array_pos = base_name.rfind("[0]");
-        if (base_name.size() > 3 && array_pos == base_name.size() - 3) {
-          base_name = base_name.substr(0, base_name.size() - 3);
-        }
-        for (GLsizei jj = 1; jj < info.size; ++jj) {
-          std::string element_name(
-              std::string(base_name) + "[" + base::IntToString(jj) + "]");
-          EXPECT_CALL(*gl, GetUniformLocation(service_id, StrEq(element_name)))
-              .WillOnce(Return(info.real_location + jj * 2))
-              .RetiresOnSaturation();
-        }
+      sorted_uniforms[num_valid_uniforms++] = uniforms[ii];
+    }
+  }
+
+  std::sort(
+      &sorted_uniforms[0], &sorted_uniforms[num_valid_uniforms],
+      UniformInfoComparer());
+
+  for (size_t ii = 0; ii < num_valid_uniforms; ++ii) {
+    const UniformInfo& info = sorted_uniforms[ii];
+    EXPECT_CALL(*gl, GetUniformLocation(service_id, StrEq(info.name)))
+        .WillOnce(Return(info.real_location))
+        .RetiresOnSaturation();
+    if (info.size > 1) {
+      std::string base_name = info.name;
+      size_t array_pos = base_name.rfind("[0]");
+      if (base_name.size() > 3 && array_pos == base_name.size() - 3) {
+        base_name = base_name.substr(0, base_name.size() - 3);
+      }
+      for (GLsizei jj = 1; jj < info.size; ++jj) {
+        std::string element_name(
+            std::string(base_name) + "[" + base::IntToString(jj) + "]");
+        EXPECT_CALL(*gl, GetUniformLocation(service_id, StrEq(element_name)))
+            .WillOnce(Return(info.real_location + jj * 2))
+            .RetiresOnSaturation();
       }
     }
   }
 }
 
-
 }  // namespace gles2
 }  // namespace gpu