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 38 matching lines @@
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "gpu/command_buffer/service/uniform_subscription_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "third_party/smhasher/src/City.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_MACOSX)
 #include <IOSurface/IOSurfaceAPI.h>
@@ skipping 720 matching lines @@
   TextureManager* texture_manager() {
     return group_->texture_manager();
   }
 
   MailboxManager* mailbox_manager() {
     return group_->mailbox_manager();
   }
 
   ImageManager* image_manager() { return image_manager_.get(); }
 
+  UniformSubscriptionManager* uniform_subscription_manager() {
+    return uniform_subscription_manager_.get();
+  }
+
   VertexArrayManager* vertex_array_manager() {
     return vertex_array_manager_.get();
   }
 
   MemoryTracker* memory_tracker() {
     return group_->memory_tracker();
   }
 
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
@@ skipping 142 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 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);
 
+  // Populate subscribed uniforms for program specified by |client_id|
+  void PopulateSubscribedUniforms(GLuint client_id);
+
   // 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 116 matching lines @@
   scoped_ptr<BackFramebuffer> offscreen_resolved_frame_buffer_;
   scoped_ptr<BackTexture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<QueryManager> query_manager_;
 
   scoped_ptr<VertexArrayManager> vertex_array_manager_;
 
   scoped_ptr<ImageManager> image_manager_;
 
+  scoped_ptr<UniformSubscriptionManager> uniform_subscription_manager_;
+
   base::Callback<void(gfx::Size, float)> resize_callback_;
 
   WaitSyncPointCallback wait_sync_point_callback_;
 
   ShaderCacheCallback shader_cache_callback_;
 
   scoped_ptr<AsyncPixelTransferManager> async_pixel_transfer_manager_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
@@ skipping 693 matching lines @@
       group_->max_vertex_attribs(),
       feature_info_->workarounds().init_vertex_attributes);
 
   // vertex_attrib_manager is set to default_vertex_attrib_manager by this call
   DoBindVertexArrayOES(0);
 
   query_manager_.reset(new QueryManager(this, feature_info_.get()));
 
   image_manager_.reset(new ImageManager);
 
+  uniform_subscription_manager_.reset(new UniformSubscriptionManager);
+
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
@@ skipping 1064 matching lines @@
   if (vertex_array_manager_ .get()) {
     vertex_array_manager_->Destroy(have_context);
     vertex_array_manager_.reset();
   }
 
   if (image_manager_.get()) {
     image_manager_->Destroy(have_context);
     image_manager_.reset();
   }
 
+  if (uniform_subscription_manager_.get()) {
+    uniform_subscription_manager_->Destroy(have_context);
+    uniform_subscription_manager_.reset();
+  }
+
   offscreen_target_frame_buffer_.reset();
   offscreen_target_color_texture_.reset();
   offscreen_target_color_render_buffer_.reset();
   offscreen_target_depth_render_buffer_.reset();
   offscreen_target_stencil_render_buffer_.reset();
   offscreen_saved_frame_buffer_.reset();
   offscreen_saved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
   offscreen_resolved_color_texture_.reset();
 
@@ skipping 2205 matching lines @@
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgramForUniform(
     GLint location, const char* function_name) {
   if (!CheckCurrentProgram(function_name)) {
     return false;
   }
   return location != -1;
 }
 
+
 bool GLES2DecoderImpl::CheckDrawingFeedbackLoops() {
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
   if (!framebuffer)
     return false;
   const Framebuffer::Attachment* attachment =
       framebuffer->GetAttachment(GL_COLOR_ATTACHMENT0);
   if (!attachment)
     return false;
 
   DCHECK(state_.current_program.get());
@@ skipping 12 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(GLuint client_id) {
+  const UniformSubscriptionManager::ProgramSubscriptions*
+      program_subscriptions =
+          uniform_subscription_manager()->SubscriptionsForProgram(client_id);
+  if (program_subscriptions) {
+    // 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);
+    PopulateSubscribedUniforms(program_id);

[piman, 2014/10/21 20:00:41]

I think we'd want to populate the uniforms only once after
PopulateSubscribedUniformsCHROMIUM was called?

One cheap way you can do that is by having the uniform_subscription_manager keep
a generation number, that gets increased any time
PopulateSubscribedUniformsCHROMIUM is called. Each program would keep the
generation of the last time it updated the uniforms. When binding the program
you'd compare both and update iff the generation numbers differ (and the program
has any subscribed uniform).

[orglofch, 2014/10/22 23:10:21]

Done. I added needs_update_subscriptions_ flag to 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",
+          uniform_subscription_manager()->ApiTypeForTarget(target))) {
+    return false;
+  }
+  return true;
+}
+
+void GLES2DecoderImpl::DoSubscribeUniformCHROMIUM(GLint location,
+                                                  GLenum target) {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoSubscribeUniformCHROMIUM");
+  if (!ValidateSubscribeUniform(location, target)) {
+    return;
+  }
+  GLuint client_id;
+  program_manager()->GetClientId(state_.current_program.get()->service_id(),
+                                 &client_id);
+  uniform_subscription_manager()->AddSubscription(client_id, location, target);
+}
+
+void GLES2DecoderImpl::DoPopulateSubscribedUniformsCHROMIUM() {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoPopulateSubscribedUniformsCHROMIUM");
+  uniform_subscription_manager()->ActivateUniformSubscriptionState();
+  // Defer population of other programs until calls to DoUseProgram
+  if (state_.current_program.get()) {
+    GLuint client_id;
+    program_manager()->GetClientId(state_.current_program.get()->service_id(),
+                                   &client_id);
+    PopulateSubscribedUniforms(client_id);
+  }
+}
+
 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