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

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 213 matching lines @@
         {GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT},
         {GL_RGBA32I, GL_RGBA_INTEGER, GL_INT},
         {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT},
         {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT},
         {GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT},
         {GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT},
         {GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT},
         {GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8},
         {GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL,
          GL_FLOAT_32_UNSIGNED_INT_24_8_REV},
+        // Exposed by GL_APPLE_texture_format_BGRA8888
+        {GL_BGRA8_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
     };
 
     for (size_t ii = 0; ii < arraysize(kSupportedFormatTypes); ++ii) {
       supported_combinations_.insert(kSupportedFormatTypes[ii]);
     }
   }
 
   // This may be accessed from multiple threads.
   bool IsValid(GLenum internal_format, GLenum format, GLenum type) const {
     FormatType query = { internal_format, format, type };
@@ skipping 57 matching lines @@
     case GL_BLUE:
       return swizzle->blue;
     case GL_ALPHA:
       return swizzle->alpha;
     default:
       NOTREACHED();
       return GL_NONE;
   }
 }
 
+bool SizedFormatAvailable(const FeatureInfo* feature_info,
+                          bool immutable,
+                          GLenum internal_format) {
+  if (immutable)
+    return true;
+
+  // TODO(dshwang): check if it's possible to remove
+  // CHROMIUM_color_buffer_float_rgb. crbug.com/329605
+  if ((feature_info->feature_flags().chromium_color_buffer_float_rgb &&
+       internal_format == GL_RGB32F) ||
+      (feature_info->feature_flags().chromium_color_buffer_float_rgba &&
+       internal_format == GL_RGBA32F)) {
+    return true;
+  }

[dshwang, 2016/10/14 12:03:34]

following test failed.
https://www.khronos.org/registry/webgl/sdk/tests/conformance/extensions/oes-t...

It's because https://bugs.chromium.org/p/chromium/issues/detail?id=329605 added
CHROMIUM_color_buffer_float_rgb extensions;
https://cs.chromium.org/chromium/src/gpu/GLES2/extensions/CHROMIUM/CHROMIUM_c...
, which allows TexImage*(GL_RGB32F) in ES2 context.

I'm not fully understand why it's needed. kbr@, do you have some clue?

[Ken Russell (switch to Gerrit), 2016/10/20 04:59:40]

Sorry, I don't remember. The ultimate goal was to enable rendering to these
floating-point textures in WebGL 1.0 via an extension, but I don't remember the
reason for this direction.

+
+  return feature_info->IsES3Enabled();
+}
+
 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
 GLuint ToGLuint(const void* ptr) {
   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
 }
 
 base::LazyInstance<const FormatTypeValidator>::Leaky g_format_type_validator =
     LAZY_INSTANCE_INITIALIZER;
 
 class ScopedResetPixelUnpackBuffer{
  public:
@@ skipping 273 matching lines @@
         // In ES2 with OES_depth_texture, such limitation isn't specified.
         if (feature_info->IsES3Enabled()) {
           return false;
         }
       }
     } else if (feature_info->validators()->compressed_texture_format.IsValid(
         first_level.internal_format)) {
       // TODO(zmo): The assumption that compressed textures are all filterable
       // may not be true in the future.
     } else {
-      if (!Texture::TextureFilterable(feature_info,
-                                      first_level.internal_format,
-                                      first_level.type)) {
+      if (!Texture::TextureFilterable(feature_info, first_level.internal_format,
+                                      first_level.type, immutable_)) {
         return false;
       }
     }
   }
 
   if (!feature_info->IsES3Enabled()) {
     bool is_npot_compatible = !needs_mips &&
         sampler_state.wrap_s == GL_CLAMP_TO_EDGE &&
         sampler_state.wrap_t == GL_CLAMP_TO_EDGE;
 
@@ skipping 105 matching lines @@
     return false;
   }
 
   // Can't generate mips for depth or stencil textures.
   const Texture::LevelInfo& base = face_infos_[0].level_infos[base_level_];
   uint32_t channels = GLES2Util::GetChannelsForFormat(base.format);
   if (channels & (GLES2Util::kDepth | GLES2Util::kStencil)) {
     return false;
   }
 
-  if (!Texture::ColorRenderable(feature_info, base.internal_format) ||
-      !Texture::TextureFilterable(
-          feature_info, base.internal_format, base.type)) {
+  if (!Texture::ColorRenderable(feature_info, base.internal_format,
+                                immutable_) ||
+      !Texture::TextureFilterable(feature_info, base.internal_format, base.type,
+                                  immutable_)) {
     return false;
   }
 
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const LevelInfo& info = face_infos_[ii].level_infos[base_level_];
     if ((info.target == 0) ||
         feature_info->validators()->compressed_texture_format.IsValid(
             info.internal_format) ||
         info.image.get()) {
       return false;
@@ skipping 56 matching lines @@
                  depth == mip_depth &&
                  internal_format == base_level_face.internal_format &&
                  format == base_level_face.format &&
                  type == base_level_face.type);
   }
   return complete;
 }
 
 // static
 bool Texture::ColorRenderable(const FeatureInfo* feature_info,
-                              GLenum internal_format) {
+                              GLenum internal_format,
+                              bool immutable) {
   if (feature_info->validators()->texture_unsized_internal_format.IsValid(
       internal_format)) {
     return true;
   }
-  return feature_info->validators()->
-      texture_sized_color_renderable_internal_format.IsValid(internal_format);
+
+  return SizedFormatAvailable(feature_info, immutable, internal_format) &&
+         feature_info->validators()
+             ->texture_sized_color_renderable_internal_format.IsValid(
+                 internal_format);
 }
 
 // static
 bool Texture::TextureFilterable(const FeatureInfo* feature_info,
                                 GLenum internal_format,
-                                GLenum type) {
+                                GLenum type,
+                                bool immutable) {
   if (feature_info->validators()->texture_unsized_internal_format.IsValid(
       internal_format)) {
     switch (type) {
       case GL_FLOAT:
         return feature_info->feature_flags().enable_texture_float_linear;
       case GL_HALF_FLOAT_OES:
         return feature_info->feature_flags().enable_texture_half_float_linear;
       default:
         // GL_HALF_FLOAT is ES3 only and should only be used with sized formats.
         return true;
     }
   }
-  return feature_info->validators()->
-      texture_sized_texture_filterable_internal_format.IsValid(internal_format);
+  return SizedFormatAvailable(feature_info, immutable, internal_format) &&
+         feature_info->validators()
+             ->texture_sized_texture_filterable_internal_format.IsValid(
+                 internal_format);
 }
 
 void Texture::SetLevelClearedRect(GLenum target,
                                   GLint level,
                                   const gfx::Rect& cleared_rect) {
   DCHECK_GE(level, 0);
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
   DCHECK_LT(static_cast<size_t>(face_index),
             face_infos_.size());
   DCHECK_LT(static_cast<size_t>(level),
@@ skipping 856 matching lines @@
   // However, it is required if command buffer is implemented on top of
   // recent OpenGL core versions or OpenGL ES 3.0+. Therefore, for consistency,
   // it is better to deviate from ES2 spec and require cube completeness all
   // the time.
   if (face_infos_.size() == 6 && !cube_complete_)
     return false;
   DCHECK(level >= 0 &&
          level < static_cast<GLint>(face_infos_[0].level_infos.size()));
   GLenum internal_format = face_infos_[0].level_infos[level].internal_format;
   bool color_renderable =
-      ((feature_info->validators()->texture_unsized_internal_format.
-            IsValid(internal_format) &&
-        internal_format != GL_ALPHA &&
-        internal_format != GL_LUMINANCE &&
+      ((feature_info->validators()->texture_unsized_internal_format.IsValid(
+            internal_format) &&
+        internal_format != GL_ALPHA && internal_format != GL_LUMINANCE &&
         internal_format != GL_LUMINANCE_ALPHA &&
         internal_format != GL_SRGB_EXT) ||
-       feature_info->validators()->
-           texture_sized_color_renderable_internal_format.IsValid(
-               internal_format));
+       (SizedFormatAvailable(feature_info, immutable_, internal_format) &&
+        feature_info->validators()
+            ->texture_sized_color_renderable_internal_format.IsValid(
+                internal_format)));
   bool depth_renderable = feature_info->validators()->
       texture_depth_renderable_internal_format.IsValid(internal_format);
   bool stencil_renderable = feature_info->validators()->
       texture_stencil_renderable_internal_format.IsValid(internal_format);
   return (color_renderable || depth_renderable || stencil_renderable);
 }
 
 GLenum Texture::GetCompatibilitySwizzleForChannel(GLenum channel) {
   return GetSwizzleForChannel(channel, compatibility_swizzle_);
 }
@@ skipping 1747 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu