Swizzle Uniform Locations

gpu/command_buffer/service/program_manager.cc

 // Copyright (c) 2011 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/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/rand_util.h"
 #include "base/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 namespace gpu {
 namespace gles2 {
 
 static int ShaderTypeToIndex(GLenum shader_type) {
   switch (shader_type) {
     case GL_VERTEX_SHADER:
@@ skipping 421 matching lines @@
   }
   return true;
 }
 
 static uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
          static_cast<const uint8*>(start);
 }
 
 void ProgramManager::ProgramInfo::GetProgramInfo(
-    CommonDecoder::Bucket* bucket) const {
+    ProgramManager* manager, CommonDecoder::Bucket* bucket) const {
   // NOTE: It seems to me the math in here does not need check for overflow
   // because the data being calucated from has various small limits. The max
   // number of attribs + uniforms is somewhere well under 1024. The maximum size
   // of an identifier is 256 characters.
   uint32 num_locations = 0;
   uint32 total_string_size = 0;
 
   for (size_t ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttribInfo& info = attrib_infos_[ii];
     num_locations += 1;
@@ skipping 45 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++ = info.element_locations[jj];
+      *locations++ = manager->SwizzleLocation(info.element_locations[jj]);
     }
     memcpy(strings, info.name.c_str(), info.name.size());
     strings += info.name.size();
     ++inputs;
   }
 
   DCHECK_EQ(ComputeOffset(header, strings), size);
 }
 
 ProgramManager::ProgramInfo::~ProgramInfo() {}
 
-ProgramManager::ProgramManager() {}
+ProgramManager::ProgramManager()
+    : uniform_swizzle_(base::RandInt(0, 15)) {
+}
 
 ProgramManager::~ProgramManager() {
   DCHECK(program_infos_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   while (!program_infos_.empty()) {
     if (have_context) {
       ProgramInfo* info = program_infos_.begin()->second;
       if (!info->IsDeleted()) {
@@ skipping 79 matching lines @@
 void ProgramManager::UnuseProgram(
     ShaderManager* shader_manager,
     ProgramManager::ProgramInfo* info) {
   DCHECK(shader_manager);
   DCHECK(info);
   DCHECK(IsOwned(info));
   info->DecUseCount();
   RemoveProgramInfoIfUnused(shader_manager, info);
 }
 
+// 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 1 more than "someuniform[0]".
+static GLint Swizzle(GLint location) {
+  return (location & 0xFFFF0000U) |
+         ((location & 0x0000AAAAU) >> 1) |
+         ((location & 0x00005555U) << 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