Add glGetActiveUniformsiv to GPU command buffer.

gpu/command_buffer/client/program_info_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/client/program_info_manager.h"
 
 namespace {
 
 template<typename T> static T LocalGetAs(
     const std::vector<int8>& data, uint32 offset, size_t size) {
@@ skipping 26 matching lines @@
     : size(_size),
       type(_type),
       name(_name) {
   is_array = (!name.empty() && name[name.size() - 1] == ']');
   DCHECK(!(size > 1 && !is_array));
 }
 
 ProgramInfoManager::Program::UniformInfo::~UniformInfo() {
 }
 
+ProgramInfoManager::Program::UniformES3::UniformES3()
+    : block_index(-1),
+      offset(-1),
+      array_stride(-1),
+      matrix_stride(-1),
+      is_row_major(0) {
+}
+
+ProgramInfoManager::Program::UniformES3::~UniformES3() {
+}
+
 ProgramInfoManager::Program::UniformBlock::UniformBlock()
     : binding(0),
       data_size(0),
       referenced_by_vertex_shader(false),
       referenced_by_fragment_shader(false) {
 }
 
 ProgramInfoManager::Program::UniformBlock::~UniformBlock() {
 }
 
 ProgramInfoManager::Program::TransformFeedbackVarying::
 TransformFeedbackVarying()
     : size(0),
       type(0) {
 }
 
 ProgramInfoManager::Program::TransformFeedbackVarying::
 ~TransformFeedbackVarying() {
 }
 
 ProgramInfoManager::Program::Program()
     : cached_es2_(false),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       link_status_(false),
       cached_es3_uniform_blocks_(false),
       active_uniform_block_max_name_length_(0),
       cached_es3_transform_feedback_varyings_(false),
-      transform_feedback_varying_max_length_(0) {
+      transform_feedback_varying_max_length_(0),
+      cached_es3_uniformsiv_(false) {
 }
 
 ProgramInfoManager::Program::~Program() {
 }
 
 // TODO(gman): Add a faster lookup.
 GLint ProgramInfoManager::Program::GetAttribLocation(
     const std::string& name) const {
   for (GLuint ii = 0; ii < attrib_infos_.size(); ++ii) {
     const VertexAttrib& info = attrib_infos_[ii];
@@ skipping 133 matching lines @@
     uniform_blocks_[index].binding = binding;
   }
 }
 
 const ProgramInfoManager::Program::TransformFeedbackVarying*
 ProgramInfoManager::Program::GetTransformFeedbackVarying(GLuint index) const {
   return (index < transform_feedback_varyings_.size()) ?
       &transform_feedback_varyings_[index] : NULL;
 }
 
+bool ProgramInfoManager::Program::GetUniformsiv(
+    GLsizei count, const GLuint* indices, GLenum pname, GLint* params) {
+  if (count == 0) {
+    // At this point, pname has already been validated.
+    return true;
+  }
+  DCHECK(count > 0 && indices);
+  size_t num_uniforms = uniform_infos_.size();
+  if (num_uniforms == 0) {
+    num_uniforms = uniforms_es3_.size();
+  }
+  if (static_cast<size_t>(count) > num_uniforms) {
+    return false;
+  }
+  for (GLsizei ii = 0; ii < count; ++ii) {
+    if (indices[ii] >= num_uniforms) {
+      return false;
+    }
+  }
+  if (!params) {
+    return true;
+  }
+  switch (pname) {
+    case GL_UNIFORM_SIZE:
+      DCHECK_EQ(num_uniforms, uniform_infos_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = static_cast<GLint>(uniform_infos_[indices[ii]].size);
+      }
+      return true;
+    case GL_UNIFORM_TYPE:
+      DCHECK_EQ(num_uniforms, uniform_infos_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = static_cast<GLint>(uniform_infos_[indices[ii]].type);
+      }
+      return true;
+    case GL_UNIFORM_NAME_LENGTH:
+      DCHECK_EQ(num_uniforms, uniform_infos_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = static_cast<GLint>(
+            uniform_infos_[indices[ii]].name.length() + 1);
+      }
+      return true;
+    case GL_UNIFORM_BLOCK_INDEX:
+      DCHECK_EQ(num_uniforms, uniforms_es3_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = uniforms_es3_[indices[ii]].block_index;
+      }
+      return true;
+    case GL_UNIFORM_OFFSET:
+      DCHECK_EQ(num_uniforms, uniforms_es3_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = uniforms_es3_[indices[ii]].offset;
+      }
+      return true;
+    case GL_UNIFORM_ARRAY_STRIDE:
+      DCHECK_EQ(num_uniforms, uniforms_es3_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = uniforms_es3_[indices[ii]].array_stride;
+      }
+      return true;
+    case GL_UNIFORM_MATRIX_STRIDE:
+      DCHECK_EQ(num_uniforms, uniforms_es3_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = uniforms_es3_[indices[ii]].matrix_stride;
+      }
+      return true;
+    case GL_UNIFORM_IS_ROW_MAJOR:
+      DCHECK_EQ(num_uniforms, uniforms_es3_.size());
+      for (GLsizei ii = 0; ii < count; ++ii) {
+        params[ii] = uniforms_es3_[indices[ii]].is_row_major;
+      }
+      return true;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return false;
+}
+
 void ProgramInfoManager::Program::UpdateES2(const std::vector<int8>& result) {
   if (cached_es2_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   DCHECK_GE(result.size(), sizeof(ProgramInfoHeader));
   const ProgramInfoHeader* header = LocalGetAs<const ProgramInfoHeader*>(
@@ skipping 107 matching lines @@
       uniform_blocks_[ii].active_uniform_indices[uu] =
           static_cast<GLuint>(indices[uu]);
     }
     indices += entries[ii].active_uniforms;
     data = reinterpret_cast<const char*>(indices);
   }
   DCHECK_EQ(data_size, size);
   cached_es3_uniform_blocks_ = true;
 }
 
+void ProgramInfoManager::Program::UpdateES3Uniformsiv(
+    const std::vector<int8>& result) {
+  if (cached_es3_uniformsiv_) {
+    return;
+  }
+  if (result.empty()) {
+    // This should only happen on a lost context.
+    return;
+  }
+  uniforms_es3_.clear();
+
+  // |result| comes from GPU process. We consider it trusted data. Therefore,
+  // no need to check for overflows as the GPU side did the checks already.
+  uint32_t header_size = sizeof(UniformsES3Header);
+  DCHECK_GE(result.size(), header_size);
+  const UniformsES3Header* header = LocalGetAs<const UniformsES3Header*>(
+      result, 0, header_size);
+  DCHECK(header);
+  if (header->num_uniforms == 0) {
+    DCHECK_EQ(result.size(), header_size);
+    // TODO(zmo): Here we can't tell if no uniforms are defined, or
+    // the previous link failed.
+    return;
+  }
+  uniforms_es3_.resize(header->num_uniforms);
+
+  uint32_t entry_size = sizeof(UniformES3Info) * header->num_uniforms;
+  DCHECK_EQ(result.size(), header_size + entry_size);
+  const UniformES3Info* entries = LocalGetAs<const UniformES3Info*>(
+      result, header_size, entry_size);
+  DCHECK(entries);
+
+  for (uint32_t ii = 0; ii < header->num_uniforms; ++ii) {
+    uniforms_es3_[ii].block_index = entries[ii].block_index;
+    uniforms_es3_[ii].offset = entries[ii].offset;
+    uniforms_es3_[ii].array_stride = entries[ii].array_stride;
+    uniforms_es3_[ii].matrix_stride = entries[ii].matrix_stride;
+    uniforms_es3_[ii].is_row_major = entries[ii].is_row_major;
+  }
+  cached_es3_uniformsiv_ = true;
+}
+
 void ProgramInfoManager::Program::UpdateES3TransformFeedbackVaryings(
     const std::vector<int8>& result) {
   if (cached_es3_transform_feedback_varyings_) {
     return;
   }
   if (result.empty()) {
     // This should only happen on a lost context.
     return;
   }
   transform_feedback_varyings_.clear();
@@ skipping 49 matching lines @@
 }
 
 bool ProgramInfoManager::Program::IsCached(ProgramInfoType type) const {
   switch (type) {
     case kES2:
       return cached_es2_;
     case kES3UniformBlocks:
       return cached_es3_uniform_blocks_;
     case kES3TransformFeedbackVaryings:
       return cached_es3_transform_feedback_varyings_;
+    case kES3Uniformsiv:
+      return cached_es3_uniformsiv_;
     case kNone:
       return true;
     default:
       NOTREACHED();
       return true;
   }
 }
 
 
 ProgramInfoManager::ProgramInfoManager() {
@@ skipping 34 matching lines @@
       info->UpdateES3UniformBlocks(result);
       break;
     case kES3TransformFeedbackVaryings:
       {
         base::AutoUnlock unlock(lock_);
         // lock_ can't be held across IPC call or else it may deadlock in
         // pepper. http://crbug.com/418651
         gl->GetTransformFeedbackVaryingsCHROMIUMHelper(program, &result);
       }
       info->UpdateES3TransformFeedbackVaryings(result);
+    case kES3Uniformsiv:
+      {
+        base::AutoUnlock unlock(lock_);
+        // lock_ can't be held across IPC call or else it may deadlock in
+        // pepper. http://crbug.com/418651
+        gl->GetUniformsES3CHROMIUMHelper(program, &result);
+      }
+      info->UpdateES3Uniformsiv(result);
     default:
       NOTREACHED();
       return NULL;
   }
   return info;
 }
 
 void ProgramInfoManager::CreateInfo(GLuint program) {
   base::AutoLock auto_lock(lock_);
   program_infos_.erase(program);
@@ skipping 31 matching lines @@
     default:
       return false;
   }
   Program* info = GetProgramInfo(gl, program, type);
   if (!info) {
     return false;
   }
   return info->GetProgramiv(pname, params);
 }
 
+bool ProgramInfoManager::GetActiveUniformsiv(
+    GLES2Implementation* gl, GLuint program, GLsizei count,
+    const GLuint* indices, GLenum pname, GLint* params) {
+  base::AutoLock auto_lock(lock_);
+  ProgramInfoType type = kNone;
+  switch (pname) {
+    case GL_UNIFORM_SIZE:
+    case GL_UNIFORM_TYPE:
+    case GL_UNIFORM_NAME_LENGTH:
+      type = kES2;
+      break;
+    case GL_UNIFORM_BLOCK_INDEX:
+    case GL_UNIFORM_OFFSET:
+    case GL_UNIFORM_ARRAY_STRIDE:
+    case GL_UNIFORM_MATRIX_STRIDE:
+    case GL_UNIFORM_IS_ROW_MAJOR:
+      type = kES3Uniformsiv;
+      break;
+    default:
+      return false;
+  }
+  Program* info = GetProgramInfo(gl, program, type);
+  if (info) {
+    return info->GetUniformsiv(count, indices, pname, params);
+  }
+  return gl->GetActiveUniformsivHelper(program, count, indices, pname, params);
+}
+
 GLint ProgramInfoManager::GetAttribLocation(
     GLES2Implementation* gl, GLuint program, const char* name) {
   {
     base::AutoLock auto_lock(lock_);
     Program* info = GetProgramInfo(gl, program, kES2);
     if (info) {
       return info->GetAttribLocation(name);
     }
   }
   return gl->GetAttribLocationHelper(program, name);
@@ skipping 280 matching lines @@
       }
       return true;
     }
   }
   return gl->GetUniformIndicesHelper(program, count, names, indices);
 }
 
 }  // namespace gles2
 }  // namespace gpu