Hookup clear_uniforms_before_first_program_use workaround with implementation.

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>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/program_cache.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "third_party/re2/re2/re2.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
@@ skipping 422 matching lines @@
 
 void Program::ExecuteBindAttribLocationCalls() {
   for (LocationMap::const_iterator it = bind_attrib_location_map_.begin();
        it != bind_attrib_location_map_.end(); ++it) {
     const std::string* mapped_name = GetAttribMappedName(it->first);
     if (mapped_name && *mapped_name != it->first)
       glBindAttribLocation(service_id_, it->second, mapped_name->c_str());
   }
 }
 
-void ProgramManager::DoCompileShader(Shader* shader,
-                                     ShaderTranslator* translator,
-                                     FeatureInfo* feature_info) {
+void ProgramManager::DoCompileShader(
+    Shader* shader,
+    ShaderTranslator* translator,
+    ProgramManager::TranslatedShaderSourceType translated_shader_source_type) {
   // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
   // glShaderSource and then glCompileShader.
   const std::string* source = shader->source();
   const char* shader_src = source ? source->c_str() : "";
   if (translator) {
     if (!translator->Translate(shader_src)) {
       shader->SetStatus(false, translator->info_log(), NULL);
       return;
     }
     shader_src = translator->translated_shader();
-    if (!feature_info->feature_flags().angle_translated_shader_source)
+    if (translated_shader_source_type != kANGLE)
       shader->UpdateTranslatedSource(shader_src);
   }
 
   glShaderSource(shader->service_id(), 1, &shader_src, NULL);
   glCompileShader(shader->service_id());
-  if (feature_info->feature_flags().angle_translated_shader_source) {
+  if (translated_shader_source_type == kANGLE) {
     GLint max_len = 0;
     glGetShaderiv(shader->service_id(),
                   GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE,
                   &max_len);
     scoped_ptr<char[]> temp(new char[max_len]);
     GLint len = 0;
     glGetTranslatedShaderSourceANGLE(
         shader->service_id(), max_len, &len, temp.get());
     DCHECK(max_len == 0 || len < max_len);
     DCHECK(len == 0 || temp[len] == '\0');
@@ skipping 21 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,
-                   FeatureInfo* feature_info,
                    const ShaderCacheCallback& shader_callback) {
   ClearLinkStatus();
   if (!CanLink()) {
     set_log_info("missing shaders");
     return false;
   }
   if (DetectAttribLocationBindingConflicts()) {
     set_log_info("glBindAttribLocation() conflicts");
     return false;
   }
@@ skipping 708 matching lines @@
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 
 ProgramManager::ProgramManager(ProgramCache* program_cache,
                                uint32 max_varying_vectors)
     : program_count_(0),
       have_context_(true),
-      disable_workarounds_(
-          CommandLine::ForCurrentProcess()->HasSwitch(
-              switches::kDisableGpuDriverBugWorkarounds)),
       program_cache_(program_cache),
       max_varying_vectors_(max_varying_vectors) { }
 
 ProgramManager::~ProgramManager() {
   DCHECK(programs_.empty());
 }
 
 void ProgramManager::Destroy(bool have_context) {
   have_context_ = have_context;
   programs_.clear();
@@ skipping 74 matching lines @@
   DCHECK(program);
   DCHECK(IsOwned(program));
   program->MarkAsDeleted();
   RemoveProgramInfoIfUnused(shader_manager, program);
 }
 
 void ProgramManager::UseProgram(Program* program) {
   DCHECK(program);
   DCHECK(IsOwned(program));
   program->IncUseCount();
-  ClearUniforms(program);
 }
 
 void ProgramManager::UnuseProgram(
     ShaderManager* shader_manager,
     Program* program) {
   DCHECK(shader_manager);
   DCHECK(program);
   DCHECK(IsOwned(program));
   program->DecUseCount();
   RemoveProgramInfoIfUnused(shader_manager, program);
 }
 
 void ProgramManager::ClearUniforms(Program* program) {
   DCHECK(program);
-  if (!disable_workarounds_) {
-    program->ClearUniforms(&zero_);
-  }
+  program->ClearUniforms(&zero_);
 }
 
 int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
   return index + element * 0x10000;
 }
 
 }  // namespace gles2
 }  // namespace gpu