program_manager::CheckPacking, sends full sh::ShaderVariable

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1844 matching lines @@
 
 bool Program::CheckVaryingsPacking(
     Program::VaryingsPackingOption option) const {
   DCHECK(attached_shaders_[0].get() &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1].get() &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const VaryingMap* vertex_varyings = &(attached_shaders_[0]->varying_map());
   const VaryingMap* fragment_varyings = &(attached_shaders_[1]->varying_map());
 
-  std::map<std::string, ShVariableInfo> combined_map;
+  std::map<std::string, const sh::ShaderVariable*> combined_map;
 
   for (const auto& key_value : *fragment_varyings) {
     if (!key_value.second.staticUse && option == kCountOnlyStaticallyUsed)
       continue;
     if (!IsBuiltInFragmentVarying(key_value.first)) {
       VaryingMap::const_iterator vertex_iter =
           vertex_varyings->find(key_value.first);
       if (vertex_iter == vertex_varyings->end() ||
           (!vertex_iter->second.staticUse &&
            option == kCountOnlyStaticallyUsed))
         continue;
     }
 
-    ShVariableInfo var;
-    var.type = static_cast<sh::GLenum>(key_value.second.type);
-    var.size = std::max(1u, key_value.second.arraySize);
-    combined_map[key_value.first] = var;
+    combined_map[key_value.first] = &key_value.second;
   }
 
   if (combined_map.size() == 0)
     return true;
-  std::unique_ptr<ShVariableInfo[]> variables(
-      new ShVariableInfo[combined_map.size()]);
-  size_t index = 0;
+  std::vector<sh::ShaderVariable> variables;
   for (const auto& key_value : combined_map) {
-    variables[index].type = key_value.second.type;
-    variables[index].size = key_value.second.size;
-    ++index;
+    variables.push_back(*key_value.second);
   }
   return ShCheckVariablesWithinPackingLimits(
       static_cast<int>(manager_->max_varying_vectors()),
-      variables.get(),
-      combined_map.size());
+      variables);
 }
 
 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
   // of an identifier is 256 characters.
   uint32_t num_locations = 0;
   uint32_t total_string_size = 0;
@@ skipping 557 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32_t ProgramManager::MakeFakeLocation(int32_t index, int32_t element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu