Add subscribeUniform extension pipeline

gpu/command_buffer/service/program_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/service/program_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 175 matching lines @@
 }
 
 Program::UniformInfo::~UniformInfo() {}
 
 bool ProgramManager::IsInvalidPrefix(const char* name, size_t length) {
   static const char kInvalidPrefix[] = { 'g', 'l', '_' };
   return (length >= sizeof(kInvalidPrefix) &&
       memcmp(name, kInvalidPrefix, sizeof(kInvalidPrefix)) == 0);
 }
 
-Program::Program(
-    ProgramManager* manager, GLuint service_id)
+Program::Program(ProgramManager* manager, GLuint service_id)
     : manager_(manager),
       use_count_(0),
       max_attrib_name_length_(0),
       max_uniform_name_length_(0),
       service_id_(service_id),
       deleted_(false),
       valid_(false),
       link_status_(false),
       uniforms_cleared_(false),
+      needs_update_subscriptions_(true),
       num_uniforms_(0) {
   manager_->StartTracking(this);
 }
 
 void Program::Reset() {
   valid_ = false;
   link_status_ = false;
+  needs_update_subscriptions_ = true;
   num_uniforms_ = 0;
   max_uniform_name_length_ = 0;
   max_attrib_name_length_ = 0;
   attrib_infos_.clear();
   uniform_infos_.clear();
   sampler_indices_.clear();
   attrib_location_to_index_map_.clear();
 }
 
 std::string Program::ProcessLogInfo(
@@ skipping 404 matching lines @@
 
 void Program::Validate() {
   if (!IsValid()) {
     set_log_info("program not linked");
     return;
   }
   glValidateProgram(service_id());
   UpdateLogInfo();
 }
 
+void Program::SetNeedsUpdateSubscriptions() {
+  needs_update_subscriptions_ = true;

[piman, 2014/10/23 02:30:48]

When will that be reset to false? In
GLES2DecoderImpl::PopulateSubscribedUniforms when implemented? Should it be done
now?

+}
+
 GLint Program::GetUniformFakeLocation(
     const std::string& name) const {
   bool getting_array_location = false;
   size_t open_pos = std::string::npos;
   int index = 0;
   if (!GLES2Util::ParseUniformName(
       name, &open_pos, &index, &getting_array_location)) {
     return -1;
   }
   for (GLuint ii = 0; ii < uniform_infos_.size(); ++ii) {
@@ skipping 543 matching lines @@
     variables[index].type = iter->second.type;
     variables[index].size = iter->second.size;
     ++index;
   }
   return ShCheckVariablesWithinPackingLimits(
       static_cast<int>(manager_->max_varying_vectors()),
       variables.get(),
       combined_map.size()) == 1;
 }
 
+void Program::AddSubscription(GLint location, GLenum target) {
+  subscription_map_[location] = target;
+}
+
+void Program::RemoveSubscription(GLint location) {
+  subscription_map_.erase(location);
+}
+
 static uint32 ComputeOffset(const void* start, const void* position) {
   return static_cast<const uint8*>(position) -
          static_cast<const uint8*>(start);
 }
 
 void Program::GetProgramInfo(
     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
@@ skipping 146 matching lines @@
 bool ProgramManager::IsOwned(Program* program) {
   for (ProgramMap::iterator it = programs_.begin();
        it != programs_.end(); ++it) {
     if (it->second.get() == program) {
       return true;
     }
   }
   return false;
 }
 
+void ProgramManager::ActivateUniformSubscriptionState() {

[brianderson, 2014/10/24 00:28:34]

It looks like ProgramManager has a 1:1 relationship with a ContextGroup, however
we'll likely want activations to only apply to a single context and not all
contexts within the group. Should this be a method on ContextState instead?

Ditto for other state like the subscription_map_.

+  // TODO(orglofch): Make active_state = pending_state
+  // only set needs update subscriptions if !pending_state.empty()
+  for (ProgramMap::iterator it = programs_.begin(); it != programs_.end();
+       ++it) {

[piman, 2014/10/23 02:30:48]

Maybe make it a TODO, but it would be nice not to have to iterate over all the
programs, given that it's likely that only a few have subscriptions.

Hence the idea to use a generation number.

+    it->second.get()->SetNeedsUpdateSubscriptions();
+  }
+}
+
 void ProgramManager::RemoveProgramInfoIfUnused(
     ShaderManager* shader_manager, Program* program) {
   DCHECK(shader_manager);
   DCHECK(program);
   DCHECK(IsOwned(program));
   if (program->IsDeleted() && !program->InUse()) {
     program->DetachShaders(shader_manager);
     for (ProgramMap::iterator it = programs_.begin();
          it != programs_.end(); ++it) {
       if (it->second.get() == program) {
@@ skipping 33 matching lines @@
 
 void ProgramManager::ClearUniforms(Program* program) {
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
+Program::UniformApiType ProgramManager::ApiTypeForSubscriptionTarget(
+    GLenum target) {
+  switch (target) {
+    case GL_MOUSE_POSITION_CHROMIUM:
+      return Program::kUniform2i;
+  }
+  NOTREACHED() << "Unhandled uniform subscription target " << target;
+  return Program::kUniformNone;
+}
+
 }  // namespace gles2
 }  // namespace gpu