Correct reporting of compressed texture formats and shader binary formats

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2011 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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 759 matching lines @@
     TextureManager::TextureInfo::Ref bound_texture_2d;
 
     // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
     // glBindTexture
     TextureManager::TextureInfo::Ref bound_texture_cube_map;
   };
 
   // Initialize or re-initialize the shader translator.
   bool InitializeShaderTranslator();
 
+  void UpdateCapabilities();
+
   // Helpers for the glGen and glDelete functions.
   bool GenTexturesHelper(GLsizei n, const GLuint* client_ids);
   void DeleteTexturesHelper(GLsizei n, const GLuint* client_ids);
   bool GenBuffersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteBuffersHelper(GLsizei n, const GLuint* client_ids);
   bool GenFramebuffersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteFramebuffersHelper(GLsizei n, const GLuint* client_ids);
   bool GenRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
 
@@ skipping 1054 matching lines @@
                                    ContextGroup* group) {
   return new GLES2DecoderImpl(surface_manager, group);
 }
 
 GLES2DecoderImpl::GLES2DecoderImpl(SurfaceManager* surface_manager,
                                    ContextGroup* group)
     : GLES2Decoder(),
       surface_manager_(surface_manager),
       group_(ContextGroup::Ref(group ? group : new ContextGroup())),
       error_bits_(0),
-      util_(0),  // TODO(gman): Set to actual num compress texture formats.
       pack_alignment_(4),
       unpack_alignment_(4),
       attrib_0_buffer_id_(0),
       attrib_0_buffer_matches_value_(true),
       attrib_0_size_(0),
       fixed_attrib_buffer_id_(0),
       fixed_attrib_buffer_size_(0),
       active_texture_unit_(0),
       clear_red_(0),
       clear_green_(0),
@@ skipping 86 matching lines @@
                << "failed to initialize.";
     Destroy();
     return false;
   }
 
   CHECK_GL_ERROR();
   disallowed_extensions_ = disallowed_extensions;
 
   vertex_attrib_manager_.Initialize(group_->max_vertex_attribs());
 
+  util_.set_num_compressed_texture_formats(
+      validators_->compressed_texture_format.GetValues().size());
+
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
@@ skipping 167 matching lines @@
     glEnable(GL_POINT_SPRITE);
   }
 
   if (!InitializeShaderTranslator()) {
     return false;
   }
 
   return true;
 }
 
+void GLES2DecoderImpl::UpdateCapabilities() {
+  util_.set_num_compressed_texture_formats(
+      validators_->compressed_texture_format.GetValues().size());
+  util_.set_num_shader_binary_formats(
+      validators_->shader_binary_format.GetValues().size());
+}
+
 bool GLES2DecoderImpl::InitializeShaderTranslator() {
   // Re-check the state of use_shader_translator_ each time this is called.
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2 &&
       feature_info_->feature_flags().chromium_webglsl &&
       !use_shader_translator_) {
     use_shader_translator_ = true;
   }
   if (!use_shader_translator_) {
     return true;
   }
@@ skipping 1031 matching lines @@
       return true;
     case GL_STENCIL_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         glGetIntegerv(GL_STENCIL_BITS, &v);
         params[0] = BoundFramebufferHasStencilAttachment() ? v : 0;
       }
       return true;
     case GL_COMPRESSED_TEXTURE_FORMATS:
-      *num_written = 0;
-      // We don't support compressed textures.
+      *num_written = validators_->compressed_texture_format.GetValues().size();
+      if (params) {
+        for (GLint ii = 0; ii < *num_written; ++ii) {
+          params[ii] = validators_->compressed_texture_format.GetValues()[ii];
+        }
+      }
       return true;
     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
       *num_written = 1;
       if (params) {
-        *params = 0;  // We don't support compressed textures.
+        *params = validators_->compressed_texture_format.GetValues().size();
       }
       return true;
     case GL_NUM_SHADER_BINARY_FORMATS:
       *num_written = 1;
       if (params) {
-        *params = 0;  // We don't support binary shader formats.
+        *params = validators_->shader_binary_format.GetValues().size();
       }
       return true;
     case GL_SHADER_BINARY_FORMATS:
-      *num_written = 0;
-      return true;  // We don't support binary shader format.s
+      *num_written = validators_->shader_binary_format.GetValues().size();
+      if (params) {
+        for (GLint ii = 0; ii <  *num_written; ++ii) {
+          params[ii] = validators_->shader_binary_format.GetValues()[ii];
+        }
+      }
+      return true;
     case GL_SHADER_COMPILER:
       *num_written = 1;
       if (params) {
         *params = GL_TRUE;
       }
       return true;
     case GL_ARRAY_BUFFER_BINDING:
       *num_written = 1;
       if (params) {
         if (bound_array_buffer_) {
@@ skipping 3621 matching lines @@
 
   // If we just enabled a feature which affects the shader translator,
   // we may need to re-initialize it.
   if (std_derivatives_enabled !=
           feature_info_->feature_flags().oes_standard_derivatives ||
       webglsl_enabled !=
           feature_info_->feature_flags().chromium_webglsl) {
     InitializeShaderTranslator();
   }
 
+  UpdateCapabilities();
+
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetMultipleIntegervCHROMIUM(
     uint32 immediate_data_size, const gles2::GetMultipleIntegervCHROMIUM& c) {
   GLuint count = c.count;
   uint32 pnames_size;
   if (!SafeMultiplyUint32(count, sizeof(GLenum), &pnames_size)) {
     return error::kOutOfBounds;
   }
@@ skipping 67 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu