Don't enable occlusion query on Linux with Intel drivers.

TEST=none
BUG=128083


Review URL: https://chromiumcodereview.appspot.com/10381137

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@137179 0039d316-1c4b-4281-b951-d872f2087c98

gpu/command_buffer/service/context_group.cc

@@ -163,17 +163,11 @@ bool ContextGroup::Initialize(const DisallowedFeatures& disallowed_features,
   // TODO(gman): Update this code to check for a specific version of
   // the drivers above which we no longer need this fix.
 #if defined(OS_MACOSX)
-  const char* vendor_str = reinterpret_cast<const char*>(
-      glGetString(GL_VENDOR));
-  if (vendor_str) {
-    std::string lc_str(::StringToLowerASCII(std::string(vendor_str)));
-    bool intel_on_mac = strstr(lc_str.c_str(), "intel");
-    if (intel_on_mac) {
-      max_texture_size = std::min(
+  if (feature_info_->feature_flags().is_intel) {
+    max_texture_size = std::min(
         static_cast<GLint>(4096), max_texture_size);
-      max_cube_map_texture_size = std::min(
+    max_cube_map_texture_size = std::min(
         static_cast<GLint>(512), max_cube_map_texture_size);
-    }
   }
 #endif
   texture_manager_.reset(new TextureManager(feature_info_.get(),

gpu/command_buffer/service/feature_info.cc

@@ -7,6 +7,7 @@
 #include <set>
 
 #include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
@@ -108,6 +109,16 @@ void FeatureInfo::AddFeatures(const char* desired_features) {
           gfx::GLContext::GetCurrent()->GetExtensions().c_str() :
           reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)),
       desired_features);
+  const char* vendor_str = reinterpret_cast<const char*>(
+      glGetString(GL_VENDOR));
+  if (vendor_str) {
+    std::string str(StringToLowerASCII(std::string(vendor_str)));
+    feature_flags_.is_intel = str.find("intel") != std::string::npos;
+    feature_flags_.is_nvidia = str.find("nvidia") != std::string::npos;
+    feature_flags_.is_amd =
+        str.find("amd") != std::string::npos ||
+        str.find("ati") != std::string::npos;
+  }
 
   bool npot_ok = false;
 
@@ -446,7 +457,15 @@ void FeatureInfo::AddFeatures(const char* desired_features) {
       ext.Have("GL_EXT_occlusion_query_boolean");
   bool have_arb_occlusion_query2 = ext.Have("GL_ARB_occlusion_query2");
   bool have_arb_occlusion_query = ext.Have("GL_ARB_occlusion_query");
-  if (ext.Desire("GL_EXT_occlusion_query_boolean") &&
+  bool ext_occlusion_query_disallowed = false;
+
+#if defined(OS_LINUX)
+  // Intel drivers on Linux appear to be buggy.
+  ext_occlusion_query_disallowed = feature_flags_.is_intel;
+#endif
+
+  if (!ext_occlusion_query_disallowed &&
+      ext.Desire("GL_EXT_occlusion_query_boolean") &&
       (have_ext_occlusion_query_boolean ||
        have_arb_occlusion_query2 ||
        have_arb_occlusion_query)) {

gpu/command_buffer/service/feature_info.h

@@ -35,7 +35,10 @@ class GPU_EXPORT FeatureInfo : public base::RefCounted<FeatureInfo> {
           angle_instanced_arrays(false),
           occlusion_query_boolean(false),
           use_arb_occlusion_query2_for_occlusion_query_boolean(false),
-          use_arb_occlusion_query_for_occlusion_query_boolean(false) {
+          use_arb_occlusion_query_for_occlusion_query_boolean(false),
+          is_intel(false),
+          is_nvidia(false),
+          is_amd(false) {
     }
 
     bool chromium_framebuffer_multisample;
@@ -53,6 +56,9 @@ class GPU_EXPORT FeatureInfo : public base::RefCounted<FeatureInfo> {
     bool occlusion_query_boolean;
     bool use_arb_occlusion_query2_for_occlusion_query_boolean;
     bool use_arb_occlusion_query_for_occlusion_query_boolean;
+    bool is_intel;
+    bool is_nvidia;
+    bool is_amd;
   };
 
   FeatureInfo();

gpu/command_buffer/service/feature_info_unittest.cc

@@ -33,7 +33,13 @@ class FeatureInfoTest : public testing::Test {
   }
 
   void SetupInitExpectations(const char* extensions) {
-    TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), extensions);
+    SetupInitExpectationsWithVendor(extensions, "");
+  }
+
+  void SetupInitExpectationsWithVendor(
+      const char* extensions, const char* vendor) {
+    TestHelper::SetupFeatureInfoInitExpectationsWithVendor(
+        gl_.get(), extensions, vendor);
   }
 
  protected:
@@ -72,6 +78,9 @@ TEST_F(FeatureInfoTest, Basic) {
       ).use_arb_occlusion_query2_for_occlusion_query_boolean);
   EXPECT_FALSE(info_->feature_flags(
       ).use_arb_occlusion_query_for_occlusion_query_boolean);
+  EXPECT_FALSE(info_->feature_flags().is_intel);
+  EXPECT_FALSE(info_->feature_flags().is_nvidia);
+  EXPECT_FALSE(info_->feature_flags().is_amd);
 }
 
 TEST_F(FeatureInfoTest, InitializeNoExtensions) {
@@ -491,6 +500,38 @@ TEST_F(FeatureInfoTest, InitializeARB_occlusion_query2) {
       ).use_arb_occlusion_query_for_occlusion_query_boolean);
 }
 
+TEST_F(FeatureInfoTest, IsIntel) {
+  SetupInitExpectationsWithVendor("", "iNTel");
+  info_->Initialize(NULL);
+  EXPECT_TRUE(info_->feature_flags().is_intel);
+  EXPECT_FALSE(info_->feature_flags().is_nvidia);
+  EXPECT_FALSE(info_->feature_flags().is_amd);
+}
+
+TEST_F(FeatureInfoTest, IsNvidia) {
+  SetupInitExpectationsWithVendor("", "nvIdIa");
+  info_->Initialize(NULL);
+  EXPECT_FALSE(info_->feature_flags().is_intel);
+  EXPECT_TRUE(info_->feature_flags().is_nvidia);
+  EXPECT_FALSE(info_->feature_flags().is_amd);
+}
+
+TEST_F(FeatureInfoTest, IsAMD) {
+  SetupInitExpectationsWithVendor("", "aMd");
+  info_->Initialize(NULL);
+  EXPECT_FALSE(info_->feature_flags().is_intel);
+  EXPECT_FALSE(info_->feature_flags().is_nvidia);
+  EXPECT_TRUE(info_->feature_flags().is_amd);
+}
+
+TEST_F(FeatureInfoTest, IsAMDATI) {
+  SetupInitExpectationsWithVendor("", "aTI");
+  info_->Initialize(NULL);
+  EXPECT_FALSE(info_->feature_flags().is_intel);
+  EXPECT_FALSE(info_->feature_flags().is_nvidia);
+  EXPECT_TRUE(info_->feature_flags().is_amd);
+}
+
 }  // namespace gles2
 }  // namespace gpu
 

gpu/command_buffer/service/gles2_cmd_decoder.cc

@@ -2236,12 +2236,10 @@ bool GLES2DecoderImpl::Initialize(
 
   if (!disable_workarounds_) {
 #if defined(OS_MACOSX)
-    const char* vendor_str = reinterpret_cast<const char*>(
-        glGetString(GL_VENDOR));
     needs_mac_nvidia_driver_workaround_ =
-        vendor_str && strstr(vendor_str, "NVIDIA");
+        feature_info_->feature_flags().is_nvidia;
     needs_glsl_built_in_function_emulation_ =
-        vendor_str && (strstr(vendor_str, "ATI") || strstr(vendor_str, "AMD"));
+        feature_info_->feature_flags().is_amd;
 #endif
   }
 

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc

@@ -296,12 +296,6 @@ void GLES2DecoderTestBase::InitDecoder(
       .Times(1)
       .RetiresOnSaturation();
 
-#if defined(OS_MACOSX)
-  EXPECT_CALL(*gl_, GetString(GL_VENDOR))
-      .Times(1)
-      .RetiresOnSaturation();
-#endif
-
   EXPECT_CALL(*gl_, Viewport(
       kViewportX, kViewportY, kViewportWidth, kViewportHeight))
       .Times(1)

gpu/command_buffer/service/test_helper.cc

@@ -190,13 +190,6 @@ void TestHelper::SetupContextGroupInitExpectations(
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, _))
       .WillOnce(SetArgumentPointee<1>(kMaxCubeMapTextureSize))
       .RetiresOnSaturation();
-
-#if defined(OS_MACOSX)
-  EXPECT_CALL(*gl, GetString(GL_VENDOR))
-      .WillOnce(Return(reinterpret_cast<const uint8*>("")))
-      .RetiresOnSaturation();
-#endif
-
   EXPECT_CALL(*gl, GetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, _))
       .WillOnce(SetArgumentPointee<1>(kMaxTextureImageUnits))
       .RetiresOnSaturation();
@@ -218,11 +211,19 @@ void TestHelper::SetupContextGroupInitExpectations(
 
 void TestHelper::SetupFeatureInfoInitExpectations(
       ::gfx::MockGLInterface* gl, const char* extensions) {
+  SetupFeatureInfoInitExpectationsWithVendor(gl, extensions, "");
+}
+
+void TestHelper::SetupFeatureInfoInitExpectationsWithVendor(
+     ::gfx::MockGLInterface* gl, const char* extensions, const char* vendor) {
   InSequence sequence;
 
   EXPECT_CALL(*gl, GetString(GL_EXTENSIONS))
       .WillOnce(Return(reinterpret_cast<const uint8*>(extensions)))
       .RetiresOnSaturation();
+  EXPECT_CALL(*gl, GetString(GL_VENDOR))
+      .WillOnce(Return(reinterpret_cast<const uint8*>(vendor)))
+      .RetiresOnSaturation();
 }
 
 void TestHelper::SetupExpectationsForClearingUniforms(

gpu/command_buffer/service/test_helper.h

@@ -61,6 +61,8 @@ class TestHelper {
       const char* extensions);
   static void SetupFeatureInfoInitExpectations(
       ::gfx::MockGLInterface* gl, const char* extensions);
+  static void SetupFeatureInfoInitExpectationsWithVendor(
+      ::gfx::MockGLInterface* gl, const char* extensions, const char* vendor);
   static void SetupTextureManagerInitExpectations(::gfx::MockGLInterface* gl,
                                                   const char* extensions);