Fix unsized internalformat color-renderable detection

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 767 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,
-                                immutable_) ||
-      !Texture::TextureFilterable(feature_info, base.internal_format, base.type,
-                                  immutable_)) {
-    return false;
+  if (!feature_info->validators()->texture_unsized_internal_format.IsValid(
+      base.internal_format)) {
+    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 59 matching lines @@
   }
   return complete;
 }
 
 // static
 bool Texture::ColorRenderable(const FeatureInfo* feature_info,
                               GLenum internal_format,
                               bool immutable) {
   if (feature_info->validators()->texture_unsized_internal_format.IsValid(
       internal_format)) {
-    return true;
+    return internal_format == GL_RGBA || internal_format == GL_RGB ||

[Zhenyao Mo, 2016/11/14 19:49:44]

Actually let's stick to the != ALPHA != LUMINANCE code. Other extensions might
also have color-renderable unsized formats, say RED or RG.

[qiankun, 2016/11/18 03:20:38]

Done.

+           internal_format == GL_BGRA_EXT ||
+           internal_format == GL_SRGB_ALPHA_EXT;
   }
 
   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,
@@ skipping 882 matching lines @@
   // In GLES2, cube completeness is not required for framebuffer completeness.
   // 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 &&
-        internal_format != GL_LUMINANCE_ALPHA &&
-        internal_format != GL_SRGB_EXT) ||
-       (SizedFormatAvailable(feature_info, immutable_, internal_format) &&
-        feature_info->validators()
-            ->texture_sized_color_renderable_internal_format.IsValid(
-                internal_format)));
+  bool color_renderable = ColorRenderable(feature_info, internal_format,
+                                          immutable_);
   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 1853 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu