Blacklist MSAA for GPU Raster on Intel GPUs

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 <vector>
 
 #include "base/command_line.h"
@@ skipping 213 matching lines @@
       command_line->HasSwitch(switches::kDisableVirtualContexts);
 
   // The shader translator is needed to translate from WebGL-conformant GLES SL
   // to normal GLES SL, enforce WebGL conformance, translate from GLES SL 1.0 to
   // target context GLSL, etc.
   // The flag here is for testing only.
   disable_shader_translator_ =
       command_line->HasSwitch(switches::kDisableGLSLTranslator);
 
   unsafe_es3_apis_enabled_ = false;
+
+  // Default context_type_ to a GLES2 Context.
+  context_type_ = CONTEXT_TYPE_OPENGLES2;
 }
 
-bool FeatureInfo::Initialize() {
-  disallowed_features_ = DisallowedFeatures();
+bool FeatureInfo::Initialize(ContextType context_type,
+                             const DisallowedFeatures& disallowed_features) {
+  disallowed_features_ = disallowed_features;
+  context_type_ = context_type;
   InitializeFeatures();
   return true;
 }
 
-bool FeatureInfo::Initialize(const DisallowedFeatures& disallowed_features) {
-  disallowed_features_ = disallowed_features;
-  InitializeFeatures();
-  return true;
+bool FeatureInfo::InitializeForTesting() {
+  return Initialize(CONTEXT_TYPE_OPENGLES2, DisallowedFeatures());
 }
 
 bool IsGL_REDSupportedOnFBOs() {
   // Skia uses GL_RED with frame buffers, unfortunately, Mesa claims to support
   // GL_EXT_texture_rg, but it doesn't support it on frame buffers.  To fix
   // this, we try it, and if it fails, we don't expose GL_EXT_texture_rg.
   GLint fb_binding = 0;
   GLint tex_binding = 0;
   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fb_binding);
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex_binding);
@@ skipping 435 matching lines @@
       AddExtensionString("GL_CHROMIUM_color_buffer_float_rgba");
     }
     if (statusRGB == GL_FRAMEBUFFER_COMPLETE) {
       validators_.texture_internal_format.AddValue(GL_RGB32F);
       feature_flags_.chromium_color_buffer_float_rgb = true;
       AddExtensionString("GL_CHROMIUM_color_buffer_float_rgb");
     }
   }
 
   // Check for multisample support
-  if (!workarounds_.disable_chromium_framebuffer_multisample) {
+
+  // crbug.com/527565 - On some GPUs, MSAA does not perform acceptably for
+  // rasterization. We disable it on non-WebGL contexts. For WebGL contexts
+  // we leave it up to the site to decide whether to enable MSAA.
+  bool disable_all_multisample =
+      workarounds_.disable_msaa_on_non_webgl_contexts && !IsWebGLContext();
+
+  if (!disable_all_multisample &&
+      !workarounds_.disable_chromium_framebuffer_multisample) {
     bool ext_has_multisample =
         extensions.Contains("GL_EXT_framebuffer_multisample") ||
         gl_version_info_->is_es3 ||
         gl_version_info_->is_desktop_core_profile;
     if (gl_version_info_->is_angle) {
       ext_has_multisample |=
           extensions.Contains("GL_ANGLE_framebuffer_multisample");
     }
     feature_flags_.use_core_framebuffer_multisample =
         gl_version_info_->is_es3 || gl_version_info_->is_desktop_core_profile;
     if (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);
       AddExtensionString("GL_CHROMIUM_framebuffer_multisample");
     }
   }
 
-  if (!workarounds_.disable_multisampled_render_to_texture) {
+  if (!disable_all_multisample &&
+      !workarounds_.disable_multisampled_render_to_texture) {
     if (extensions.Contains("GL_EXT_multisampled_render_to_texture")) {
       feature_flags_.multisampled_render_to_texture = true;
     } else if (extensions.Contains("GL_IMG_multisampled_render_to_texture")) {
       feature_flags_.multisampled_render_to_texture = true;
       feature_flags_.use_img_for_multisampled_render_to_texture = true;
     }
     if (feature_flags_.multisampled_render_to_texture) {
       validators_.render_buffer_parameter.AddValue(
           GL_RENDERBUFFER_SAMPLES_EXT);
       validators_.g_l_state.AddValue(GL_MAX_SAMPLES_EXT);
@@ skipping 452 matching lines @@
   };
   if (max_draw_buffers < kTotalDrawBufferEnums) {
     validators_.g_l_state.RemoveValues(
         kDrawBuffers + max_draw_buffers,
         kTotalDrawBufferEnums - max_draw_buffers);
   }
 
   unsafe_es3_apis_enabled_ = true;
 }
 
+bool FeatureInfo::IsWebGLContext() const {
+  // Switch statement to cause a compile-time error if we miss a case.
+  switch (context_type_) {
+    case CONTEXT_TYPE_WEBGL1:
+    case CONTEXT_TYPE_WEBGL2:
+      return true;
+    case CONTEXT_TYPE_OPENGLES2:
+    case CONTEXT_TYPE_OPENGLES3:
+      return false;
+  }
+
+  NOTREACHED();
+  return false;
+}
+
 void FeatureInfo::AddExtensionString(const char* s) {
   std::string str(s);
   size_t pos = extensions_.find(str);
   while (pos != std::string::npos &&
          pos + str.length() < extensions_.length() &&
          extensions_.substr(pos + str.length(), 1) != " ") {
     // This extension name is a substring of another.
     pos = extensions_.find(str, pos + str.length());
   }
   if (pos == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu