gpu: Enable relevant extentions on GLES3.

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/macros.h"
@@ skipping 210 matching lines @@
   disallowed_features_ = disallowed_features;
   InitializeFeatures();
   return true;
 }
 
 void FeatureInfo::InitializeFeatures() {
   // Figure out what extensions to turn on.
   StringSet extensions(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
 
-  bool npot_ok = false;
-
   const char* renderer_str =
       reinterpret_cast<const char*>(glGetString(GL_RENDERER));
   if (renderer_str) {
     feature_flags_.is_angle = StartsWithASCII(renderer_str, "ANGLE", true);
   }
 
   bool is_es3 = false;
   const char* version_str =
       reinterpret_cast<const char*>(glGetString(GL_VERSION));
   if (version_str) {
@@ skipping 124 matching lines @@
     if (enable_depth_texture) {
       texture_format_validators_[GL_DEPTH_STENCIL]
           .AddValue(GL_UNSIGNED_INT_24_8);
       validators_.texture_internal_format.AddValue(GL_DEPTH_STENCIL);
       validators_.texture_format.AddValue(GL_DEPTH_STENCIL);
       validators_.pixel_type.AddValue(GL_UNSIGNED_INT_24_8);
     }
     validators_.render_buffer_format.AddValue(GL_DEPTH24_STENCIL8);
   }
 
-  if (extensions.Contains("GL_OES_vertex_array_object") ||
+  if (is_es3 || 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 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") ||
+  if (is_es3 || extensions.Contains("GL_OES_element_index_uint") ||
       gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_OES_element_index_uint");
     validators_.index_type.AddValue(GL_UNSIGNED_INT);
   }
 
   bool enable_texture_format_bgra8888 = false;
   bool enable_read_format_bgra = false;
   bool enable_render_buffer_bgra = false;
   bool enable_immutable_texture_format_bgra_on_es3 =
       extensions.Contains("GL_APPLE_texture_format_BGRA8888");
@@ skipping 32 matching lines @@
     validators_.render_buffer_format.AddValue(GL_BGRA8_EXT);
   }
 
   if (extensions.Contains("GL_OES_rgb8_rgba8") || gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_OES_rgb8_rgba8");
     validators_.render_buffer_format.AddValue(GL_RGB8_OES);
     validators_.render_buffer_format.AddValue(GL_RGBA8_OES);
   }
 
   // Check if we should allow GL_OES_texture_npot
-  if (extensions.Contains("GL_ARB_texture_non_power_of_two") ||
+  if (is_es3 || extensions.Contains("GL_ARB_texture_non_power_of_two") ||
       extensions.Contains("GL_OES_texture_npot")) {
     AddExtensionString("GL_OES_texture_npot");
-    npot_ok = true;
+    feature_flags_.npot_ok = true;
   }
 
   // Check if we should allow GL_OES_texture_float, GL_OES_texture_half_float,
   // GL_OES_texture_float_linear, GL_OES_texture_half_float_linear
   bool enable_texture_float = false;
   bool enable_texture_float_linear = false;
   bool enable_texture_half_float = false;
   bool enable_texture_half_float_linear = false;
 
   bool may_enable_chromium_color_buffer_float = false;
 
   if (extensions.Contains("GL_ARB_texture_float")) {
     enable_texture_float = true;
     enable_texture_float_linear = true;
     enable_texture_half_float = true;
     enable_texture_half_float_linear = true;
     may_enable_chromium_color_buffer_float = true;
   } else {
-    if (extensions.Contains("GL_OES_texture_float")) {
+    if (is_es3 || extensions.Contains("GL_OES_texture_float")) {
       enable_texture_float = true;
       if (extensions.Contains("GL_OES_texture_float_linear")) {
         enable_texture_float_linear = true;
       }
       if ((is_es3 && extensions.Contains("GL_EXT_color_buffer_float")) ||
           feature_flags_.is_angle) {
         may_enable_chromium_color_buffer_float = true;
       }
     }
+    // TODO(dshwang): GLES3 supports half float by default but GL_HALF_FLOAT_OES
+    // isn't equal to GL_HALF_FLOAT.
     if (extensions.Contains("GL_OES_texture_half_float")) {
       enable_texture_half_float = true;
       if (extensions.Contains("GL_OES_texture_half_float_linear")) {
         enable_texture_half_float_linear = true;
       }
     }
   }
 
   if (enable_texture_float) {
     texture_format_validators_[GL_ALPHA].AddValue(GL_FLOAT);
@@ skipping 114 matching lines @@
   }
 
   if (extensions.Contains("GL_OES_depth24") || gfx::HasDesktopGLFeatures() ||
       is_es3) {
     AddExtensionString("GL_OES_depth24");
     feature_flags_.oes_depth24 = true;
     validators_.render_buffer_format.AddValue(GL_DEPTH_COMPONENT24);
   }
 
   if (!workarounds_.disable_oes_standard_derivatives &&
-      (extensions.Contains("GL_OES_standard_derivatives") ||
+      (is_es3 || extensions.Contains("GL_OES_standard_derivatives") ||
        gfx::HasDesktopGLFeatures())) {
     AddExtensionString("GL_OES_standard_derivatives");
     feature_flags_.oes_standard_derivatives = true;
     validators_.hint_target.AddValue(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES);
     validators_.g_l_state.AddValue(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES);
   }
 
   if (extensions.Contains("GL_OES_EGL_image_external")) {
     AddExtensionString("GL_OES_EGL_image_external");
     feature_flags_.oes_egl_image_external = true;
@@ skipping 52 matching lines @@
 #if defined(OS_MACOSX)
   AddExtensionString("GL_CHROMIUM_iosurface");
 #endif
 
   // TODO(gman): Add support for these extensions.
   //     GL_OES_depth32
 
   feature_flags_.enable_texture_float_linear |= enable_texture_float_linear;
   feature_flags_.enable_texture_half_float_linear |=
       enable_texture_half_float_linear;
-  feature_flags_.npot_ok |= npot_ok;
 
   if (extensions.Contains("GL_ANGLE_pack_reverse_row_order")) {
     AddExtensionString("GL_ANGLE_pack_reverse_row_order");
     feature_flags_.angle_pack_reverse_row_order = true;
     validators_.pixel_store.AddValue(GL_PACK_REVERSE_ROW_ORDER_ANGLE);
     validators_.g_l_state.AddValue(GL_PACK_REVERSE_ROW_ORDER_ANGLE);
   }
 
   if (extensions.Contains("GL_ANGLE_texture_usage")) {
     feature_flags_.angle_texture_usage = true;
@@ skipping 74 matching lines @@
     AddExtensionString("GL_EXT_draw_buffers");
     feature_flags_.ext_draw_buffers = true;
 
     GLint max_color_attachments = 0;
     glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS_EXT, &max_color_attachments);
     for (GLenum i = GL_COLOR_ATTACHMENT1_EXT;
          i < static_cast<GLenum>(GL_COLOR_ATTACHMENT0 + max_color_attachments);
          ++i) {
       validators_.attachment.AddValue(i);
     }
+    COMPILE_ASSERT(GL_COLOR_ATTACHMENT0_EXT == GL_COLOR_ATTACHMENT0,
+                   color_attachment0_variation_must_match);
 
     validators_.g_l_state.AddValue(GL_MAX_COLOR_ATTACHMENTS_EXT);
     validators_.g_l_state.AddValue(GL_MAX_DRAW_BUFFERS_ARB);
     GLint max_draw_buffers = 0;
     glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &max_draw_buffers);
     for (GLenum i = GL_DRAW_BUFFER0_ARB;
          i < static_cast<GLenum>(GL_DRAW_BUFFER0_ARB + max_draw_buffers);
          ++i) {
       validators_.g_l_state.AddValue(i);
     }
   }
 
-  if (extensions.Contains("GL_EXT_blend_minmax") ||
+  if (is_es3 || extensions.Contains("GL_EXT_blend_minmax") ||
       gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_EXT_blend_minmax");
     validators_.equation.AddValue(GL_MIN_EXT);
     validators_.equation.AddValue(GL_MAX_EXT);
+    COMPILE_ASSERT(GL_MIN_EXT == GL_MIN && GL_MAX_EXT == GL_MAX,
+                   min_max_variations_must_match);
   }
 
+  // TODO(dshwang): GLES3 supports gl_FragDepth, not gl_FragDepthEXT.
   if (extensions.Contains("GL_EXT_frag_depth") || gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_EXT_frag_depth");
     feature_flags_.ext_frag_depth = true;
   }
 
   if (extensions.Contains("GL_EXT_shader_texture_lod") ||
       gfx::HasDesktopGLFeatures()) {
     AddExtensionString("GL_EXT_shader_texture_lod");
     feature_flags_.ext_shader_texture_lod = true;
   }
@@ skipping 61 matching lines @@
   if (pos == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu