Add support for GL_CHROMIUM_consistent_uniform_locations

gpu/command_buffer/service/program_manager.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 <set>
+#include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
@@ skipping 137 matching lines @@
       glUniformMatrix4fv(
           location, size, false, reinterpret_cast<const GLfloat*>(zero));
       break;
     default:
       NOTREACHED();
       break;
     }
   }
 }
 
+namespace {
+
+struct UniformData {
+  std::string queried_name;
+  std::string corrected_name;
+  std::string original_name;
+  GLsizei size;
+  GLenum type;
+};
+
+struct UniformDataComparer {
+  bool operator()(const UniformData& lhs, const UniformData& rhs) const {
+    return lhs.queried_name < rhs.queried_name;
+  }
+};
+
+}  // anonymous namespace
+
 void ProgramManager::ProgramInfo::Update() {
   Reset();
   UpdateLogInfo();
   link_status_ = true;
   uniforms_cleared_ = false;
   GLint num_attribs = 0;
   GLint max_len = 0;
   GLint max_location = -1;
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTES, &num_attribs);
   glGetProgramiv(service_id_, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_len);
@@ skipping 32 matching lines @@
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttribInfo& info = attrib_infos_[ii];
     attrib_location_to_index_map_[info.location] = ii;
   }
 
   max_len = 0;
   GLint num_uniforms = 0;
   glGetProgramiv(service_id_, GL_ACTIVE_UNIFORMS, &num_uniforms);
   glGetProgramiv(service_id_, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_len);
   name_buffer.reset(new char[max_len]);
+
+  // Read all the names first and sort them so we get a consistent list
+  std::vector<UniformData> uniform_data_;
   for (GLint ii = 0; ii < num_uniforms; ++ii) {
     GLsizei length = 0;
-    GLsizei size = 0;
-    GLenum type = 0;
+    UniformData data;
     glGetActiveUniform(
-        service_id_, ii, max_len, &length, &size, &type, name_buffer.get());
+        service_id_, ii, max_len, &length,
+        &data.size, &data.type, name_buffer.get());
     DCHECK(max_len == 0 || length < max_len);
     DCHECK(length == 0 || name_buffer[length] == '\0');
-    // TODO(gman): Should we check for error?
     if (!IsInvalidPrefix(name_buffer.get(), length)) {
-      GLint location = glGetUniformLocation(service_id_, name_buffer.get());
-      std::string name;
-      std::string original_name;
+      data.queried_name = std::string(name_buffer.get());
       GetCorrectedVariableInfo(
-          true, name_buffer.get(), &name, &original_name, &size, &type);
-      const UniformInfo* info = AddUniformInfo(
-          size, type, location, name, original_name);
-      if (info->IsSampler()) {
-        sampler_indices_.push_back(info->fake_location_base);
-      }
-      max_uniform_name_length_ =
-          std::max(max_uniform_name_length_,
-                   static_cast<GLsizei>(info->name.size()));
+          true, name_buffer.get(), &data.corrected_name, &data.original_name,
+          &data.size, &data.type);
+      uniform_data_.push_back(data);
     }
   }
+
+  std::sort(uniform_data_.begin(), uniform_data_.end(), UniformDataComparer());
+
+  for (size_t ii = 0; ii < uniform_data_.size(); ++ii) {
+    const UniformData& data = uniform_data_[ii];
+    GLint location = glGetUniformLocation(
+        service_id_, data.queried_name.c_str());
+    const UniformInfo* info = AddUniformInfo(
+        data.size, data.type, location, data.corrected_name,
+        data.original_name);
+    if (info->IsSampler()) {
+      sampler_indices_.push_back(info->fake_location_base);
+    }
+    max_uniform_name_length_ =
+        std::max(max_uniform_name_length_,
+                 static_cast<GLsizei>(info->name.size()));
+  }
   valid_ = true;
 }
 
 void ProgramManager::ProgramInfo::ExecuteBindAttribLocationCalls() {
   for (std::map<std::string, GLint>::const_iterator it =
            bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (mapped_name && *mapped_name != it->first)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
@@ skipping 52 matching lines @@
         bool bad = false;
         for (size_t pos = open_pos + 1; pos < last; ++pos) {
           int8 digit = name[pos] - '0';
           if (digit < 0 || digit > 9) {
             bad = true;
             break;
           }
           index = index * 10 + digit;
         }
         if (!bad && index >= 0 && index < info.size) {
-          return GetFakeLocation(info.fake_location_base, index);
+          return GLES2Util::MakeFakeLocation(info.fake_location_base, index);
         }
       }
     }
   }
   return -1;
 }
 
 GLint ProgramManager::ProgramInfo::GetAttribLocation(
     const std::string& name) const {
   for (GLuint ii = 0; ii < attrib_infos_.size(); ++ii) {
@@ skipping 325 matching lines @@
 
   for (size_t ii = 0; ii < uniform_infos_.size(); ++ii) {
     const UniformInfo& info = uniform_infos_[ii];
     inputs->size = info.size;
     inputs->type = info.type;
     inputs->location_offset = ComputeOffset(header, locations);
     inputs->name_offset = ComputeOffset(header, strings);
     inputs->name_length = info.name.size();
     DCHECK(static_cast<size_t>(info.size) == info.element_locations.size());
     for (size_t jj = 0; jj < info.element_locations.size(); ++jj) {
-      *locations++ = manager->SwizzleLocation(ii + jj * 0x10000);
+      *locations++ = GLES2Util::SwizzleLocation(
+          GLES2Util::MakeFakeLocation(ii, jj));
     }
     memcpy(strings, info.name.c_str(), info.name.size());
     strings += info.name.size();
     ++inputs;
   }
 
   DCHECK_EQ(ComputeOffset(header, strings), size);
 }
 
 ProgramManager::ProgramInfo::~ProgramInfo() {
   if (manager_) {
     if (manager_->have_context_) {
       glDeleteProgram(service_id());
     }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
-// TODO(gman): make this some kind of random number. Base::RandInt is not
-// callable because of the sandbox. What matters is that it's possibly different
-// by at least 1 bit each time chrome is run.
-static int uniform_random_offset_ = 3;
-
 ProgramManager::ProgramManager()
-    : uniform_swizzle_(uniform_random_offset_++ % 15),
-      program_info_count_(0),
+    : program_info_count_(0),
       have_context_(true),
       disable_workarounds_(
           CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableGpuDriverBugWorkarounds)) {
 }
 
 ProgramManager::~ProgramManager() {
   DCHECK(program_infos_.empty());
 }
 
@@ skipping 92 matching lines @@
   RemoveProgramInfoIfUnused(shader_manager, info);
 }
 
 void ProgramManager::ClearUniforms(ProgramManager::ProgramInfo* info) {
   DCHECK(info);
   if (!disable_workarounds_) {
     info->ClearUniforms(&zero_);
   }
 }
 
-// Swizzles the locations to prevent developers from assuming they
-// can do math on uniforms. According to the OpenGL ES 2.0 spec
-// the location of "someuniform[1]" is not 'n' more than "someuniform[0]".
-static GLint Swizzle(GLint location) {
-  return (location & 0xF0000000U) |
-         ((location & 0x0AAAAAAAU) >> 1) |
-         ((location & 0x05555555U) << 1);
-}
-
-// Adds uniform_swizzle_ to prevent developers from assuming that locations are
-// always the same across GPUs and drivers.
-GLint ProgramManager::SwizzleLocation(GLint v) const {
-  return v < 0 ? v : (Swizzle(v) + uniform_swizzle_);
-}
-
-GLint ProgramManager::UnswizzleLocation(GLint v) const {
-  return v < 0 ? v : Swizzle(v - uniform_swizzle_);
-}
-
 }  // namespace gles2
 }  // namespace gpu