Check if internal_format is valid for GenerateMipmap().

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 511 matching lines @@
   signature->append(TextureTag, sizeof(TextureTag));
   signature->append(reinterpret_cast<const char*>(&signature_data),
                     sizeof(signature_data));
 }
 
 void Texture::SetMailboxManager(MailboxManager* mailbox_manager) {
   DCHECK(!mailbox_manager_ || mailbox_manager_ == mailbox_manager);
   mailbox_manager_ = mailbox_manager;
 }
 
-bool Texture::MarkMipmapsGenerated(
+void Texture::MarkMipmapsGenerated(
     const FeatureInfo* feature_info) {
-  if (!CanGenerateMipmaps(feature_info)) {
-    return false;
-  }
+  DCHECK(CanGenerateMipmaps(feature_info));
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const Texture::FaceInfo& face_info = face_infos_[ii];
     const Texture::LevelInfo& level0_info = face_info.level_infos[base_level_];
     GLsizei width = level0_info.width;
     GLsizei height = level0_info.height;
     GLsizei depth = level0_info.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
                                GLES2Util::IndexToGLFaceTarget(ii);
 
     const GLsizei num_mips = face_info.num_mip_levels;
     for (GLsizei level = base_level_ + 1;
          level < base_level_ + num_mips; ++level) {
       width = std::max(1, width >> 1);
       height = std::max(1, height >> 1);
       depth = std::max(1, depth >> 1);
       SetLevelInfo(feature_info, target, level, level0_info.internal_format,
                    width, height, depth, level0_info.border, level0_info.format,
                    level0_info.type, gfx::Rect(width, height));
     }
   }
-
-  return true;
 }
 
 void Texture::SetTarget(
     const FeatureInfo* feature_info, GLenum target, GLint max_levels) {
   DCHECK_EQ(0u, target_);  // you can only set this once.
   target_ = target;
   size_t num_faces = (target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
   face_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     face_infos_[ii].level_infos.resize(max_levels);
@@ skipping 24 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;
   }
 
-  // TODO(gman): Check internal_format, format and type.
+  bool valid_internal_format = false;
+  if (feature_info->validators()->texture_unsized_internal_format.IsValid(
+      base.internal_format)) {
+    valid_internal_format = true;
+  } else if (feature_info->validators()->
+      texture_sized_color_renderable_internal_format.IsValid(
+          base.internal_format) && feature_info->validators()->
+      texture_sized_texture_filterable_internal_format.IsValid(
+          base.internal_format)) {
+    valid_internal_format = true;
+  }
+  if (!valid_internal_format) {
+    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) || (info.width != base.width) ||
-        (info.height != base.height) || (info.depth != base.depth) ||
-        (info.format != base.format) ||
-        (info.internal_format != base.internal_format) ||
-        (info.type != base.type) ||
+    if ((info.target == 0) ||
         feature_info->validators()->compressed_texture_format.IsValid(
             info.internal_format) ||
         info.image.get()) {
       return false;
     }
   }
+  if (face_infos_.size() == 6 && !cube_complete_) {
+    return false;
+  }
   return true;
 }
 
 bool Texture::TextureIsNPOT(GLsizei width,
                             GLsizei height,
                             GLsizei depth) {
   return (GLES2Util::IsNPOT(width) ||
           GLES2Util::IsNPOT(height) ||
           GLES2Util::IsNPOT(depth));
 }
@@ skipping 478 matching lines @@
   }
 
   // Update texture_complete and cube_complete status.
   const Texture::FaceInfo& first_face = face_infos_[0];
   const Texture::LevelInfo& first_level = first_face.level_infos[base_level_];
   const GLsizei levels_needed = first_face.num_mip_levels;
 
   texture_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (face_infos_.size() == 6) &&
-                   (first_level.width == first_level.height);
+                   (first_level.width == first_level.height) &&
+                   (first_level.width > 0);
 
   if (first_level.width == 0 || first_level.height == 0) {
     texture_complete_ = false;
   } else if (first_level.type == GL_FLOAT &&
       !feature_info->feature_flags().enable_texture_float_linear &&
       (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
        mag_filter_ != GL_NEAREST)) {
     texture_complete_ = false;
   } else if (first_level.type == GL_HALF_FLOAT_OES &&
              !feature_info->feature_flags().enable_texture_half_float_linear &&
@@ skipping 562 matching lines @@
           error_state, function_name, pname, "pname");
     } else {
       ERRORSTATE_SET_GL_ERROR_INVALID_PARAMF(
           error_state, result, function_name, pname, param);
     }
   } else {
     glTexParameterf(texture->target(), pname, param);
   }
 }
 
-bool TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
+void TextureManager::MarkMipmapsGenerated(TextureRef* ref) {
   DCHECK(ref);
   Texture* texture = ref->texture();
   texture->GetMemTracker()->TrackMemFree(texture->estimated_size());
-  bool result = texture->MarkMipmapsGenerated(feature_info_.get());
+  texture->MarkMipmapsGenerated(feature_info_.get());
   texture->GetMemTracker()->TrackMemAlloc(texture->estimated_size());
-  return result;
 }
 
 TextureRef* TextureManager::CreateTexture(
     GLuint client_id, GLuint service_id) {
   DCHECK_NE(0u, service_id);
   scoped_refptr<TextureRef> ref(TextureRef::Create(
       this, client_id, service_id));
   std::pair<TextureMap::iterator, bool> result =
       textures_.insert(std::make_pair(client_id, ref));
   DCHECK(result.second);
@@ skipping 948 matching lines @@
 uint32_t TextureManager::GetServiceIdGeneration() const {
   return current_service_id_generation_;
 }
 
 void TextureManager::IncrementServiceIdGeneration() {
   current_service_id_generation_++;
 }
 
 }  // namespace gles2
 }  // namespace gpu