Add subscribeUniform extension pipeline

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 925 matching lines @@
   void DoProduceTextureCHROMIUM(GLenum target, const GLbyte* key);
   void DoProduceTextureDirectCHROMIUM(GLuint texture, GLenum target,
       const GLbyte* key);
   void ProduceTextureRef(std::string func_name, TextureRef* texture_ref,
       GLenum target, const GLbyte* data);
 
   void DoConsumeTextureCHROMIUM(GLenum target, const GLbyte* key);
   void DoCreateAndConsumeTextureCHROMIUM(GLenum target, const GLbyte* key,
     GLuint client_id);
 
+  void DoSubscribeUniformCHROMIUM(GLint locaton, GLenum target);
+  void DoUnsubscribeUniformCHROMIUM(GLint location);
+  void DoPopulateSubscribedUniformsCHROMIUM();
+
   void DoBindTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
   void DoReleaseTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
 
   void DoTraceEndCHROMIUM(void);
 
   void DoDrawBuffersEXT(GLsizei count, const GLenum* bufs);
@@ skipping 229 matching lines @@
   // -1. If the current program is not valid generates the appropriate GL
   // error. Returns true if the current program is in a usable state and
   // location is not -1.
   bool CheckCurrentProgramForUniform(GLint location, const char* function_name);
 
   // Checks if the current program samples a texture that is also the color
   // image of the current bound framebuffer, i.e., the source and destination
   // of the draw operation are the same.
   bool CheckDrawingFeedbackLoops();
 
+  // Checks if |api_type| is valid for the given uniform
+  // If the api type is not valid generates the appropriate GL
+  // error. Returns true if |api_type| is valid for the uniform
+  bool CheckUniformForApiType(const Program::UniformInfo* info,
+                              const char* function_name,
+                              Program::UniformApiType api_type);
+
   // Gets the type of a uniform for a location in the current program. Sets GL
   // errors if the current program is not valid. Returns true if the current
   // program is valid and the location exists. Adjusts count so it
   // does not overflow the uniform.
   bool PrepForSetUniformByLocation(GLint fake_location,
                                    const char* function_name,
                                    Program::UniformApiType api_type,
                                    GLint* real_location,
                                    GLenum* type,
                                    GLsizei* count);
 
+  void PopulateSubscribedUniforms(Program* program);
+
   // Gets the service id for any simulated backbuffer fbo.
   GLuint GetBackbufferServiceId() const;
 
   // Helper for glGetBooleanv, glGetFloatv and glGetIntegerv
   bool GetHelper(GLenum pname, GLint* params, GLsizei* num_written);
 
   // Helper for glGetVertexAttrib
   void GetVertexAttribHelper(
     const VertexAttrib* attrib, GLenum pname, GLint* param);
 
@@ skipping 359 matching lines @@
       GLint level, GLsizei width, GLsizei height, GLenum format);
   bool ValidateCompressedTexFuncData(
       const char* function_name,
       GLsizei width, GLsizei height, GLenum format, size_t size);
   bool ValidateCompressedTexSubDimensions(
     const char* function_name,
     GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height, GLenum format,
     Texture* texture);
 
+  bool ValidateSubscribeUniform(GLint fake_location, GLenum target);
+
   void RenderWarning(const char* filename, int line, const std::string& msg);
   void PerformanceWarning(
       const char* filename, int line, const std::string& msg);
 
   const FeatureInfo::FeatureFlags& features() const {
     return feature_info_->feature_flags();
   }
 
   const FeatureInfo::Workarounds& workarounds() const {
     return feature_info_->workarounds();
@@ skipping 4170 matching lines @@
       TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
       TextureRef* texture_ref =
           texture_unit.GetInfoForSamplerType(GL_SAMPLER_2D).get();
       if (attachment->IsTexture(texture_ref))
         return true;
     }
   }
   return false;
 }
 
+bool GLES2DecoderImpl::CheckUniformForApiType(
+    const Program::UniformInfo* info,
+    const char* function_name,
+    Program::UniformApiType api_type) {
+  DCHECK(info);
+  if ((api_type & info->accepts_api_type) == 0) {
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_OPERATION, function_name, "wrong uniform function for type");
+    return false;
+  }
+  return true;
+}
+
 bool GLES2DecoderImpl::PrepForSetUniformByLocation(
     GLint fake_location,
     const char* function_name,
     Program::UniformApiType api_type,
     GLint* real_location,
     GLenum* type,
     GLsizei* count) {
   DCHECK(type);
   DCHECK(count);
   DCHECK(real_location);
 
   if (!CheckCurrentProgramForUniform(fake_location, function_name)) {
     return false;
   }
   GLint array_index = -1;
   const Program::UniformInfo* info =
       state_.current_program->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!info) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "unknown location");
     return false;
   }
-
-  if ((api_type & info->accepts_api_type) == 0) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION, function_name,
-        "wrong uniform function for type");
+  if (!CheckUniformForApiType(info, function_name, api_type)) {
     return false;
   }
   if (*count > 1 && !info->is_array) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, function_name, "count > 1 for non-array");
     return false;
   }
   *count = std::min(info->size - array_index, *count);
   if (*count <= 0) {
     return false;
   }
   *type = info->type;
   return true;
 }
 
+void GLES2DecoderImpl::PopulateSubscribedUniforms(Program* program) {
+  const Program::SubscriptionMap& subscription_map =
+      program->subscription_map();
+  for (Program::SubscriptionMap::const_iterator it = subscription_map.begin();
+       it != subscription_map.end();
+       ++it) {
+    // TODO(orglofch):
+  }
+}
+
 void GLES2DecoderImpl::DoUniform1i(GLint fake_location, GLint v0) {
   GLenum type = 0;
   GLsizei count = 1;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform1i",
                                    Program::kUniform1i,
                                    &real_location,
                                    &type,
                                    &count)) {
@@ skipping 240 matching lines @@
     program_manager()->UnuseProgram(shader_manager(),
                                     state_.current_program.get());
   }
   state_.current_program = program;
   LogClientServiceMapping("glUseProgram", program_id, service_id);
   glUseProgram(service_id);
   if (state_.current_program.get()) {
     program_manager()->UseProgram(state_.current_program.get());
     if (workarounds().clear_uniforms_before_first_program_use)
       program_manager()->ClearUniforms(program);
+    if (program->needs_update_subscriptions()) {
+      PopulateSubscribedUniforms(program);
+    }
   }
 }
 
 void GLES2DecoderImpl::RenderWarning(
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line, std::string("RENDER WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::PerformanceWarning(
     const char* filename, int line, const std::string& msg) {
@@ skipping 4578 matching lines @@
   if (texture->target() != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glCreateAndConsumeTextureCHROMIUM", "invalid target");
     return;
   }
 
   texture_ref = texture_manager()->Consume(client_id, texture);
 }
 
+bool GLES2DecoderImpl::ValidateSubscribeUniform(GLint fake_location,
+                                                GLenum target) {
+  if (!CheckCurrentProgramForUniform(fake_location,
+                                     "glSubscribeUniformCHROMIUM")) {
+    return false;
+  }
+  GLint array_index = -1;
+  GLint real_location = -1;
+  const Program::UniformInfo* info =
+      state_.current_program->GetUniformInfoByFakeLocation(
+          fake_location, &real_location, &array_index);
+  if (!info) {
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_OPERATION, "glSubscribeUniformCHROMIUM", "unknown location");
+    return false;
+  }
+  if (!CheckUniformForApiType(
+          info,
+          "glSubscribeUniformCHROMIUM",
+          program_manager()->ApiTypeForSubscriptionTarget(target))) {
+    return false;
+  }
+  return true;
+}
+
+void GLES2DecoderImpl::DoSubscribeUniformCHROMIUM(GLint location,
+                                                  GLenum target) {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoSubscribeUniformCHROMIUM");
+  if (!ValidateSubscribeUniform(location, target)) {
+    return;
+  }
+  if (state_.current_program.get()) {
+    state_.current_program.get()->AddSubscription(location, target);
+  }
+}
+
+void GLES2DecoderImpl::DoUnsubscribeUniformCHROMIUM(GLint location) {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoUnsubscribeUniformCHROMIUM");
+  if (!CheckCurrentProgramForUniform(location,
+                                     "glUnsubscribeUniformCHROMIUM")) {
+    return;
+  }
+  if (state_.current_program.get()) {
+    state_.current_program.get()->RemoveSubscription(location);
+  }
+}
+
+void GLES2DecoderImpl::DoPopulateSubscribedUniformsCHROMIUM() {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoPopulateSubscribedUniformsCHROMIUM");
+  program_manager()->ActivateUniformSubscriptionState();
+  // Defer population of other programs until calls to DoUseProgram
+  if (state_.current_program.get() &&
+      state_.current_program.get()->needs_update_subscriptions()) {
+    PopulateSubscribedUniforms(state_.current_program.get());
+  }
+}
+
 void GLES2DecoderImpl::DoInsertEventMarkerEXT(
     GLsizei length, const GLchar* marker) {
   if (!marker) {
     marker = "";
   }
   debug_marker_manager_.SetMarker(
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2DecoderImpl::DoPushGroupMarkerEXT(
@@ skipping 542 matching lines @@
   }
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu