Hookup driver_bug_workarounds with gl_tests properly.

gpu/command_buffer/service/feature_info.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/feature_info.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/string_util.h"
@@ skipping 162 matching lines @@
   disallowed_features_ = disallowed_features;
   AddFeatures(*CommandLine::ForCurrentProcess());
   return true;
 }
 
 void FeatureInfo::AddFeatures(const CommandLine& command_line) {
   // Figure out what extensions to turn on.
   StringSet extensions(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
 
-  // This is a temporary fix to turn gl_tests green on Linux and Android bots.
-  // Once we migrate blacklisting stuff from src/content to src/gpu, we can
-  // get the workarounds from json file. Then we should remove this block.
-  // See crbug.com/228979.
-  bool is_intel = false;
-  bool is_nvidia = false;
-  bool is_amd = false;
-  bool is_mesa = false;
-  bool is_qualcomm = false;
-  bool is_imagination = false;
-  bool is_arm = false;
-  bool is_vivante = false;
-  const char* gl_strings[2];
-  gl_strings[0] = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
-  gl_strings[1] = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
-  if (!command_line.HasSwitch(switches::kGpuDriverBugWorkarounds) &&
-      !command_line.HasSwitch(switches::kDisableGpuDriverBugWorkarounds)) {
-    for (size_t ii = 0; ii < arraysize(gl_strings); ++ii) {
-      const char* str = gl_strings[ii];
-      if (str) {
-        std::string lstr(StringToLowerASCII(std::string(str)));
-        StringSet string_set(lstr);
-        is_intel |= string_set.Contains("intel");
-        is_nvidia |= string_set.Contains("nvidia");
-        is_amd |= string_set.Contains("amd") || string_set.Contains("ati");
-        is_mesa |= string_set.Contains("mesa");
-        is_qualcomm |= string_set.Contains("qualcomm");
-        is_imagination |= string_set.Contains("imagination");
-        is_arm |= string_set.Contains("arm");
-      }
-    }
-    if (extensions.Contains("GL_VIV_shader_binary"))
-      is_vivante = true;
-
-    workarounds_.set_texture_filter_before_generating_mipmap = true;
-    workarounds_.clear_alpha_in_readpixels = true;
-    if (is_nvidia) {
-      workarounds_.use_current_program_after_successful_link = true;
-    }
-    if (is_qualcomm) {
-      workarounds_.restore_scissor_on_fbo_change = true;
-      workarounds_.flush_on_context_switch = true;
-      workarounds_.delete_instead_of_resize_fbo = true;
-    }
-    if (is_vivante || is_imagination) {
-      workarounds_.unbind_fbo_on_context_switch = true;
-    }
-#if defined(OS_MACOSX)
-    workarounds_.needs_offscreen_buffer_workaround = is_nvidia;
-    workarounds_.needs_glsl_built_in_function_emulation = is_amd;
-    if ((is_amd || is_intel) &&
-        gfx::GetGLImplementation() == gfx::kGLImplementationDesktopGL) {
-      workarounds_.reverse_point_sprite_coord_origin = true;
-    }
-    if (is_intel) {
-      workarounds_.max_texture_size = 4096;
-      workarounds_.max_cube_map_texture_size = 1024;
-      int32 major = 0;
-      int32 minor = 0;
-      int32 bugfix = 0;
-      base::SysInfo::OperatingSystemVersionNumbers(&major, &minor, &bugfix);
-      if (major < 10 ||
-          (major == 10 && ((minor == 7 && bugfix < 3) || (minor < 7))))
-        workarounds_.max_cube_map_texture_size = 512;
-    }
-    if (is_amd) {
-      workarounds_.max_texture_size = 4096;
-      workarounds_.max_cube_map_texture_size = 4096;
-    }
-#endif
-  }
-
   if (command_line.HasSwitch(switches::kGpuDriverBugWorkarounds)) {
     std::string types = command_line.GetSwitchValueASCII(
         switches::kGpuDriverBugWorkarounds);
     StringToWorkarounds(types, &workarounds_);
   }
 
   feature_flags_.enable_shader_name_hashing =
       !command_line.HasSwitch(switches::kDisableShaderNameHashing);
 
   bool npot_ok = false;
@@ skipping 10 matching lines @@
   AddExtensionString("GL_CHROMIUM_pixel_transfer_buffer_object");
   AddExtensionString("GL_CHROMIUM_rate_limit_offscreen_context");
   AddExtensionString("GL_CHROMIUM_resize");
   AddExtensionString("GL_CHROMIUM_resource_safe");
   AddExtensionString("GL_CHROMIUM_set_visibility");
   AddExtensionString("GL_CHROMIUM_strict_attribs");
   AddExtensionString("GL_CHROMIUM_stream_texture");
   AddExtensionString("GL_CHROMIUM_texture_mailbox");
   AddExtensionString("GL_EXT_debug_marker");
 
-  if (workarounds_.enable_chromium_fast_npot_mo8_textures ||
-      is_imagination)
+  if (workarounds_.enable_chromium_fast_npot_mo8_textures)
     AddExtensionString("GL_CHROMIUM_fast_NPOT_MO8_textures");
 
   feature_flags_.chromium_stream_texture = true;
 
   // OES_vertex_array_object is emulated if not present natively,
   // so the extension string is always exposed.
   AddExtensionString("GL_OES_vertex_array_object");
 
   if (!disallowed_features_.gpu_memory_manager)
     AddExtensionString("GL_CHROMIUM_gpu_memory_manager");
@@ skipping 64 matching lines @@
   // NOTE: GL_OES_depth_texture requires support for depth cubemaps.
   // GL_ARB_depth_texture requires other features that
   // GL_OES_packed_depth_stencil does not provide.
   //
   // Therefore we made up GL_GOOGLE_depth_texture / GL_CHROMIUM_depth_texture.
   //
   // GL_GOOGLE_depth_texture is legacy. As we exposed it into NaCl we can't
   // get rid of it.
   //
   bool enable_depth_texture = false;
-  if ((!workarounds_.disable_depth_texture && !is_qualcomm) &&
+  if (!workarounds_.disable_depth_texture &&
       (extensions.Contains("GL_ARB_depth_texture") ||
        extensions.Contains("GL_OES_depth_texture") ||
        extensions.Contains("GL_ANGLE_depth_texture"))) {
     enable_depth_texture = true;
   }
 
   if (enable_depth_texture) {
     AddExtensionString("GL_CHROMIUM_depth_texture");
     AddExtensionString("GL_GOOGLE_depth_texture");
     texture_format_validators_[GL_DEPTH_COMPONENT].AddValue(GL_UNSIGNED_SHORT);
@@ skipping 16 matching lines @@
     }
     validators_.render_buffer_format.AddValue(GL_DEPTH24_STENCIL8);
   }
 
   if (extensions.Contains("GL_OES_vertex_array_object") ||
       extensions.Contains("GL_ARB_vertex_array_object") ||
       extensions.Contains("GL_APPLE_vertex_array_object")) {
     feature_flags_.native_vertex_array_object = true;
   }
 
-  if (is_arm || is_imagination) {
-    workarounds_.use_client_side_arrays_for_stream_buffers = true;
-  }
-
   // If we're using client_side_arrays we have to emulate
   // vertex array objects since vertex array objects do not work
   // with client side arrays.
   if (workarounds_.use_client_side_arrays_for_stream_buffers) {
     feature_flags_.native_vertex_array_object = false;
   }
 
   if (extensions.Contains("GL_OES_element_index_uint") ||
       gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_OES_element_index_uint");
@@ skipping 100 matching lines @@
     validators_.read_pixel_type.AddValue(GL_HALF_FLOAT_OES);
     AddExtensionString("GL_OES_texture_half_float");
     if (enable_texture_half_float_linear) {
       AddExtensionString("GL_OES_texture_half_float_linear");
     }
   }
 
   // Check for multisample support
   bool ext_has_multisample =
       extensions.Contains("GL_EXT_framebuffer_multisample");
-  if (!is_qualcomm && !workarounds_.disable_angle_framebuffer_multisample) {
+  if (!workarounds_.disable_angle_framebuffer_multisample) {
     ext_has_multisample |=
        extensions.Contains("GL_ANGLE_framebuffer_multisample");
   }
   if (!disallowed_features_.multisampling && ext_has_multisample) {
     feature_flags_.chromium_framebuffer_multisample = true;
     validators_.frame_buffer_target.AddValue(GL_READ_FRAMEBUFFER_EXT);
     validators_.frame_buffer_target.AddValue(GL_DRAW_FRAMEBUFFER_EXT);
     validators_.g_l_state.AddValue(GL_READ_FRAMEBUFFER_BINDING_EXT);
     validators_.g_l_state.AddValue(GL_MAX_SAMPLES_EXT);
     validators_.render_buffer_parameter.AddValue(GL_RENDERBUFFER_SAMPLES_EXT);
@@ skipping 98 matching lines @@
   }
 
   bool have_ext_occlusion_query_boolean =
       extensions.Contains("GL_EXT_occlusion_query_boolean");
   bool have_arb_occlusion_query2 =
       extensions.Contains("GL_ARB_occlusion_query2");
   bool have_arb_occlusion_query =
       extensions.Contains("GL_ARB_occlusion_query");
 
   if (!workarounds_.disable_ext_occlusion_query &&
-#if defined(OS_LINUX)
-      !is_intel &&
-#endif
       (have_ext_occlusion_query_boolean ||
        have_arb_occlusion_query2 ||
        have_arb_occlusion_query)) {
     AddExtensionString("GL_EXT_occlusion_query_boolean");
     feature_flags_.occlusion_query_boolean = true;
     feature_flags_.use_arb_occlusion_query2_for_occlusion_query_boolean =
         !have_ext_occlusion_query_boolean && have_arb_occlusion_query2;
     feature_flags_.use_arb_occlusion_query_for_occlusion_query_boolean =
         !have_ext_occlusion_query_boolean && have_arb_occlusion_query &&
         !have_arb_occlusion_query2;
@@ skipping 53 matching lines @@
   if (extensions_.find(str) == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu