Add support for GL_CHROMIUM_consistent_uniform_locations

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 
+#include <algorithm>
 #include <map>
+#include <queue>
 #include <set>
-#include <queue>
 #include <GLES2/gl2ext.h>
 #include "../client/mapped_memory.h"
 #include "../client/program_info_manager.h"
 #include "../client/query_tracker.h"
 #include "../client/transfer_buffer.h"
 #include "../common/gles2_cmd_utils.h"
 #include "../common/trace_event.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
@@ skipping 2061 matching lines @@
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetString(name, kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // Adds extensions implemented on client side only.
     switch (name) {
       case GL_EXTENSIONS:
         str += std::string(str.empty() ? "" : " ") +
             "GL_CHROMIUM_map_sub "
             "GL_CHROMIUM_flipy "
+            "GL_CHROMIUM_consistent_uniform_locations "
             "GL_EXT_unpack_subimage";
         break;
       default:
         break;
     }
 
     // Because of WebGL the extensions can change. We have to cache each unique
     // result since we don't know when the client will stop referring to a
     // previous one it queries.
     GLStringMap::iterator it = gl_strings_.find(name);
@@ skipping 1166 matching lines @@
   TRACE_EVENT0("gpu", "GLES2::GenMailboxCHROMIUM");
 
   helper_->GenMailboxCHROMIUM(kResultBucketId);
 
   std::vector<GLbyte> result;
   GetBucketContents(kResultBucketId, &result);
 
   std::copy(result.begin(), result.end(), mailbox);
 }
 
+namespace {
+
+class GLUniformDefinitionComparer {
+ public:
+  explicit GLUniformDefinitionComparer(
+      const GLUniformDefinitionCHROMIUM* uniforms)
+      : uniforms_(uniforms) {
+  }
+
+  bool operator()(const GLint lhs, const GLint rhs) const {
+    return strcmp(uniforms_[lhs].name, uniforms_[rhs].name) < 0;
+  }
+
+ private:
+  const GLUniformDefinitionCHROMIUM* uniforms_;
+};
+
+}  // anonymous namespace.
+
+void GLES2Implementation::GetUniformLocationsCHROMIUM(
+    const GLUniformDefinitionCHROMIUM* uniforms,
+    GLsizei count,
+    GLsizei max_locations,
+    GLint* locations) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << this << "] glGenUniformLocationsCHROMIUM("
+      << static_cast<const void*>(uniforms) << ", "  << count << ", "
+      << max_locations << ", " << static_cast<const void*>(locations) << ")");
+
+  if (count <= 0) {
+    SetGLError(GL_INVALID_VALUE, "glGetUniformLocationsCHROMIUM", "count <= 0");
+    return;
+  }
+
+  for (GLsizei ii = 0; ii < count; ++ii) {
+    const GLUniformDefinitionCHROMIUM& def = uniforms[ii];
+    if (def.size <= 0) {
+      SetGLError(
+          GL_INVALID_VALUE, "glGetUniformLocationsCHROMIUM", "size <= 0");
+      return;
+    }
+  }
+
+  scoped_array<GLint> indices(new GLint[count]);
+  for (GLint ii = 0; ii < count; ++ii) {
+    indices[ii] = ii;
+  }
+
+  std::sort(&indices[0], &indices[count],
+            GLUniformDefinitionComparer(uniforms));
+
+  scoped_array<GLint> reverse_map(new GLint[count]);
+
+  for (GLint ii = 0; ii < count; ++ii) {
+    reverse_map[indices[ii]] = ii;
+  }
+
+  for (GLsizei ii = 0; ii < count; ++ii) {
+    const GLUniformDefinitionCHROMIUM& def = uniforms[ii];
+    GLint base_location = reverse_map[ii];
+    for (GLsizei jj = 0; jj < def.size; ++jj) {
+      if (max_locations <= 0) {
+        return;
+      }
+      *locations++ = GLES2Util::SwizzleLocation(
+          GLES2Util::MakeFakeLocation(base_location, jj));
+      --max_locations;
+    }
+  }
+}
+
 }  // namespace gles2
 }  // namespace gpu