Revert of gpu: Clarify sized texture format is available only if ES3 context or immutable

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 <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 197 matching lines @@
   // 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;
 
+  chromium_color_buffer_float_rgba_available_ = false;
+  chromium_color_buffer_float_rgb_available_ = false;
   ext_color_buffer_float_available_ = false;
   oes_texture_float_linear_available_ = false;
   oes_texture_half_float_linear_available_ = false;
 }
 
 bool FeatureInfo::Initialize(ContextType context_type,
                              const DisallowedFeatures& disallowed_features) {
   disallowed_features_ = disallowed_features;
   context_type_ = context_type;
   InitializeFeatures();
@@ skipping 63 matching lines @@
       GL_RGBA16F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(GL_R32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(GL_RG32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_RGBA32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_R11F_G11F_B10F);
 }
 
 void FeatureInfo::EnableCHROMIUMColorBufferFloatRGBA() {
-  if (!feature_flags_.chromium_color_buffer_float_rgba)
+  if (!chromium_color_buffer_float_rgba_available_)
     return;
   validators_.texture_internal_format.AddValue(GL_RGBA32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_RGBA32F);
   AddExtensionString("GL_CHROMIUM_color_buffer_float_rgba");
 }
 
 void FeatureInfo::EnableCHROMIUMColorBufferFloatRGB() {
-  if (!feature_flags_.chromium_color_buffer_float_rgb)
+  if (!chromium_color_buffer_float_rgb_available_)
     return;
   validators_.texture_internal_format.AddValue(GL_RGB32F);
   validators_.texture_sized_color_renderable_internal_format.AddValue(
       GL_RGB32F);
   AddExtensionString("GL_CHROMIUM_color_buffer_float_rgb");
 }
 
 void FeatureInfo::EnableOESTextureFloatLinear() {
   if (!oes_texture_float_linear_available_)
     return;
@@ skipping 321 matching lines @@
   // that compatibility. So if EXT_texture_format_BGRA8888 (but not
   // APPLE_texture_format_BGRA8888) is present on an underlying ES3 context, we
   // have to choose which one of BGRA vs texture storage we expose.
   // When creating ES2 contexts, we prefer support BGRA to texture storage, so
   // we disable texture storage if only EXT_texture_format_BGRA8888 is present.
   // If neither is present, we expose texture storage.
   // When creating ES3 contexts, we do need to expose texture storage, so we
   // disable BGRA if we have to.
   bool has_apple_bgra = extensions.Contains("GL_APPLE_texture_format_BGRA8888");
   bool has_ext_bgra = extensions.Contains("GL_EXT_texture_format_BGRA8888");
-  bool enable_texture_format_bgra8888 =
-      has_ext_bgra || has_apple_bgra || !gl_version_info_->is_es;
+  bool has_bgra = has_ext_bgra || has_apple_bgra || !gl_version_info_->is_es;
 
   bool has_ext_texture_storage = extensions.Contains("GL_EXT_texture_storage");
   bool has_arb_texture_storage = extensions.Contains("GL_ARB_texture_storage");
   bool has_texture_storage =
       !workarounds_.disable_texture_storage &&
       (has_ext_texture_storage || has_arb_texture_storage ||
        gl_version_info_->is_es3 || gl_version_info_->IsAtLeastGL(4, 2));
 
+  bool enable_texture_format_bgra8888 = has_bgra;
   bool enable_texture_storage = has_texture_storage;
 
   bool texture_storage_incompatible_with_bgra =
       gl_version_info_->is_es3 && !has_ext_texture_storage && !has_apple_bgra;
   if (texture_storage_incompatible_with_bgra &&
       enable_texture_format_bgra8888 && enable_texture_storage) {
     switch (context_type_) {
       case CONTEXT_TYPE_OPENGLES2:
       case CONTEXT_TYPE_WEBGL1:
         enable_texture_storage = false;
@@ skipping 214 matching lines @@
 
     glDeleteFramebuffersEXT(1, &fb_id);
     glDeleteTextures(1, &tex_id);
 
     glBindFramebufferEXT(GL_FRAMEBUFFER, static_cast<GLuint>(fb_binding));
     glBindTexture(GL_TEXTURE_2D, static_cast<GLuint>(tex_binding));
 
     DCHECK(glGetError() == GL_NO_ERROR);
 
     if (status_rgba == GL_FRAMEBUFFER_COMPLETE) {
-      feature_flags_.chromium_color_buffer_float_rgba = true;
+      chromium_color_buffer_float_rgba_available_ = true;
       if (!disallowed_features_.chromium_color_buffer_float_rgba)
         EnableCHROMIUMColorBufferFloatRGBA();
     }
     if (status_rgb == GL_FRAMEBUFFER_COMPLETE) {
-      feature_flags_.chromium_color_buffer_float_rgb = true;
+      chromium_color_buffer_float_rgb_available_ = true;
       if (!disallowed_features_.chromium_color_buffer_float_rgb)
         EnableCHROMIUMColorBufferFloatRGB();
     }
   }
 
   // Enable the GL_EXT_color_buffer_float extension for WebGL 2.0
   if (enable_ext_color_buffer_float && IsES3Capable()) {
     ext_color_buffer_float_available_ = true;
     if (!disallowed_features_.ext_color_buffer_float)
       EnableEXTColorBufferFloat();
@@ skipping 183 matching lines @@
   if (extensions.Contains("GL_ANGLE_texture_usage")) {
     feature_flags_.angle_texture_usage = true;
     AddExtensionString("GL_ANGLE_texture_usage");
     validators_.texture_parameter.AddValue(GL_TEXTURE_USAGE_ANGLE);
   }
 
   if (enable_texture_storage) {
     feature_flags_.ext_texture_storage = true;
     AddExtensionString("GL_EXT_texture_storage");
     validators_.texture_parameter.AddValue(GL_TEXTURE_IMMUTABLE_FORMAT_EXT);
-    if (enable_texture_format_bgra8888) {
-      validators_.texture_internal_format_storage.AddValue(GL_BGRA8_EXT);
-      validators_.texture_sized_color_renderable_internal_format.AddValue(
-          GL_BGRA8_EXT);
-      validators_.texture_sized_texture_filterable_internal_format.AddValue(
-          GL_BGRA8_EXT);
-    }
+    if (enable_texture_format_bgra8888)
+        validators_.texture_internal_format_storage.AddValue(GL_BGRA8_EXT);
     if (enable_texture_float) {
         validators_.texture_internal_format_storage.AddValue(GL_RGBA32F_EXT);
         validators_.texture_internal_format_storage.AddValue(GL_RGB32F_EXT);
         validators_.texture_internal_format_storage.AddValue(GL_ALPHA32F_EXT);
         validators_.texture_internal_format_storage.AddValue(
             GL_LUMINANCE32F_EXT);
         validators_.texture_internal_format_storage.AddValue(
             GL_LUMINANCE_ALPHA32F_EXT);
     }
     if (enable_texture_half_float) {
@@ skipping 351 matching lines @@
     GL_DRAW_BUFFER13,
     GL_DRAW_BUFFER14,
     GL_DRAW_BUFFER15,
   };
   if (max_draw_buffers < kTotalDrawBufferEnums) {
     validators_.g_l_state.RemoveValues(
         kDrawBuffers + max_draw_buffers,
         kTotalDrawBufferEnums - max_draw_buffers);
   }
 
-  if (feature_flags_.ext_texture_format_bgra8888) {
-    validators_.texture_internal_format.AddValue(GL_BGRA8_EXT);
-    validators_.texture_sized_color_renderable_internal_format.AddValue(
-        GL_BGRA8_EXT);
-    validators_.texture_sized_texture_filterable_internal_format.AddValue(
-        GL_BGRA8_EXT);
-  }
-
   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:
@@ skipping 47 matching lines @@
   if (pos == std::string::npos) {
     extensions_ += (extensions_.empty() ? "" : " ") + str;
   }
 }
 
 FeatureInfo::~FeatureInfo() {
 }
 
 }  // namespace gles2
 }  // namespace gpu