gpu/command_buffer/service/feature_info.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/feature_info.h"
   6
   7 #include <set>
   8
   9 #include "base/command_line.h"
  10 #include "base/macros.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/string_util.h"
  15 #include "gpu/command_buffer/service/gl_utils.h"
  16 #include "gpu/command_buffer/service/gpu_switches.h"
  17 #include "ui/gl/gl_fence.h"
  18 #include "ui/gl/gl_implementation.h"
  19
  20 #if !defined(OS_MACOSX)
  21 #include "ui/gl/gl_fence_egl.h"
  22 #endif
  23
  24 namespace gpu {
  25 namespace gles2 {
  26
  27 namespace {
  28
  29 struct FormatInfo {
  30   GLenum format;
  31   const GLenum* types;
  32   size_t count;
  33 };
  34
  35 class StringSet {
  36  public:
  37   StringSet() {}
  38
  39   StringSet(const char* s) {
  40     Init(s);
  41   }
  42
  43   StringSet(const std::string& str) {
  44     Init(str);
  45   }
  46
  47   void Init(const char* s) {
  48     std::string str(s ? s : "");
  49     Init(str);
  50   }
  51
  52   void Init(const std::string& str) {
  53     std::vector<std::string> tokens;
  54     Tokenize(str, " ", &tokens);
  55     string_set_.insert(tokens.begin(), tokens.end());
  56   }
  57
  58   bool Contains(const char* s) {
  59     return string_set_.find(s) != string_set_.end();
  60   }
  61
  62   bool Contains(const std::string& s) {
  63     return string_set_.find(s) != string_set_.end();
  64   }
  65
  66  private:
  67   std::set<std::string> string_set_;
  68 };
  69
  70 // Process a string of wordaround type IDs (seperated by ',') and set up
  71 // the corresponding Workaround flags.
  72 void StringToWorkarounds(
  73     const std::string& types, FeatureInfo::Workarounds* workarounds) {
  74   DCHECK(workarounds);
  75   std::vector<std::string> pieces;
  76   base::SplitString(types, ',', &pieces);
  77   for (size_t i = 0; i < pieces.size(); ++i) {
  78     int number = 0;
  79     bool succeed = base::StringToInt(pieces[i], &number);
  80     DCHECK(succeed);
  81     switch (number) {
  82 #define GPU_OP(type, name)    \
  83   case gpu::type:             \
  84     workarounds->name = true; \
  85     break;
  86       GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
  87 #undef GPU_OP
  88       default:
  89         NOTIMPLEMENTED();
  90     }
  91   }
  92   if (workarounds->max_texture_size_limit_4096)
  93     workarounds->max_texture_size = 4096;
  94   if (workarounds->max_cube_map_texture_size_limit_4096)
  95     workarounds->max_cube_map_texture_size = 4096;
  96   if (workarounds->max_cube_map_texture_size_limit_1024)
  97     workarounds->max_cube_map_texture_size = 1024;
  98   if (workarounds->max_cube_map_texture_size_limit_512)
  99     workarounds->max_cube_map_texture_size = 512;
 100
 101   if (workarounds->max_fragment_uniform_vectors_32)
 102     workarounds->max_fragment_uniform_vectors = 32;
 103   if (workarounds->max_varying_vectors_16)
 104     workarounds->max_varying_vectors = 16;
 105   if (workarounds->max_vertex_uniform_vectors_256)
 106     workarounds->max_vertex_uniform_vectors = 256;
 107 }
 108
 109 }  // anonymous namespace.
 110
 111 FeatureInfo::FeatureFlags::FeatureFlags()
 112     : chromium_color_buffer_float_rgba(false),
 113       chromium_color_buffer_float_rgb(false),
 114       chromium_framebuffer_multisample(false),
 115       chromium_sync_query(false),
 116       use_core_framebuffer_multisample(false),
 117       multisampled_render_to_texture(false),
 118       use_img_for_multisampled_render_to_texture(false),
 119       oes_standard_derivatives(false),
 120       oes_egl_image_external(false),
 121       oes_depth24(false),
 122       oes_compressed_etc1_rgb8_texture(false),
 123       packed_depth24_stencil8(false),
 124       npot_ok(false),
 125       enable_texture_float_linear(false),
 126       enable_texture_half_float_linear(false),
 127       angle_translated_shader_source(false),
 128       angle_pack_reverse_row_order(false),
 129       arb_texture_rectangle(false),
 130       angle_instanced_arrays(false),
 131       occlusion_query_boolean(false),
 132       use_arb_occlusion_query2_for_occlusion_query_boolean(false),
 133       use_arb_occlusion_query_for_occlusion_query_boolean(false),
 134       native_vertex_array_object(false),
 135       ext_texture_format_bgra8888(false),
 136       enable_shader_name_hashing(false),
 137       enable_samplers(false),
 138       ext_draw_buffers(false),
 139       nv_draw_buffers(false),
 140       ext_frag_depth(false),
 141       ext_shader_texture_lod(false),
 142       use_async_readpixels(false),
 143       map_buffer_range(false),
 144       ext_discard_framebuffer(false),
 145       angle_depth_texture(false),
 146       is_swiftshader(false),
 147       angle_texture_usage(false),
 148       ext_texture_storage(false),
 149       chromium_path_rendering(false),
 150       blend_equation_advanced(false),
 151       blend_equation_advanced_coherent(false),
 152       ext_texture_rg(false),
 153       enable_subscribe_uniform(false) {
 154 }
 155
 156 FeatureInfo::Workarounds::Workarounds() :
 157 #define GPU_OP(type, name) name(false),
 158     GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
 159 #undef GPU_OP
 160     max_texture_size(0),
 161     max_cube_map_texture_size(0),
 162     max_fragment_uniform_vectors(0),
 163     max_varying_vectors(0),
 164     max_vertex_uniform_vectors(0) {
 165 }
 166
 167 FeatureInfo::FeatureInfo() {
 168   InitializeBasicState(*base::CommandLine::ForCurrentProcess());
 169 }
 170
 171 FeatureInfo::FeatureInfo(const base::CommandLine& command_line) {
 172   InitializeBasicState(command_line);
 173 }
 174
 175 void FeatureInfo::InitializeBasicState(const base::CommandLine& command_line) {
 176   if (command_line.HasSwitch(switches::kGpuDriverBugWorkarounds)) {
 177     std::string types = command_line.GetSwitchValueASCII(
 178         switches::kGpuDriverBugWorkarounds);
 179     StringToWorkarounds(types, &workarounds_);
 180   }
 181   feature_flags_.enable_shader_name_hashing =
 182       !command_line.HasSwitch(switches::kDisableShaderNameHashing);
 183
 184   feature_flags_.is_swiftshader =
 185       (command_line.GetSwitchValueASCII(switches::kUseGL) == "swiftshader");
 186
 187   feature_flags_.enable_subscribe_uniform =
 188       command_line.HasSwitch(switches::kEnableSubscribeUniformExtension);
 189
 190   static const GLenum kAlphaTypes[] = {
 191       GL_UNSIGNED_BYTE,
 192   };
 193   static const GLenum kRGBTypes[] = {
 194       GL_UNSIGNED_BYTE,
 195       GL_UNSIGNED_SHORT_5_6_5,
 196   };
 197   static const GLenum kRGBATypes[] = {
 198       GL_UNSIGNED_BYTE,
 199       GL_UNSIGNED_SHORT_4_4_4_4,
 200       GL_UNSIGNED_SHORT_5_5_5_1,
 201   };
 202   static const GLenum kLuminanceTypes[] = {
 203       GL_UNSIGNED_BYTE,
 204   };
 205   static const GLenum kLuminanceAlphaTypes[] = {
 206       GL_UNSIGNED_BYTE,
 207   };
 208   static const FormatInfo kFormatTypes[] = {
 209     { GL_ALPHA, kAlphaTypes, arraysize(kAlphaTypes), },
 210     { GL_RGB, kRGBTypes, arraysize(kRGBTypes), },
 211     { GL_RGBA, kRGBATypes, arraysize(kRGBATypes), },
 212     { GL_LUMINANCE, kLuminanceTypes, arraysize(kLuminanceTypes), },
 213     { GL_LUMINANCE_ALPHA, kLuminanceAlphaTypes,
 214       arraysize(kLuminanceAlphaTypes), } ,
 215   };
 216   for (size_t ii = 0; ii < arraysize(kFormatTypes); ++ii) {
 217     const FormatInfo& info = kFormatTypes[ii];
 218     ValueValidator<GLenum>& validator = texture_format_validators_[info.format];
 219     for (size_t jj = 0; jj < info.count; ++jj) {
 220       validator.AddValue(info.types[jj]);
 221     }
 222   }
 223 }
 224
 225 bool FeatureInfo::Initialize() {
 226   disallowed_features_ = DisallowedFeatures();
 227   InitializeFeatures();
 228   return true;
 229 }
 230
 231 bool FeatureInfo::Initialize(const DisallowedFeatures& disallowed_features) {
 232   disallowed_features_ = disallowed_features;
 233   InitializeFeatures();
 234   return true;
 235 }
 236
 237 bool IsGL_REDSupportedOnFBOs() {
 238   // Skia uses GL_RED with frame buffers, unfortunately, Mesa claims to support
 239   // GL_EXT_texture_rg, but it doesn't support it on frame buffers.  To fix
 240   // this, we try it, and if it fails, we don't expose GL_EXT_texture_rg.
 241   GLint fb_binding = 0;
 242   GLint tex_binding = 0;
 243   glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fb_binding);
 244   glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex_binding);
 245
 246   GLuint textureId = 0;
 247   glGenTextures(1, &textureId);
 248   glBindTexture(GL_TEXTURE_2D, textureId);
 249   GLubyte data[1] = {0};
 250   glTexImage2D(GL_TEXTURE_2D, 0, GL_RED_EXT, 1, 1, 0, GL_RED_EXT,
 251                GL_UNSIGNED_BYTE, data);
 252   GLuint textureFBOID = 0;
 253   glGenFramebuffersEXT(1, &textureFBOID);
 254   glBindFramebufferEXT(GL_FRAMEBUFFER, textureFBOID);
 255   glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
 256                             textureId, 0);
 257   bool result =
 258       glCheckFramebufferStatusEXT(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_UNSUPPORTED;
 259   glDeleteFramebuffersEXT(1, &textureFBOID);
 260   glDeleteTextures(1, &textureId);
 261
 262   glBindFramebufferEXT(GL_FRAMEBUFFER, static_cast<GLuint>(fb_binding));
 263   glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(tex_binding));
 264
 265   DCHECK(glGetError() == GL_NO_ERROR);
 266
 267   return result;
 268 }
 269
 270 void FeatureInfo::InitializeFeatures() {
 271   // Figure out what extensions to turn on.
 272   StringSet extensions(
 273       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
 274
 275   const char* renderer_str =
 276       reinterpret_cast<const char*>(glGetString(GL_RENDERER));
 277   const char* version_str =
 278       reinterpret_cast<const char*>(glGetString(GL_VERSION));
 279
 280   gl_version_info_.reset(new gfx::GLVersionInfo(version_str, renderer_str));
 281
 282   AddExtensionString("GL_ANGLE_translated_shader_source");
 283   AddExtensionString("GL_CHROMIUM_async_pixel_transfers");
 284   AddExtensionString("GL_CHROMIUM_bind_uniform_location");
 285   AddExtensionString("GL_CHROMIUM_command_buffer_query");
 286   AddExtensionString("GL_CHROMIUM_command_buffer_latency_query");
 287   AddExtensionString("GL_CHROMIUM_copy_texture");
 288   AddExtensionString("GL_CHROMIUM_get_error_query");
 289   AddExtensionString("GL_CHROMIUM_lose_context");
 290   AddExtensionString("GL_CHROMIUM_pixel_transfer_buffer_object");
 291   AddExtensionString("GL_CHROMIUM_rate_limit_offscreen_context");
 292   AddExtensionString("GL_CHROMIUM_resize");
 293   AddExtensionString("GL_CHROMIUM_resource_safe");
 294   AddExtensionString("GL_CHROMIUM_strict_attribs");
 295   AddExtensionString("GL_CHROMIUM_texture_mailbox");
 296   AddExtensionString("GL_CHROMIUM_trace_marker");
 297   AddExtensionString("GL_EXT_debug_marker");
 298
 299   if (feature_flags_.enable_subscribe_uniform) {
 300     AddExtensionString("GL_CHROMIUM_subscribe_uniform");
 301   }
 302
 303   // OES_vertex_array_object is emulated if not present natively,
 304   // so the extension string is always exposed.
 305   AddExtensionString("GL_OES_vertex_array_object");
 306
 307   if (!disallowed_features_.gpu_memory_manager)
 308     AddExtensionString("GL_CHROMIUM_gpu_memory_manager");
 309
 310   if (extensions.Contains("GL_ANGLE_translated_shader_source")) {
 311     feature_flags_.angle_translated_shader_source = true;
 312   }
 313
 314   // Check if we should allow GL_EXT_texture_compression_dxt1 and
 315   // GL_EXT_texture_compression_s3tc.
 316   bool enable_dxt1 = false;
 317   bool enable_dxt3 = false;
 318   bool enable_dxt5 = false;
 319   bool have_s3tc = extensions.Contains("GL_EXT_texture_compression_s3tc");
 320   bool have_dxt3 =
 321       have_s3tc || extensions.Contains("GL_ANGLE_texture_compression_dxt3");
 322   bool have_dxt5 =
 323       have_s3tc || extensions.Contains("GL_ANGLE_texture_compression_dxt5");
 324
 325   if (extensions.Contains("GL_EXT_texture_compression_dxt1") || have_s3tc) {
 326     enable_dxt1 = true;
 327   }
 328   if (have_dxt3) {
 329     enable_dxt3 = true;
 330   }
 331   if (have_dxt5) {
 332     enable_dxt5 = true;
 333   }
 334
 335   if (enable_dxt1) {
 336     AddExtensionString("GL_EXT_texture_compression_dxt1");
 337     validators_.compressed_texture_format.AddValue(
 338         GL_COMPRESSED_RGB_S3TC_DXT1_EXT);
 339     validators_.compressed_texture_format.AddValue(
 340         GL_COMPRESSED_RGBA_S3TC_DXT1_EXT);
 341   }
 342
 343   if (enable_dxt3) {
 344     // The difference between GL_EXT_texture_compression_s3tc and
 345     // GL_CHROMIUM_texture_compression_dxt3 is that the former
 346     // requires on the fly compression. The latter does not.
 347     AddExtensionString("GL_CHROMIUM_texture_compression_dxt3");
 348     validators_.compressed_texture_format.AddValue(
 349         GL_COMPRESSED_RGBA_S3TC_DXT3_EXT);
 350   }
 351
 352   if (enable_dxt5) {
 353     // The difference between GL_EXT_texture_compression_s3tc and
 354     // GL_CHROMIUM_texture_compression_dxt5 is that the former
 355     // requires on the fly compression. The latter does not.
 356     AddExtensionString("GL_CHROMIUM_texture_compression_dxt5");
 357     validators_.compressed_texture_format.AddValue(
 358         GL_COMPRESSED_RGBA_S3TC_DXT5_EXT);
 359   }
 360
 361   // Check if we should enable GL_EXT_texture_filter_anisotropic.
 362   if (extensions.Contains("GL_EXT_texture_filter_anisotropic")) {
 363     AddExtensionString("GL_EXT_texture_filter_anisotropic");
 364     validators_.texture_parameter.AddValue(
 365         GL_TEXTURE_MAX_ANISOTROPY_EXT);
 366     validators_.g_l_state.AddValue(
 367         GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT);
 368   }
 369
 370   // Check if we should support GL_OES_packed_depth_stencil and/or
 371   // GL_GOOGLE_depth_texture / GL_CHROMIUM_depth_texture.
 372   //
 373   // NOTE: GL_OES_depth_texture requires support for depth cubemaps.
 374   // GL_ARB_depth_texture requires other features that
 375   // GL_OES_packed_depth_stencil does not provide.
 376   //
 377   // Therefore we made up GL_GOOGLE_depth_texture / GL_CHROMIUM_depth_texture.
 378   //
 379   // GL_GOOGLE_depth_texture is legacy. As we exposed it into NaCl we can't
 380   // get rid of it.
 381   //
 382   bool enable_depth_texture = false;
 383   if (!workarounds_.disable_depth_texture &&
 384       (extensions.Contains("GL_ARB_depth_texture") ||
 385        extensions.Contains("GL_OES_depth_texture") ||
 386        extensions.Contains("GL_ANGLE_depth_texture") ||
 387        gl_version_info_->is_es3)) {
 388     enable_depth_texture = true;
 389     feature_flags_.angle_depth_texture =
 390         extensions.Contains("GL_ANGLE_depth_texture");
 391   }
 392
 393   if (enable_depth_texture) {
 394     AddExtensionString("GL_CHROMIUM_depth_texture");
 395     AddExtensionString("GL_GOOGLE_depth_texture");
 396     texture_format_validators_[GL_DEPTH_COMPONENT].AddValue(GL_UNSIGNED_SHORT);
 397     texture_format_validators_[GL_DEPTH_COMPONENT].AddValue(GL_UNSIGNED_INT);
 398     validators_.texture_internal_format.AddValue(GL_DEPTH_COMPONENT);
 399     validators_.texture_format.AddValue(GL_DEPTH_COMPONENT);
 400     validators_.pixel_type.AddValue(GL_UNSIGNED_SHORT);
 401     validators_.pixel_type.AddValue(GL_UNSIGNED_INT);
 402   }
 403
 404   if (extensions.Contains("GL_EXT_packed_depth_stencil") ||
 405       extensions.Contains("GL_OES_packed_depth_stencil") ||
 406       gl_version_info_->is_es3) {
 407     AddExtensionString("GL_OES_packed_depth_stencil");
 408     feature_flags_.packed_depth24_stencil8 = true;
 409     if (enable_depth_texture) {
 410       texture_format_validators_[GL_DEPTH_STENCIL]
 411           .AddValue(GL_UNSIGNED_INT_24_8);
 412       validators_.texture_internal_format.AddValue(GL_DEPTH_STENCIL);
 413       validators_.texture_format.AddValue(GL_DEPTH_STENCIL);
 414       validators_.pixel_type.AddValue(GL_UNSIGNED_INT_24_8);
 415     }
 416     validators_.render_buffer_format.AddValue(GL_DEPTH24_STENCIL8);
 417   }
 418
 419   if (gl_version_info_->is_es3 ||
 420       extensions.Contains("GL_OES_vertex_array_object") ||
 421       extensions.Contains("GL_ARB_vertex_array_object") ||
 422       extensions.Contains("GL_APPLE_vertex_array_object")) {
 423     feature_flags_.native_vertex_array_object = true;
 424   }
 425
 426   // If we're using client_side_arrays we have to emulate
 427   // vertex array objects since vertex array objects do not work
 428   // with client side arrays.
 429   if (workarounds_.use_client_side_arrays_for_stream_buffers) {
 430     feature_flags_.native_vertex_array_object = false;
 431   }
 432
 433   if (gl_version_info_->is_es3 ||
 434       extensions.Contains("GL_OES_element_index_uint") ||
 435       gfx::HasDesktopGLFeatures()) {
 436     AddExtensionString("GL_OES_element_index_uint");
 437     validators_.index_type.AddValue(GL_UNSIGNED_INT);
 438   }
 439
 440   // With EXT_sRGB, unsized SRGB_EXT and SRGB_ALPHA_EXT are accepted by the
 441   // <format> and <internalformat> parameter of TexImage2D. GLES3 adds support
 442   // for SRGB Textures but the accepted internal formats for TexImage2D are only
 443   // sized formats GL_SRGB8 and GL_SRGB8_ALPHA8. Also, SRGB_EXT isn't a valid
 444   // <format> in this case. So, even with GLES3 explicitly check for
 445   // GL_EXT_sRGB.
 446   if (((gl_version_info_->is_es3 ||
 447         extensions.Contains("GL_OES_rgb8_rgba8")) &&
 448       extensions.Contains("GL_EXT_sRGB")) || gfx::HasDesktopGLFeatures()) {
 449     AddExtensionString("GL_EXT_sRGB");
 450     texture_format_validators_[GL_SRGB_EXT].AddValue(GL_UNSIGNED_BYTE);
 451     texture_format_validators_[GL_SRGB_ALPHA_EXT].AddValue(GL_UNSIGNED_BYTE);
 452     validators_.texture_internal_format.AddValue(GL_SRGB_EXT);
 453     validators_.texture_internal_format.AddValue(GL_SRGB_ALPHA_EXT);
 454     validators_.texture_format.AddValue(GL_SRGB_EXT);
 455     validators_.texture_format.AddValue(GL_SRGB_ALPHA_EXT);
 456     validators_.render_buffer_format.AddValue(GL_SRGB8_ALPHA8_EXT);
 457     validators_.frame_buffer_parameter.AddValue(
 458         GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT);
 459   }
 460
 461   bool enable_texture_format_bgra8888 = false;
 462   bool enable_read_format_bgra = false;
 463   bool enable_render_buffer_bgra = false;
 464   bool enable_immutable_texture_format_bgra_on_es3 =
 465       extensions.Contains("GL_APPLE_texture_format_BGRA8888");
 466
 467   // Check if we should allow GL_EXT_texture_format_BGRA8888
 468   if (extensions.Contains("GL_EXT_texture_format_BGRA8888") ||
 469       enable_immutable_texture_format_bgra_on_es3 ||
 470       extensions.Contains("GL_EXT_bgra")) {
 471     enable_texture_format_bgra8888 = true;
 472   }
 473
 474   // Only desktop GL extension GL_EXT_bgra or ANGLE guarantee that we can
 475   // allocate a renderbuffer with this format.
 476   if (extensions.Contains("GL_EXT_bgra") || gl_version_info_->is_angle) {
 477     enable_render_buffer_bgra = true;
 478   }
 479
 480   if (extensions.Contains("GL_EXT_read_format_bgra") ||
 481       extensions.Contains("GL_EXT_bgra")) {
 482     enable_read_format_bgra = true;
 483   }
 484
 485   if (enable_texture_format_bgra8888) {
 486     feature_flags_.ext_texture_format_bgra8888 = true;
 487     AddExtensionString("GL_EXT_texture_format_BGRA8888");
 488     texture_format_validators_[GL_BGRA_EXT].AddValue(GL_UNSIGNED_BYTE);
 489     validators_.texture_internal_format.AddValue(GL_BGRA_EXT);
 490     validators_.texture_format.AddValue(GL_BGRA_EXT);
 491   }
 492
 493   if (enable_read_format_bgra) {
 494     AddExtensionString("GL_EXT_read_format_bgra");
 495     validators_.read_pixel_format.AddValue(GL_BGRA_EXT);
 496   }
 497
 498   if (enable_render_buffer_bgra) {
 499     AddExtensionString("GL_CHROMIUM_renderbuffer_format_BGRA8888");
 500     validators_.render_buffer_format.AddValue(GL_BGRA8_EXT);
 501   }
 502
 503   if (extensions.Contains("GL_OES_rgb8_rgba8") || gfx::HasDesktopGLFeatures()) {
 504     AddExtensionString("GL_OES_rgb8_rgba8");
 505     validators_.render_buffer_format.AddValue(GL_RGB8_OES);
 506     validators_.render_buffer_format.AddValue(GL_RGBA8_OES);
 507   }
 508
 509   // Check if we should allow GL_OES_texture_npot
 510   if (gl_version_info_->is_es3 ||
 511       extensions.Contains("GL_ARB_texture_non_power_of_two") ||
 512       extensions.Contains("GL_OES_texture_npot")) {
 513     AddExtensionString("GL_OES_texture_npot");
 514     feature_flags_.npot_ok = true;
 515   }
 516
 517   // Check if we should allow GL_OES_texture_float, GL_OES_texture_half_float,
 518   // GL_OES_texture_float_linear, GL_OES_texture_half_float_linear
 519   bool enable_texture_float = false;
 520   bool enable_texture_float_linear = false;
 521   bool enable_texture_half_float = false;
 522   bool enable_texture_half_float_linear = false;
 523
 524   bool may_enable_chromium_color_buffer_float = false;
 525
 526   if (extensions.Contains("GL_ARB_texture_float")) {
 527     enable_texture_float = true;
 528     enable_texture_float_linear = true;
 529     enable_texture_half_float = true;
 530     enable_texture_half_float_linear = true;
 531     may_enable_chromium_color_buffer_float = true;
 532   } else {
 533     // GLES3 adds support for Float type by default but it doesn't support all
 534     // formats as GL_OES_texture_float(i.e.LUMINANCE_ALPHA,LUMINANCE and Alpha)
 535     if (extensions.Contains("GL_OES_texture_float")) {
 536       enable_texture_float = true;
 537       if (extensions.Contains("GL_OES_texture_float_linear")) {
 538         enable_texture_float_linear = true;
 539       }
 540       // This extension allows a variety of floating point formats to be
 541       // rendered to via framebuffer objects. Enable it's usage only if
 542       // support for Floating textures is enabled.
 543       if ((gl_version_info_->is_es3 &&
 544            extensions.Contains("GL_EXT_color_buffer_float")) ||
 545           gl_version_info_->is_angle) {
 546         may_enable_chromium_color_buffer_float = true;
 547       }
 548     }
 549
 550     // TODO(dshwang): GLES3 supports half float by default but GL_HALF_FLOAT_OES
 551     // isn't equal to GL_HALF_FLOAT.
 552     if (extensions.Contains("GL_OES_texture_half_float")) {
 553       enable_texture_half_float = true;
 554       if (extensions.Contains("GL_OES_texture_half_float_linear")) {
 555         enable_texture_half_float_linear = true;
 556       }
 557     }
 558   }
 559
 560   if (enable_texture_float) {
 561     texture_format_validators_[GL_ALPHA].AddValue(GL_FLOAT);
 562     texture_format_validators_[GL_RGB].AddValue(GL_FLOAT);
 563     texture_format_validators_[GL_RGBA].AddValue(GL_FLOAT);
 564     texture_format_validators_[GL_LUMINANCE].AddValue(GL_FLOAT);
 565     texture_format_validators_[GL_LUMINANCE_ALPHA].AddValue(GL_FLOAT);
 566     validators_.pixel_type.AddValue(GL_FLOAT);
 567     validators_.read_pixel_type.AddValue(GL_FLOAT);
 568     AddExtensionString("GL_OES_texture_float");
 569     if (enable_texture_float_linear) {
 570       AddExtensionString("GL_OES_texture_float_linear");
 571     }
 572   }
 573
 574   if (enable_texture_half_float) {
 575     texture_format_validators_[GL_ALPHA].AddValue(GL_HALF_FLOAT_OES);
 576     texture_format_validators_[GL_RGB].AddValue(GL_HALF_FLOAT_OES);
 577     texture_format_validators_[GL_RGBA].AddValue(GL_HALF_FLOAT_OES);
 578     texture_format_validators_[GL_LUMINANCE].AddValue(GL_HALF_FLOAT_OES);
 579     texture_format_validators_[GL_LUMINANCE_ALPHA].AddValue(GL_HALF_FLOAT_OES);
 580     validators_.pixel_type.AddValue(GL_HALF_FLOAT_OES);
 581     validators_.read_pixel_type.AddValue(GL_HALF_FLOAT_OES);
 582     AddExtensionString("GL_OES_texture_half_float");
 583     if (enable_texture_half_float_linear) {
 584       AddExtensionString("GL_OES_texture_half_float_linear");
 585     }
 586   }
 587
 588   if (may_enable_chromium_color_buffer_float) {
 589     static_assert(GL_RGBA32F_ARB == GL_RGBA32F &&
 590                   GL_RGBA32F_EXT == GL_RGBA32F &&
 591                   GL_RGB32F_ARB == GL_RGB32F &&
 592                   GL_RGB32F_EXT == GL_RGB32F,
 593                   "sized float internal format variations must match");
 594     // We don't check extension support beyond ARB_texture_float on desktop GL,
 595     // and format support varies between GL configurations. For example, spec
 596     // prior to OpenGL 3.0 mandates framebuffer support only for one
 597     // implementation-chosen format, and ES3.0 EXT_color_buffer_float does not
 598     // support rendering to RGB32F. Check for framebuffer completeness with
 599     // formats that the extensions expose, and only enable an extension when a
 600     // framebuffer created with its texture format is reported as complete.
 601     GLint fb_binding = 0;
 602     GLint tex_binding = 0;
 603     glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fb_binding);
 604     glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex_binding);
 605
 606     GLuint tex_id = 0;
 607     GLuint fb_id = 0;
 608     GLsizei width = 16;
 609
 610     glGenTextures(1, &tex_id);
 611     glGenFramebuffersEXT(1, &fb_id);
 612     glBindTexture(GL_TEXTURE_2D, tex_id);
 613     // Nearest filter needed for framebuffer completeness on some drivers.
 614     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 615     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, width, 0, GL_RGBA,
 616                  GL_FLOAT, NULL);
 617     glBindFramebufferEXT(GL_FRAMEBUFFER, fb_id);
 618     glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
 619                               GL_TEXTURE_2D, tex_id, 0);
 620     GLenum statusRGBA = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 621     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, width, width, 0, GL_RGB,
 622                  GL_FLOAT, NULL);
 623     GLenum statusRGB = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 624     glDeleteFramebuffersEXT(1, &fb_id);
 625     glDeleteTextures(1, &tex_id);
 626
 627     glBindFramebufferEXT(GL_FRAMEBUFFER, static_cast<GLuint>(fb_binding));
 628     glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(tex_binding));
 629
 630     DCHECK(glGetError() == GL_NO_ERROR);
 631
 632     if (statusRGBA == GL_FRAMEBUFFER_COMPLETE) {
 633       validators_.texture_internal_format.AddValue(GL_RGBA32F);
 634       feature_flags_.chromium_color_buffer_float_rgba = true;
 635       AddExtensionString("GL_CHROMIUM_color_buffer_float_rgba");
 636     }
 637     if (statusRGB == GL_FRAMEBUFFER_COMPLETE) {
 638       validators_.texture_internal_format.AddValue(GL_RGB32F);
 639       feature_flags_.chromium_color_buffer_float_rgb = true;
 640       AddExtensionString("GL_CHROMIUM_color_buffer_float_rgb");
 641     }
 642   }
 643
 644   // Check for multisample support
 645   if (!workarounds_.disable_multisampling) {
 646     bool ext_has_multisample =
 647         extensions.Contains("GL_EXT_framebuffer_multisample") ||
 648         gl_version_info_->is_es3;
 649     if (gl_version_info_->is_angle) {
 650       ext_has_multisample |=
 651           extensions.Contains("GL_ANGLE_framebuffer_multisample");
 652     }
 653     feature_flags_.use_core_framebuffer_multisample = gl_version_info_->is_es3;
 654     if (ext_has_multisample) {
 655       feature_flags_.chromium_framebuffer_multisample = true;
 656       validators_.frame_buffer_target.AddValue(GL_READ_FRAMEBUFFER_EXT);
 657       validators_.frame_buffer_target.AddValue(GL_DRAW_FRAMEBUFFER_EXT);
 658       validators_.g_l_state.AddValue(GL_READ_FRAMEBUFFER_BINDING_EXT);
 659       validators_.g_l_state.AddValue(GL_MAX_SAMPLES_EXT);
 660       validators_.render_buffer_parameter.AddValue(GL_RENDERBUFFER_SAMPLES_EXT);
 661       AddExtensionString("GL_CHROMIUM_framebuffer_multisample");
 662     }
 663     if (extensions.Contains("GL_EXT_multisampled_render_to_texture")) {
 664       feature_flags_.multisampled_render_to_texture = true;
 665     } else if (extensions.Contains("GL_IMG_multisampled_render_to_texture")) {
 666       feature_flags_.multisampled_render_to_texture = true;
 667       feature_flags_.use_img_for_multisampled_render_to_texture = true;
 668     }
 669     if (feature_flags_.multisampled_render_to_texture) {
 670       validators_.render_buffer_parameter.AddValue(
 671           GL_RENDERBUFFER_SAMPLES_EXT);
 672       validators_.g_l_state.AddValue(GL_MAX_SAMPLES_EXT);
 673       validators_.frame_buffer_parameter.AddValue(
 674           GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT);
 675       AddExtensionString("GL_EXT_multisampled_render_to_texture");
 676     }
 677   }
 678
 679   if (extensions.Contains("GL_OES_depth24") || gfx::HasDesktopGLFeatures() ||
 680       gl_version_info_->is_es3) {
 681     AddExtensionString("GL_OES_depth24");
 682     feature_flags_.oes_depth24 = true;
 683     validators_.render_buffer_format.AddValue(GL_DEPTH_COMPONENT24);
 684   }
 685
 686   if (!workarounds_.disable_oes_standard_derivatives &&
 687       (gl_version_info_->is_es3 ||
 688        extensions.Contains("GL_OES_standard_derivatives") ||
 689        gfx::HasDesktopGLFeatures())) {
 690     AddExtensionString("GL_OES_standard_derivatives");
 691     feature_flags_.oes_standard_derivatives = true;
 692     validators_.hint_target.AddValue(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES);
 693     validators_.g_l_state.AddValue(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES);
 694   }
 695
 696   if (extensions.Contains("GL_OES_EGL_image_external")) {
 697     AddExtensionString("GL_OES_EGL_image_external");
 698     feature_flags_.oes_egl_image_external = true;
 699     validators_.texture_bind_target.AddValue(GL_TEXTURE_EXTERNAL_OES);
 700     validators_.get_tex_param_target.AddValue(GL_TEXTURE_EXTERNAL_OES);
 701     validators_.texture_parameter.AddValue(GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES);
 702     validators_.g_l_state.AddValue(GL_TEXTURE_BINDING_EXTERNAL_OES);
 703   }
 704
 705   if (extensions.Contains("GL_OES_compressed_ETC1_RGB8_texture")) {
 706     AddExtensionString("GL_OES_compressed_ETC1_RGB8_texture");
 707     feature_flags_.oes_compressed_etc1_rgb8_texture = true;
 708     validators_.compressed_texture_format.AddValue(GL_ETC1_RGB8_OES);
 709   }
 710
 711   if (extensions.Contains("GL_AMD_compressed_ATC_texture")) {
 712     AddExtensionString("GL_AMD_compressed_ATC_texture");
 713     validators_.compressed_texture_format.AddValue(
 714         GL_ATC_RGB_AMD);
 715     validators_.compressed_texture_format.AddValue(
 716         GL_ATC_RGBA_EXPLICIT_ALPHA_AMD);
 717     validators_.compressed_texture_format.AddValue(
 718         GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD);
 719   }
 720
 721   if (extensions.Contains("GL_IMG_texture_compression_pvrtc")) {
 722     AddExtensionString("GL_IMG_texture_compression_pvrtc");
 723     validators_.compressed_texture_format.AddValue(
 724         GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG);
 725     validators_.compressed_texture_format.AddValue(
 726         GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG);
 727     validators_.compressed_texture_format.AddValue(
 728         GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG);
 729     validators_.compressed_texture_format.AddValue(
 730         GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG);
 731   }
 732
 733   // Ideally we would only expose this extension on Mac OS X, to
 734   // support GL_CHROMIUM_iosurface and the compositor. We don't want
 735   // applications to start using it; they should use ordinary non-
 736   // power-of-two textures. However, for unit testing purposes we
 737   // expose it on all supported platforms.
 738   if (extensions.Contains("GL_ARB_texture_rectangle")) {
 739     AddExtensionString("GL_ARB_texture_rectangle");
 740     feature_flags_.arb_texture_rectangle = true;
 741     validators_.texture_bind_target.AddValue(GL_TEXTURE_RECTANGLE_ARB);
 742     // For the moment we don't add this enum to the texture_target
 743     // validator. This implies that the only way to get image data into a
 744     // rectangular texture is via glTexImageIOSurface2DCHROMIUM, which is
 745     // just fine since again we don't want applications depending on this
 746     // extension.
 747     validators_.get_tex_param_target.AddValue(GL_TEXTURE_RECTANGLE_ARB);
 748     validators_.g_l_state.AddValue(GL_TEXTURE_BINDING_RECTANGLE_ARB);
 749   }
 750
 751 #if defined(OS_MACOSX)
 752   AddExtensionString("GL_CHROMIUM_iosurface");
 753 #endif
 754
 755   // TODO(gman): Add support for these extensions.
 756   //     GL_OES_depth32
 757
 758   feature_flags_.enable_texture_float_linear |= enable_texture_float_linear;
 759   feature_flags_.enable_texture_half_float_linear |=
 760       enable_texture_half_float_linear;
 761
 762   if (extensions.Contains("GL_ANGLE_pack_reverse_row_order")) {
 763     AddExtensionString("GL_ANGLE_pack_reverse_row_order");
 764     feature_flags_.angle_pack_reverse_row_order = true;
 765     validators_.pixel_store.AddValue(GL_PACK_REVERSE_ROW_ORDER_ANGLE);
 766     validators_.g_l_state.AddValue(GL_PACK_REVERSE_ROW_ORDER_ANGLE);
 767   }
 768
 769   if (extensions.Contains("GL_ANGLE_texture_usage")) {
 770     feature_flags_.angle_texture_usage = true;
 771     AddExtensionString("GL_ANGLE_texture_usage");
 772     validators_.texture_parameter.AddValue(GL_TEXTURE_USAGE_ANGLE);
 773   }
 774
 775   // Note: Only APPLE_texture_format_BGRA8888 extension allows BGRA8_EXT in
 776   // ES3's glTexStorage2D. We prefer support BGRA to texture storage.
 777   // So we don't expose GL_EXT_texture_storage when ES3 +
 778   // GL_EXT_texture_format_BGRA8888 because we fail the GL_BGRA8 requirement.
 779   // However we expose GL_EXT_texture_storage when just ES3 because we don't
 780   // claim to handle GL_BGRA8.
 781   bool support_texture_storage_on_es3 =
 782       (gl_version_info_->is_es3 &&
 783        enable_immutable_texture_format_bgra_on_es3) ||
 784       (gl_version_info_->is_es3 &&
 785        !enable_texture_format_bgra8888);
 786   if (extensions.Contains("GL_EXT_texture_storage") ||
 787       extensions.Contains("GL_ARB_texture_storage") ||
 788       support_texture_storage_on_es3) {
 789     feature_flags_.ext_texture_storage = true;
 790     AddExtensionString("GL_EXT_texture_storage");
 791     validators_.texture_parameter.AddValue(GL_TEXTURE_IMMUTABLE_FORMAT_EXT);
 792     if (enable_texture_format_bgra8888)
 793         validators_.texture_internal_format_storage.AddValue(GL_BGRA8_EXT);
 794     if (enable_texture_float) {
 795         validators_.texture_internal_format_storage.AddValue(GL_RGBA32F_EXT);
 796         validators_.texture_internal_format_storage.AddValue(GL_RGB32F_EXT);
 797         validators_.texture_internal_format_storage.AddValue(GL_ALPHA32F_EXT);
 798         validators_.texture_internal_format_storage.AddValue(
 799             GL_LUMINANCE32F_EXT);
 800         validators_.texture_internal_format_storage.AddValue(
 801             GL_LUMINANCE_ALPHA32F_EXT);
 802     }
 803     if (enable_texture_half_float) {
 804         validators_.texture_internal_format_storage.AddValue(GL_RGBA16F_EXT);
 805         validators_.texture_internal_format_storage.AddValue(GL_RGB16F_EXT);
 806         validators_.texture_internal_format_storage.AddValue(GL_ALPHA16F_EXT);
 807         validators_.texture_internal_format_storage.AddValue(
 808             GL_LUMINANCE16F_EXT);
 809         validators_.texture_internal_format_storage.AddValue(
 810             GL_LUMINANCE_ALPHA16F_EXT);
 811     }
 812   }
 813
 814   bool have_ext_occlusion_query_boolean =
 815       extensions.Contains("GL_EXT_occlusion_query_boolean");
 816   bool have_arb_occlusion_query2 =
 817       extensions.Contains("GL_ARB_occlusion_query2");
 818   bool have_arb_occlusion_query =
 819       extensions.Contains("GL_ARB_occlusion_query");
 820
 821   if (!workarounds_.disable_ext_occlusion_query &&
 822       (have_ext_occlusion_query_boolean ||
 823        have_arb_occlusion_query2 ||
 824        have_arb_occlusion_query)) {
 825     AddExtensionString("GL_EXT_occlusion_query_boolean");
 826     feature_flags_.occlusion_query_boolean = true;
 827     feature_flags_.use_arb_occlusion_query2_for_occlusion_query_boolean =
 828         !have_ext_occlusion_query_boolean && have_arb_occlusion_query2;
 829     feature_flags_.use_arb_occlusion_query_for_occlusion_query_boolean =
 830         !have_ext_occlusion_query_boolean && have_arb_occlusion_query &&
 831         !have_arb_occlusion_query2;
 832   }
 833
 834   if (!workarounds_.disable_angle_instanced_arrays &&
 835       (extensions.Contains("GL_ANGLE_instanced_arrays") ||
 836        (extensions.Contains("GL_ARB_instanced_arrays") &&
 837         extensions.Contains("GL_ARB_draw_instanced")) ||
 838        gl_version_info_->is_es3)) {
 839     AddExtensionString("GL_ANGLE_instanced_arrays");
 840     feature_flags_.angle_instanced_arrays = true;
 841     validators_.vertex_attribute.AddValue(GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
 842   }
 843
 844   bool vendor_agnostic_draw_buffers =
 845       extensions.Contains("GL_ARB_draw_buffers") ||
 846       extensions.Contains("GL_EXT_draw_buffers");
 847   if (!workarounds_.disable_ext_draw_buffers &&
 848       (vendor_agnostic_draw_buffers ||
 849        (extensions.Contains("GL_NV_draw_buffers") &&
 850         gl_version_info_->is_es3))) {
 851     AddExtensionString("GL_EXT_draw_buffers");
 852     feature_flags_.ext_draw_buffers = true;
 853
 854     // This flag is set to enable emulation of EXT_draw_buffers when we're
 855     // running on GLES 3.0+, NV_draw_buffers extension is supported and
 856     // glDrawBuffers from GLES 3.0 core has been bound. It toggles using the
 857     // NV_draw_buffers extension directive instead of EXT_draw_buffers extension
 858     // directive in ESSL 100 shaders translated by ANGLE, enabling them to write
 859     // into multiple gl_FragData values, which is not by default possible in
 860     // ESSL 100 with core GLES 3.0. For more information, see the
 861     // NV_draw_buffers specification.
 862     feature_flags_.nv_draw_buffers = !vendor_agnostic_draw_buffers;
 863
 864     GLint max_color_attachments = 0;
 865     glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &max_color_attachments);
 866     for (GLenum i = GL_COLOR_ATTACHMENT1_EXT;
 867          i < static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + max_color_attachments);
 868          ++i) {
 869       validators_.attachment.AddValue(i);
 870     }
 871     static_assert(GL_COLOR_ATTACHMENT0_EXT == GL_COLOR_ATTACHMENT0,
 872                   "GL_COLOR_ATTACHMENT0_EXT should equal GL_COLOR_ATTACHMENT0");
 873
 874     validators_.g_l_state.AddValue(GL_MAX_COLOR_ATTACHMENTS_EXT);
 875     validators_.g_l_state.AddValue(GL_MAX_DRAW_BUFFERS_ARB);
 876     GLint max_draw_buffers = 0;
 877     glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buffers);
 878     for (GLenum i = GL_DRAW_BUFFER0_ARB;
 879          i < static_cast<GLenum>(GL_DRAW_BUFFER0_ARB + max_draw_buffers);
 880          ++i) {
 881       validators_.g_l_state.AddValue(i);
 882     }
 883   }
 884
 885   if (gl_version_info_->is_es3 ||
 886       extensions.Contains("GL_EXT_blend_minmax") ||
 887       gfx::HasDesktopGLFeatures()) {
 888     AddExtensionString("GL_EXT_blend_minmax");
 889     validators_.equation.AddValue(GL_MIN_EXT);
 890     validators_.equation.AddValue(GL_MAX_EXT);
 891     static_assert(GL_MIN_EXT == GL_MIN && GL_MAX_EXT == GL_MAX,
 892                   "min & max variations must match");
 893   }
 894
 895   // TODO(dshwang): GLES3 supports gl_FragDepth, not gl_FragDepthEXT.
 896   if (extensions.Contains("GL_EXT_frag_depth") || gfx::HasDesktopGLFeatures()) {
 897     AddExtensionString("GL_EXT_frag_depth");
 898     feature_flags_.ext_frag_depth = true;
 899   }
 900
 901   if (extensions.Contains("GL_EXT_shader_texture_lod") ||
 902       gfx::HasDesktopGLFeatures()) {
 903     AddExtensionString("GL_EXT_shader_texture_lod");
 904     feature_flags_.ext_shader_texture_lod = true;
 905   }
 906
 907 #if !defined(OS_MACOSX)
 908   if (workarounds_.disable_egl_khr_fence_sync) {
 909     gfx::g_driver_egl.ext.b_EGL_KHR_fence_sync = false;
 910   }
 911   if (workarounds_.disable_egl_khr_wait_sync) {
 912     gfx::g_driver_egl.ext.b_EGL_KHR_wait_sync = false;
 913   }
 914 #endif
 915   if (workarounds_.disable_arb_sync)
 916     gfx::g_driver_gl.ext.b_GL_ARB_sync = false;
 917   bool ui_gl_fence_works = gfx::GLFence::IsSupported();
 918   UMA_HISTOGRAM_BOOLEAN("GPU.FenceSupport", ui_gl_fence_works);
 919
 920   feature_flags_.map_buffer_range =
 921       gl_version_info_->is_es3 ||
 922       extensions.Contains("GL_ARB_map_buffer_range") ||
 923       extensions.Contains("GL_EXT_map_buffer_range");
 924
 925   // Really it's part of core OpenGL 2.1 and up, but let's assume the
 926   // extension is still advertised.
 927   bool has_pixel_buffers =
 928       gl_version_info_->is_es3 ||
 929       extensions.Contains("GL_ARB_pixel_buffer_object") ||
 930       extensions.Contains("GL_NV_pixel_buffer_object");
 931
 932   // We will use either glMapBuffer() or glMapBufferRange() for async readbacks.
 933   if (has_pixel_buffers && ui_gl_fence_works &&
 934       !workarounds_.disable_async_readpixels) {
 935     feature_flags_.use_async_readpixels = true;
 936   }
 937
 938   if (gl_version_info_->is_es3 ||
 939       extensions.Contains("GL_ARB_sampler_objects")) {
 940     feature_flags_.enable_samplers = true;
 941     // TODO(dsinclair): Add AddExtensionString("GL_CHROMIUM_sampler_objects")
 942     // when available.
 943   }
 944
 945   if ((gl_version_info_->is_es3 ||
 946        extensions.Contains("GL_EXT_discard_framebuffer")) &&
 947       !workarounds_.disable_ext_discard_framebuffer) {
 948     // DiscardFramebufferEXT is automatically bound to InvalidateFramebuffer.
 949     AddExtensionString("GL_EXT_discard_framebuffer");
 950     feature_flags_.ext_discard_framebuffer = true;
 951   }
 952
 953   if (ui_gl_fence_works) {
 954     AddExtensionString("GL_CHROMIUM_sync_query");
 955     feature_flags_.chromium_sync_query = true;
 956   }
 957
 958   bool blend_equation_advanced_coherent =
 959     extensions.Contains("GL_NV_blend_equation_advanced_coherent") ||
 960     extensions.Contains("GL_KHR_blend_equation_advanced_coherent");
 961
 962   if (blend_equation_advanced_coherent ||
 963       extensions.Contains("GL_NV_blend_equation_advanced") ||
 964       extensions.Contains("GL_KHR_blend_equation_advanced")) {
 965     const GLenum equations[] = {GL_MULTIPLY_KHR,
 966                                 GL_SCREEN_KHR,
 967                                 GL_OVERLAY_KHR,
 968                                 GL_DARKEN_KHR,
 969                                 GL_LIGHTEN_KHR,
 970                                 GL_COLORDODGE_KHR,
 971                                 GL_COLORBURN_KHR,
 972                                 GL_HARDLIGHT_KHR,
 973                                 GL_SOFTLIGHT_KHR,
 974                                 GL_DIFFERENCE_KHR,
 975                                 GL_EXCLUSION_KHR,
 976                                 GL_HSL_HUE_KHR,
 977                                 GL_HSL_SATURATION_KHR,
 978                                 GL_HSL_COLOR_KHR,
 979                                 GL_HSL_LUMINOSITY_KHR};
 980
 981     for (GLenum equation : equations)
 982       validators_.equation.AddValue(equation);
 983     if (blend_equation_advanced_coherent)
 984       AddExtensionString("GL_KHR_blend_equation_advanced_coherent");
 985
 986     AddExtensionString("GL_KHR_blend_equation_advanced");
 987     feature_flags_.blend_equation_advanced = true;
 988     feature_flags_.blend_equation_advanced_coherent =
 989       blend_equation_advanced_coherent;
 990   }
 991
 992   if (extensions.Contains("GL_NV_path_rendering")) {
 993     if (extensions.Contains("GL_EXT_direct_state_access") ||
 994         gl_version_info_->is_es3) {
 995       AddExtensionString("GL_CHROMIUM_path_rendering");
 996       feature_flags_.chromium_path_rendering = true;
 997       validators_.g_l_state.AddValue(GL_PATH_MODELVIEW_MATRIX_CHROMIUM);
 998       validators_.g_l_state.AddValue(GL_PATH_PROJECTION_MATRIX_CHROMIUM);
 999     }
1000   }
1001
1002   if ((gl_version_info_->is_es3 || extensions.Contains("GL_EXT_texture_rg") ||
1003        extensions.Contains("GL_ARB_texture_rg")) &&
1004       IsGL_REDSupportedOnFBOs()) {
1005     feature_flags_.ext_texture_rg = true;
1006     AddExtensionString("GL_EXT_texture_rg");
1007
1008     validators_.texture_format.AddValue(GL_RED_EXT);
1009     validators_.texture_format.AddValue(GL_RG_EXT);
1010     validators_.texture_internal_format.AddValue(GL_RED_EXT);
1011     validators_.texture_internal_format.AddValue(GL_RG_EXT);
1012     validators_.read_pixel_format.AddValue(GL_RED_EXT);
1013     validators_.read_pixel_format.AddValue(GL_RG_EXT);
1014     validators_.render_buffer_format.AddValue(GL_R8_EXT);
1015     validators_.render_buffer_format.AddValue(GL_RG8_EXT);
1016
1017     texture_format_validators_[GL_RED_EXT].AddValue(GL_UNSIGNED_BYTE);
1018     texture_format_validators_[GL_RG_EXT].AddValue(GL_UNSIGNED_BYTE);
1019
1020     if (enable_texture_float) {
1021       texture_format_validators_[GL_RED_EXT].AddValue(GL_FLOAT);
1022       texture_format_validators_[GL_RG_EXT].AddValue(GL_FLOAT);
1023     }
1024     if (enable_texture_half_float) {
1025       texture_format_validators_[GL_RED_EXT].AddValue(GL_HALF_FLOAT_OES);
1026       texture_format_validators_[GL_RG_EXT].AddValue(GL_HALF_FLOAT_OES);
1027     }
1028   }
1029
1030 #if !defined(OS_MACOSX)
1031   if (workarounds_.ignore_egl_sync_failures) {
1032     gfx::GLFenceEGL::SetIgnoreFailures();
1033   }
1034 #endif
1035 }
1036
1037 void FeatureInfo::AddExtensionString(const char* s) {
1038   std::string str(s);
1039   size_t pos = extensions_.find(str);
1040   while (pos != std::string::npos &&
1041          pos + str.length() < extensions_.length() &&
1042          extensions_.substr(pos + str.length(), 1) != " ") {
1043     // This extension name is a substring of another.
1044     pos = extensions_.find(str, pos + str.length());
1045   }
1046   if (pos == std::string::npos) {
1047     extensions_ += (extensions_.empty() ? "" : " ") + str;
1048   }
1049 }
1050
1051 FeatureInfo::~FeatureInfo() {
1052 }
1053
1054 }  // namespace gles2
1055 }  // namespace gpu