Revert 250147 "Merge 249547 "Add a gpu driver bug workaround to ..."

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 504 matching lines @@
         << "unless the driver is buggy:"
         << "\n--original-shader--\n" << (source ? *source : std::string())
         << "\n--translated-shader--\n" << shader_src << "\n--info-log--\n"
         << *shader->log_info();
   }
 }
 
 bool Program::Link(ShaderManager* manager,
                    ShaderTranslator* vertex_translator,
                    ShaderTranslator* fragment_translator,
-                   Program::VaryingsPackingOption varyings_packing_option,
                    const ShaderCacheCallback& shader_callback) {
   ClearLinkStatus();
   if (!CanLink()) {
     set_log_info("missing shaders");
     return false;
   }
   if (DetectAttribLocationBindingConflicts()) {
     set_log_info("glBindAttribLocation() conflicts");
     return false;
   }
   if (DetectUniformsMismatch()) {
     set_log_info("Uniforms with the same name but different type/precision");
     return false;
   }
   if (DetectVaryingsMismatch()) {
     set_log_info("Varyings with the same name but different type, "
                  "or statically used varyings in fragment shader are not "
                  "declared in vertex shader");
     return false;
   }
   if (DetectGlobalNameConflicts()) {
     set_log_info("Name conflicts between an uniform and an attribute");
     return false;
   }
-  if (!CheckVaryingsPacking(varyings_packing_option)) {
+  if (!CheckVaryingsPacking()) {
     set_log_info("Varyings over maximum register limit");
     return false;
   }
 
   TimeTicks before_time = TimeTicks::HighResNow();
   bool link = true;
   ProgramCache* cache = manager_->program_cache_;
   if (cache) {
     DCHECK(attached_shaders_[0]->signature_source() &&
            attached_shaders_[1]->signature_source());
@@ skipping 517 matching lines @@
   for (ShaderTranslator::VariableMap::const_iterator iter =
            attribs->begin(); iter != attribs->end(); ++iter) {
     for (int ii = 0; ii < 2; ++ii) {
       if (uniforms[ii]->find(iter->first) != uniforms[ii]->end())
         return true;
     }
   }
   return false;
 }
 
-bool Program::CheckVaryingsPacking(
-    Program::VaryingsPackingOption option) const {
+bool Program::CheckVaryingsPacking() const {
   DCHECK(attached_shaders_[0] &&
          attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
          attached_shaders_[1] &&
          attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
   const ShaderTranslator::VariableMap* vertex_varyings =
       &(attached_shaders_[0]->varying_map());
   const ShaderTranslator::VariableMap* fragment_varyings =
       &(attached_shaders_[1]->varying_map());
 
   std::map<std::string, ShVariableInfo> combined_map;
 
   for (ShaderTranslator::VariableMap::const_iterator iter =
            fragment_varyings->begin();
        iter != fragment_varyings->end(); ++iter) {
-    if (!iter->second.static_use && option == kCountOnlyStaticallyUsed)
+    if (!iter->second.static_use)
       continue;
     if (!IsBuiltInVarying(iter->first)) {
       ShaderTranslator::VariableMap::const_iterator vertex_iter =
           vertex_varyings->find(iter->first);
       if (vertex_iter == vertex_varyings->end() ||
-          (!vertex_iter->second.static_use &&
-           option == kCountOnlyStaticallyUsed))
+          !vertex_iter->second.static_use)
         continue;
     }
 
     ShVariableInfo var;
     var.type = static_cast<ShDataType>(iter->second.type);
     var.size = iter->second.size;
     combined_map[iter->first] = var;
   }
 
   if (combined_map.size() == 0)
@@ skipping 228 matching lines @@
   DCHECK(program);
   program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu