Allow deleted resources to be used

gpu/command_buffer/service/texture_manager.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/texture_manager.h"
 #include "base/bits.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
@@ skipping 70 matching lines @@
       black_cube_texture_id_,
       default_texture_2d_->service_id(),
       default_texture_cube_map_->service_id(),
     };
     glDeleteTextures(arraysize(ids), ids);
   }
 }
 
 bool TextureManager::TextureInfo::CanRender(
     const FeatureInfo* feature_info) const {
-  if (target_ == 0 || IsDeleted()) {
+  if (target_ == 0) {
     return false;
   }
   bool needs_mips = NeedsMips();
   if (npot() && !feature_info->feature_flags().npot_ok) {
     return !needs_mips &&
            wrap_s_ == GL_CLAMP_TO_EDGE &&
            wrap_t_ == GL_CLAMP_TO_EDGE;
   }
   if (needs_mips) {
     if (target_ == GL_TEXTURE_2D) {
@@ skipping 51 matching lines @@
 
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 }
 
 bool TextureManager::TextureInfo::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
-      level_infos_.empty() || IsDeleted() ||
+      level_infos_.empty() ||
       target_ == GL_TEXTURE_EXTERNAL_OES) {
     return false;
   }
   const TextureInfo::LevelInfo& first = level_infos_[0][0];
   // TODO(gman): Check internal_format, format and type.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const LevelInfo& info = level_infos_[ii][0];
     if ((info.target == 0) ||
         (info.width != first.width) ||
         (info.height != first.height) ||
@@ skipping 91 matching lines @@
 bool TextureManager::TextureInfo::ValidForTexture(
     GLint face,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLenum type) const {
   size_t face_index = GLTargetToFaceIndex(face);
-  if (!IsDeleted() && level >= 0 && face_index < level_infos_.size() &&
+  if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(face)][level];
     GLint right;
     GLint top;
     return SafeAdd(xoffset, width, &right) &&
            SafeAdd(yoffset, height, &top) &&
            xoffset >= 0 &&
            yoffset >= 0 &&
            right <= info.width &&
            top <= info.height &&
            format == info.internal_format &&
            type == info.type;
   }
   return false;
 }
 
 bool TextureManager::TextureInfo::GetLevelSize(
     GLint face, GLint level, GLsizei* width, GLsizei* height) const {
   DCHECK(width);
   DCHECK(height);
   size_t face_index = GLTargetToFaceIndex(face);
-  if (!IsDeleted() && level >= 0 && face_index < level_infos_.size() &&
+  if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(face)][level];
     if (info.target != 0) {
       *width = info.width;
       *height = info.height;
       return true;
     }
   }
   return false;
 }
 
 bool TextureManager::TextureInfo::GetLevelType(
     GLint face, GLint level, GLenum* type, GLenum* internal_format) const {
   DCHECK(type);
   DCHECK(internal_format);
   size_t face_index = GLTargetToFaceIndex(face);
-  if (!IsDeleted() && level >= 0 && face_index < level_infos_.size() &&
+  if (level >= 0 && face_index < level_infos_.size() &&
       static_cast<size_t>(level) < level_infos_[face_index].size()) {
     const LevelInfo& info = level_infos_[GLTargetToFaceIndex(face)][level];
     if (info.target != 0) {
       *type = info.type;
       *internal_format = info.internal_format;
       return true;
     }
   }
   return false;
 }
@@ skipping 147 matching lines @@
         }
       }
     }
   }
   cleared_ = true;
   return true;
 }
 
 bool TextureManager::TextureInfo::IsLevelCleared(GLenum target, GLint level) {
   size_t face_index = GLTargetToFaceIndex(target);
-  if (IsDeleted() ||
-      face_index >= level_infos_.size() ||
+  if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
   TextureInfo::LevelInfo& info = level_infos_[face_index][level];
 
   return info.cleared;
 }
 
 bool TextureManager::TextureInfo::ClearLevel(
     GLES2Decoder* decoder, GLenum target, GLint level) {
   DCHECK(decoder);
   size_t face_index = GLTargetToFaceIndex(target);
-  if (IsDeleted() ||
-      face_index >= level_infos_.size() ||
+  if (face_index >= level_infos_.size() ||
       level >= static_cast<GLint>(level_infos_[face_index].size())) {
     return true;
   }
 
   TextureInfo::LevelInfo& info = level_infos_[face_index][level];
 
   DCHECK(target == info.target);
 
   if (info.target == 0 ||
       info.cleared ||
@@ skipping 134 matching lines @@
   }
   info->SetTarget(target, MaxLevelsForTarget(target));
   if (!info->CanRender(feature_info)) {
     ++num_unrenderable_textures_;
   }
 }
 
 void TextureManager::SetLevelCleared(
     TextureManager::TextureInfo* info, GLenum target, GLint level) {
   DCHECK(info);
-  DCHECK(!info->IsDeleted());
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   info->SetLevelCleared(target, level);
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 bool TextureManager::ClearRenderableLevels(
     GLES2Decoder* decoder,TextureManager::TextureInfo* info) {
   DCHECK(info);
-  DCHECK(!info->IsDeleted());
   if (info->SafeToRenderFrom()) {
     return true;
   }
   DCHECK_NE(0, num_unsafe_textures_);
   --num_unsafe_textures_;
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   bool result = info->ClearRenderableLevels(decoder);
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 bool TextureManager::ClearTextureLevel(
     GLES2Decoder* decoder,TextureManager::TextureInfo* info,
     GLenum target, GLint level) {
   DCHECK(info);
-  DCHECK(!info->IsDeleted());
   if (info->num_uncleared_mips() == 0) {
     return true;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   bool result = info->ClearLevel(decoder, target, level);
@@ skipping 12 matching lines @@
     GLint level,
     GLenum internal_format,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLenum format,
     GLenum type,
     bool cleared) {
   DCHECK(info);
-  DCHECK(!info->IsDeleted());
   if (!info->CanRender(feature_info)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
   info->SetLevelInfo(
       feature_info, target, level, internal_format, width, height, depth,
       border, format, type, cleared);
   num_uncleared_mips_ += info->num_uncleared_mips();
   if (!info->CanRender(feature_info)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
 }
 
 bool TextureManager::SetParameter(
     const FeatureInfo* feature_info,
     TextureManager::TextureInfo* info, GLenum pname, GLint param) {
   DCHECK(feature_info);
   DCHECK(info);
-  DCHECK(!info->IsDeleted());
   if (!info->CanRender(feature_info)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   bool result = info->SetParameter(feature_info, pname, param);
   if (!info->CanRender(feature_info)) {
     ++num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     ++num_unsafe_textures_;
   }
   return result;
 }
 
 bool TextureManager::MarkMipmapsGenerated(
     const FeatureInfo* feature_info,
     TextureManager::TextureInfo* info) {
   DCHECK(info);
-  DCHECK(!info->IsDeleted());
   if (!info->CanRender(feature_info)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!info->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= info->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
@@ skipping 60 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu