Blacklist MSAA for GPU Raster on Intel GPUs

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 823 matching lines @@
   }
 
   bool EnsureGPUMemoryAvailable(size_t estimated_size) {
     MemoryTracker* tracker = memory_tracker();
     if (tracker) {
       return tracker->EnsureGPUMemoryAvailable(estimated_size);
     }
     return true;
   }
 
-  bool IsWebGLContext() const {
-    return context_type_ == CONTEXT_TYPE_WEBGL1 ||
-           context_type_ == CONTEXT_TYPE_WEBGL2;
-  }
-
   bool IsOffscreenBufferMultisampled() const {
     return offscreen_target_samples_ > 1;
   }
 
   // Creates a Texture for the given texture.
   TextureRef* CreateTexture(
       GLuint client_id, GLuint service_id) {
     return texture_manager()->CreateTexture(client_id, service_id);
   }
 
@@ skipping 1757 matching lines @@
     const std::vector<int32>& attribs) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::Initialize");
   DCHECK(context->IsCurrent(surface.get()));
   DCHECK(!context_.get());
   DCHECK(!offscreen || !offscreen_size.IsEmpty());
 
   ContextCreationAttribHelper attrib_parser;
   if (!attrib_parser.Parse(attribs))
     return false;
 
-  context_type_ = attrib_parser.context_type;
-
   surfaceless_ = surface->IsSurfaceless() && !offscreen;
 
   set_initialized();
   gpu_state_tracer_ = GPUStateTracer::Create(&state_);
 
   if (base::CommandLine::InitializedForCurrentProcess()) {
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableGPUDebugging)) {
       set_debug(true);
     }
@@ skipping 29 matching lines @@
   // If the failIfMajorPerformanceCaveat context creation attribute was true
   // and we are using a software renderer, fail.
   if (attrib_parser.fail_if_major_perf_caveat &&
       feature_info_->feature_flags().is_swiftshader) {
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
     Destroy(true);
     return false;
   }
 
   disallowed_features_ = disallowed_features;
-  if (context_type_ == CONTEXT_TYPE_WEBGL1) {
+  if (attrib_parser.context_type == CONTEXT_TYPE_WEBGL1) {
     disallowed_features_.npot_support = true;
   }
 
-  if (!group_->Initialize(this, context_type_, disallowed_features_)) {
+  if (!group_->Initialize(this, attrib_parser.context_type,
+                          disallowed_features_)) {
     group_ = NULL;  // Must not destroy ContextGroup if it is not initialized.
     Destroy(true);
     return false;
   }
   CHECK_GL_ERROR();
-  if (context_type_ == CONTEXT_TYPE_WEBGL2 ||
-      context_type_ == CONTEXT_TYPE_OPENGLES3) {
+  if (feature_info_->context_type() == CONTEXT_TYPE_WEBGL2 ||
+      feature_info_->context_type() == CONTEXT_TYPE_OPENGLES3) {
     if (!feature_info_->IsES3Capable()) {
       LOG(ERROR) << "Underlying driver does not support ES3.";
       Destroy(true);
       return false;
     }
     feature_info_->EnableES3Validators();
     set_unsafe_es3_apis_enabled(true);
 
     frag_depth_explicitly_enabled_ = true;
     draw_buffers_explicitly_enabled_ = true;
@@ skipping 520 matching lines @@
   resources.MaxExpressionComplexity = 256;
   resources.MaxCallStackDepth = 256;
 
   GLint range[2] = { 0, 0 };
   GLint precision = 0;
   GetShaderPrecisionFormatImpl(GL_FRAGMENT_SHADER, GL_HIGH_FLOAT,
                                range, &precision);
   resources.FragmentPrecisionHigh =
       PrecisionMeetsSpecForHighpFloat(range[0], range[1], precision);
 
-  if (IsWebGLContext()) {
+  if (feature_info_->IsWebGLContext()) {
     resources.OES_standard_derivatives = derivatives_explicitly_enabled_;
     resources.EXT_frag_depth = frag_depth_explicitly_enabled_;
     resources.EXT_draw_buffers = draw_buffers_explicitly_enabled_;
     if (!draw_buffers_explicitly_enabled_)
       resources.MaxDrawBuffers = 1;
     resources.EXT_shader_texture_lod = shader_texture_lod_explicitly_enabled_;
     resources.NV_draw_buffers =
         draw_buffers_explicitly_enabled_ && features().nv_draw_buffers;
   } else {
     resources.OES_standard_derivatives =
         features().oes_standard_derivatives ? 1 : 0;
     resources.ARB_texture_rectangle =
         features().arb_texture_rectangle ? 1 : 0;
     resources.OES_EGL_image_external =
         features().oes_egl_image_external ? 1 : 0;
     resources.EXT_draw_buffers =
         features().ext_draw_buffers ? 1 : 0;
     resources.EXT_frag_depth =
         features().ext_frag_depth ? 1 : 0;
     resources.EXT_shader_texture_lod =
         features().ext_shader_texture_lod ? 1 : 0;
     resources.NV_draw_buffers =
         features().nv_draw_buffers ? 1 : 0;
   }
 
   ShShaderSpec shader_spec;
-  switch (context_type_) {
+  switch (feature_info_->context_type()) {
     case CONTEXT_TYPE_WEBGL1:
       shader_spec = SH_WEBGL_SPEC;
       break;
     case CONTEXT_TYPE_WEBGL2:
       shader_spec = SH_WEBGL2_SPEC;
       break;
     case CONTEXT_TYPE_OPENGLES2:
       shader_spec = SH_GLES2_SPEC;
       break;
     case CONTEXT_TYPE_OPENGLES3:
@@ skipping 5732 matching lines @@
               accepted_types.push_back(GL_FLOAT);
             }
             break;
           default:
             accepted_types.push_back(GL_UNSIGNED_BYTE);
             break;
         }
       }
       break;
   }
-  if (!IsWebGLContext()) {
+  if (!feature_info_->IsWebGLContext()) {
     accepted_formats.push_back(GL_BGRA_EXT);
     accepted_types.push_back(GL_UNSIGNED_BYTE);
   }
   DCHECK_EQ(accepted_formats.size(), accepted_types.size());
   bool format_type_acceptable = false;
   for (size_t ii = 0; ii < accepted_formats.size(); ++ii) {
     if (format == accepted_formats[ii] && type == accepted_types[ii]) {
       format_type_acceptable = true;
       break;
     }
@@ skipping 480 matching lines @@
     case GL_SHADING_LANGUAGE_VERSION:
       if (unsafe_es3_apis_enabled())
         str = "OpenGL ES GLSL ES 3.0 Chromium";
       else
         str = "OpenGL ES GLSL ES 1.0 Chromium";
       break;
     case GL_RENDERER:
     case GL_VENDOR:
       // Return the unmasked VENDOR/RENDERER string for WebGL contexts.
       // They are used by WEBGL_debug_renderer_info.
-      if (!IsWebGLContext())
+      if (!feature_info_->IsWebGLContext())
         str = "Chromium";
       else
         str = reinterpret_cast<const char*>(glGetString(name));
       break;
     case GL_EXTENSIONS:
       {
         // For WebGL contexts, strip out the OES derivatives and
         // EXT frag depth extensions if they have not been enabled.
-        if (IsWebGLContext()) {
+        if (feature_info_->IsWebGLContext()) {
           extensions = feature_info_->extensions();
           if (!derivatives_explicitly_enabled_) {
             size_t offset = extensions.find(kOESDerivativeExtension);
             if (std::string::npos != offset) {
               extensions.replace(offset, arraysize(kOESDerivativeExtension),
                                  std::string());
             }
           }
           if (!frag_depth_explicitly_enabled_) {
             size_t offset = extensions.find(kEXTFragDepthExtension);
@@ skipping 2426 matching lines @@
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::GetRequestableExtensionsCHROMIUM& c =
       *static_cast<const gles2::cmds::GetRequestableExtensionsCHROMIUM*>(
           cmd_data);
   Bucket* bucket = CreateBucket(c.bucket_id);
   scoped_refptr<FeatureInfo> info(new FeatureInfo());
-  info->Initialize(disallowed_features_);
+  info->Initialize(feature_info_->context_type(), disallowed_features_);
   bucket->SetFromString(info->extensions().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRequestExtensionCHROMIUM(
     uint32 immediate_data_size,
     const void* cmd_data) {
   const gles2::cmds::RequestExtensionCHROMIUM& c =
       *static_cast<const gles2::cmds::RequestExtensionCHROMIUM*>(cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string feature_str;
   if (!bucket->GetAsString(&feature_str)) {
     return error::kInvalidArguments;
   }
 
   bool desire_standard_derivatives = false;
   bool desire_frag_depth = false;
   bool desire_draw_buffers = false;
   bool desire_shader_texture_lod = false;
-  if (IsWebGLContext()) {
+  if (feature_info_->IsWebGLContext()) {
     desire_standard_derivatives =
         feature_str.find("GL_OES_standard_derivatives") != std::string::npos;
     desire_frag_depth =
         feature_str.find("GL_EXT_frag_depth") != std::string::npos;
     desire_draw_buffers =
         feature_str.find("GL_EXT_draw_buffers") != std::string::npos;
     desire_shader_texture_lod =
         feature_str.find("GL_EXT_shader_texture_lod") != std::string::npos;
   }
 
@@ skipping 3059 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu