gpu: If not cube complete, the texture isn't renderable, no matter mipmap complete.

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 <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 36 matching lines @@
   GLsizei height_;
   GLsizei depth_;
   GLfloat max_lod_;
   GLfloat min_lod_;
   GLint base_level_;
   GLint border_;
   GLint max_level_;
   GLenum format_;
   GLenum type_;
   bool has_image_;
-  bool can_render_;
+  bool texture_complete_;
   bool can_render_to_;
   bool npot_;
 
   // Since we will be hashing this signature structure, the padding must be
   // zero initialized. Although the C++11 specifications specify that this is
   // true, we will use a constructor with a memset to further enforce it instead
   // of relying on compilers adhering to this deep dark corner specification.
   TextureSignature(GLenum target,
                    GLint level,
                    GLenum min_filter,
                    GLenum mag_filter,
                    GLenum wrap_r,
                    GLenum wrap_s,
                    GLenum wrap_t,
                    GLenum usage,
                    GLenum internal_format,
                    GLenum compare_func,
                    GLenum compare_mode,
                    GLsizei width,
                    GLsizei height,
                    GLsizei depth,
                    GLfloat max_lod,
                    GLfloat min_lod,
                    GLint base_level,
                    GLint border,
                    GLint max_level,
                    GLenum format,
                    GLenum type,
                    bool has_image,
-                   bool can_render,
+                   bool texture_complete,
                    bool can_render_to,
                    bool npot) {
     memset(this, 0, sizeof(TextureSignature));
     target_ = target;
     level_ = level;
     min_filter_ = min_filter;
     mag_filter_ = mag_filter;
     wrap_r_ = wrap_r;
     wrap_s_ = wrap_s;
     wrap_t_ = wrap_t;
     usage_ = usage;
     internal_format_ = internal_format;
     compare_func_ = compare_func;
     compare_mode_ = compare_mode;
     width_ = width;
     height_ = height;
     depth_ = depth;
     max_lod_ = max_lod;
     min_lod_ = min_lod;
     base_level_ = base_level;
     border_ = border;
     max_level_ = max_level;
     format_ = format;
     type_ = type;
     has_image_ = has_image;
-    can_render_ = can_render;
+    texture_complete_ = texture_complete;
     can_render_to_ = can_render_to;
     npot_ = npot;
   }
 };
 
 class FormatTypeValidator {
  public:
   FormatTypeValidator() {
     static const FormatType kSupportedFormatTypes[] = {
         // ES2.
@@ skipping 197 matching lines @@
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       compare_func_(GL_LEQUAL),
       compare_mode_(GL_NONE),
       max_lod_(1000.0f),
       min_lod_(-1000.0f),
       base_level_(0),
       max_level_(1000),
       max_level_set_(-1),
-      texture_complete_(false),
+      texture_2d_complete_(false),
       texture_mips_dirty_(false),
       texture_mips_complete_(false),
       cube_complete_(false),
       texture_level0_dirty_(false),
       texture_level0_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
       immutable_(false),
       has_images_(false),
       estimated_size_(0),
-      can_render_condition_(CAN_RENDER_ALWAYS),
-      texture_max_anisotropy_initialized_(false) {
-}
+      texture_completeness(TEXTURE_COMPLETE_ALWAYS),
+      texture_max_anisotropy_initialized_(false) {}
 
 Texture::~Texture() {
   if (mailbox_manager_)
     mailbox_manager_->TextureDeleted(this);
 }
 
 void Texture::AddTextureRef(TextureRef* ref) {
   DCHECK(refs_.find(ref) == refs_.end());
   refs_.insert(ref);
   if (!memory_tracking_ref_) {
@@ skipping 59 matching lines @@
 Texture::LevelInfo::~LevelInfo() {
 }
 
 Texture::FaceInfo::FaceInfo()
     : num_mip_levels(0) {
 }
 
 Texture::FaceInfo::~FaceInfo() {
 }
 
-Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
+Texture::TextureCompleteness Texture::GetTextureCompleteness() const {
   if (target_ == 0)
-    return CAN_RENDER_ALWAYS;
+    return TEXTURE_COMPLETE_ALWAYS;
 
   if (target_ != GL_TEXTURE_EXTERNAL_OES) {
     if (face_infos_.empty()) {
-      return CAN_RENDER_NEVER;
+      return TEXTURE_INCOMPLETE;
     }
 
     const Texture::LevelInfo& first_face = face_infos_[0].level_infos[0];
     if (first_face.width == 0 ||
         first_face.height == 0 ||
         first_face.depth == 0) {
-      return CAN_RENDER_NEVER;
+      return TEXTURE_INCOMPLETE;
     }
   }
 
   bool needs_mips = NeedsMips();
   if (needs_mips) {
-    if (!texture_complete())
-      return CAN_RENDER_NEVER;
+    if (!texture_2d_complete())
+      return TEXTURE_INCOMPLETE;
     if (target_ == GL_TEXTURE_CUBE_MAP && !cube_complete())
-      return CAN_RENDER_NEVER;
+      return TEXTURE_INCOMPLETE;
   }
 
   bool is_npot_compatible = !needs_mips &&
       wrap_s_ == GL_CLAMP_TO_EDGE &&
       wrap_t_ == GL_CLAMP_TO_EDGE;
 
   if (!is_npot_compatible) {
     if (target_ == GL_TEXTURE_RECTANGLE_ARB)
-      return CAN_RENDER_NEVER;
+      return TEXTURE_INCOMPLETE;
     else if (npot())
-      return CAN_RENDER_ONLY_IF_NPOT;
+      return TEXTURE_COMPLETE_ONLY_IF_NPOT;
   }
 
-  return CAN_RENDER_ALWAYS;
+  return TEXTURE_COMPLETE_ALWAYS;
 }
 
-bool Texture::CanRender(const FeatureInfo* feature_info) const {
-  switch (can_render_condition_) {
-    case CAN_RENDER_ALWAYS:
+bool Texture::IsTextureComplete(const FeatureInfo* feature_info) const {
+  switch (texture_completeness) {
+    case TEXTURE_COMPLETE_ALWAYS:
       return true;
-    case CAN_RENDER_NEVER:
+    case TEXTURE_INCOMPLETE:
       return false;
-    case CAN_RENDER_ONLY_IF_NPOT:
+    case TEXTURE_COMPLETE_ONLY_IF_NPOT:
       break;
   }
   return feature_info->feature_flags().npot_ok;
 }
 
 void Texture::AddToSignature(
     const FeatureInfo* feature_info,
     GLenum target,
     GLint level,
     std::string* signature) const {
   DCHECK(feature_info);
   DCHECK(signature);
   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),
             face_infos_[face_index].level_infos.size());
 
   const Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
 
-  TextureSignature signature_data(target,
-                                  level,
-                                  min_filter_,
-                                  mag_filter_,
-                                  wrap_r_,
-                                  wrap_s_,
-                                  wrap_t_,
-                                  usage_,
-                                  info.internal_format,
-                                  compare_func_,
-                                  compare_mode_,
-                                  info.width,
-                                  info.height,
-                                  info.depth,
-                                  max_lod_,
-                                  min_lod_,
-                                  base_level_,
-                                  info.border,
-                                  max_level_,
-                                  info.format,
-                                  info.type,
-                                  info.image.get() != NULL,
-                                  CanRender(feature_info),
-                                  CanRenderTo(),
-                                  npot_);
+  TextureSignature signature_data(
+      target, level, min_filter_, mag_filter_, wrap_r_, wrap_s_, wrap_t_,
+      usage_, info.internal_format, compare_func_, compare_mode_, info.width,
+      info.height, info.depth, max_lod_, min_lod_, base_level_, info.border,
+      max_level_, info.format, info.type, info.image.get() != NULL,
+      IsTextureComplete(feature_info), CanRenderTo(), npot_);
 
   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;
 }
@@ skipping 38 matching lines @@
 
   if (target == GL_TEXTURE_EXTERNAL_OES || target == GL_TEXTURE_RECTANGLE_ARB) {
     min_filter_ = GL_LINEAR;
     wrap_s_ = wrap_t_ = GL_CLAMP_TO_EDGE;
   }
 
   if (target == GL_TEXTURE_EXTERNAL_OES) {
     immutable_ = true;
   }
   Update(feature_info);
-  UpdateCanRenderCondition();
+  UpdateTextureCompleteness();
 }
 
 bool Texture::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       face_infos_.empty() ||
       target_ == GL_TEXTURE_EXTERNAL_OES ||
       target_ == GL_TEXTURE_RECTANGLE_ARB) {
     return false;
   }
@@ skipping 137 matching lines @@
   info->cleared_rect = cleared_rect;
   bool cleared = info->cleared_rect == gfx::Rect(info->width, info->height);
   if (cleared == was_cleared)
     return;
   int delta = cleared ? -1 : +1;
   num_uncleared_mips_ += delta;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
     (*it)->manager()->UpdateUnclearedMips(delta);
 }
 
-void Texture::UpdateCanRenderCondition() {
-  CanRenderCondition can_render_condition = GetCanRenderCondition();
-  if (can_render_condition_ == can_render_condition)
+void Texture::UpdateTextureCompleteness() {
+  TextureCompleteness new_texture_completeness = GetTextureCompleteness();
+  if (texture_completeness == new_texture_completeness)
     return;
   for (RefSet::iterator it = refs_.begin(); it != refs_.end(); ++it)
-    (*it)->manager()->UpdateCanRenderCondition(can_render_condition_,
-                                               can_render_condition);
-  can_render_condition_ = can_render_condition;
+    (*it)->manager()->UpdateTextureCompleteness(texture_completeness,
+                                                new_texture_completeness);
+  texture_completeness = new_texture_completeness;
 }
 
 void Texture::UpdateHasImages() {
   if (face_infos_.empty())
     return;
 
   bool has_images = false;
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     for (size_t jj = 0; jj < face_infos_[ii].level_infos.size(); ++jj) {
       const Texture::LevelInfo& info = face_infos_[ii].level_infos[jj];
@@ skipping 81 matching lines @@
   UpdateMipCleared(&info, width, height, cleared_rect);
 
   estimated_size_ -= info.estimated_size;
   GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type, 4, &info.estimated_size, NULL, NULL);
   estimated_size_ += info.estimated_size;
 
   max_level_set_ = std::max(max_level_set_, level);
   Update(feature_info);
   UpdateCleared();
-  UpdateCanRenderCondition();
+  UpdateTextureCompleteness();
   UpdateHasImages();
   if (IsAttachedToFramebuffer()) {
     // TODO(gman): If textures tracked which framebuffers they were attached to
     // we could just mark those framebuffers as not complete.
     IncAllFramebufferStateChangeCount();
   }
 }
 
 bool Texture::ValidForTexture(
     GLint target,
@@ skipping 156 matching lines @@
         return GL_INVALID_ENUM;
       }
       usage_ = param;
       break;
     default:
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
   Update(feature_info);
   UpdateCleared();
-  UpdateCanRenderCondition();
+  UpdateTextureCompleteness();
   return GL_NO_ERROR;
 }
 
 GLenum Texture::SetParameterf(
     const FeatureInfo* feature_info, GLenum pname, GLfloat param) {
   switch (pname) {
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_MAG_FILTER:
     case GL_TEXTURE_POOL_CHROMIUM:
     case GL_TEXTURE_WRAP_R:
@@ skipping 25 matching lines @@
   }
   return GL_NO_ERROR;
 }
 
 void Texture::Update(const FeatureInfo* feature_info) {
   // Update npot status.
   // Assume GL_TEXTURE_EXTERNAL_OES textures are npot, all others
   npot_ = (target_ == GL_TEXTURE_EXTERNAL_OES) || (num_npot_faces_ > 0);
 
   if (face_infos_.empty()) {
-    texture_complete_ = false;
+    texture_2d_complete_ = false;
     cube_complete_ = false;
     return;
   }
 
   // Update texture_complete and cube_complete status.
   const Texture::FaceInfo& first_face = face_infos_[0];
   const Texture::LevelInfo& first_level = first_face.level_infos[0];
   const GLsizei levels_needed = first_face.num_mip_levels;
 
-  texture_complete_ =
+  texture_2d_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (face_infos_.size() == 6) &&
                    (first_level.width == first_level.height);
 
   if (first_level.width == 0 || first_level.height == 0) {
-    texture_complete_ = false;
+    texture_2d_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;
+    texture_2d_complete_ = false;
   } else if (first_level.type == GL_HALF_FLOAT_OES &&
              !feature_info->feature_flags().enable_texture_half_float_linear &&
              (min_filter_ != GL_NEAREST_MIPMAP_NEAREST ||
               mag_filter_ != GL_NEAREST)) {
-    texture_complete_ = false;
+    texture_2d_complete_ = false;
   }
 
   if (cube_complete_ && texture_level0_dirty_) {
     texture_level0_complete_ = true;
     for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
       const Texture::LevelInfo& level0 = face_infos_[ii].level_infos[0];
       if (!TextureFaceComplete(first_level,
                                ii,
                                level0.target,
                                level0.internal_format,
                                level0.width,
                                level0.height,
                                level0.depth,
                                level0.format,
                                level0.type)) {
         texture_level0_complete_ = false;
         break;
       }
     }
     texture_level0_dirty_ = false;
   }
   cube_complete_ &= texture_level0_complete_;
 
-  if (texture_complete_ && texture_mips_dirty_) {
+  if (texture_2d_complete_ && texture_mips_dirty_) {
     texture_mips_complete_ = true;
     for (size_t ii = 0;
          ii < face_infos_.size() && texture_mips_complete_;
          ++ii) {
       const Texture::FaceInfo& face_info = face_infos_[ii];
       const Texture::LevelInfo& level0 = face_info.level_infos[0];
       for (GLsizei jj = 1; jj < levels_needed; ++jj) {
         const Texture::LevelInfo& level_info = face_infos_[ii].level_infos[jj];
         if (!TextureMipComplete(level0,
                                 level_info.target,
                                 jj,
                                 level_info.internal_format,
                                 level_info.width,
                                 level_info.height,
                                 level_info.depth,
                                 level_info.format,
                                 level_info.type)) {
           texture_mips_complete_ = false;
           break;
         }
       }
     }
     texture_mips_dirty_ = false;
   }
-  texture_complete_ &= texture_mips_complete_;
+  texture_2d_complete_ &= texture_mips_complete_;
 }
 
 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
   DCHECK(decoder);
   if (cleared_) {
     return true;
   }
 
   for (size_t ii = 0; ii < face_infos_.size(); ++ii) {
     const Texture::FaceInfo& face_info = face_infos_[ii];
@@ skipping 102 matching lines @@
   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),
             face_infos_[face_index].level_infos.size());
   Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
   DCHECK_EQ(info.target, target);
   DCHECK_EQ(info.level, level);
   info.image = image;
-  UpdateCanRenderCondition();
+  UpdateTextureCompleteness();
   UpdateHasImages();
 }
 
 gfx::GLImage* Texture::GetLevelImage(GLint target, GLint level) const {
   if (target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES &&
       target != GL_TEXTURE_RECTANGLE_ARB) {
     return NULL;
   }
 
   size_t face_index = GLES2Util::GLTargetToFaceIndex(target);
@@ skipping 351 matching lines @@
     textures_.erase(it);
   }
 }
 
 void TextureManager::StartTracking(TextureRef* ref) {
   Texture* texture = ref->texture();
   ++texture_count_;
   num_uncleared_mips_ += texture->num_uncleared_mips();
   if (!texture->SafeToRenderFrom())
     ++num_unsafe_textures_;
-  if (!texture->CanRender(feature_info_.get()))
+  if (!texture->IsTextureComplete(feature_info_.get()))
     ++num_unrenderable_textures_;
   if (texture->HasImages())
     ++num_images_;
 }
 
 void TextureManager::StopTracking(TextureRef* ref) {
   if (ref->num_observers()) {
     for (unsigned int i = 0; i < destruction_observers_.size(); i++) {
       destruction_observers_[i]->OnTextureRefDestroying(ref);
     }
     DCHECK_EQ(ref->num_observers(), 0);
   }
 
   Texture* texture = ref->texture();
 
   --texture_count_;
   if (texture->HasImages()) {
     DCHECK_NE(0, num_images_);
     --num_images_;
   }
-  if (!texture->CanRender(feature_info_.get())) {
+  if (!texture->IsTextureComplete(feature_info_.get())) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
   num_uncleared_mips_ -= texture->num_uncleared_mips();
   DCHECK_GE(num_uncleared_mips_, 0);
 }
@@ skipping 61 matching lines @@
 void TextureManager::UpdateSafeToRenderFrom(int delta) {
   num_unsafe_textures_ += delta;
   DCHECK_GE(num_unsafe_textures_, 0);
 }
 
 void TextureManager::UpdateUnclearedMips(int delta) {
   num_uncleared_mips_ += delta;
   DCHECK_GE(num_uncleared_mips_, 0);
 }
 
-void TextureManager::UpdateCanRenderCondition(
-    Texture::CanRenderCondition old_condition,
-    Texture::CanRenderCondition new_condition) {
-  if (old_condition == Texture::CAN_RENDER_NEVER ||
-      (old_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
+void TextureManager::UpdateTextureCompleteness(
+    Texture::TextureCompleteness old_completeness,
+    Texture::TextureCompleteness new_completeness) {
+  if (old_completeness == Texture::TEXTURE_INCOMPLETE ||
+      (old_completeness == Texture::TEXTURE_COMPLETE_ONLY_IF_NPOT &&
        !feature_info_->feature_flags().npot_ok)) {
     DCHECK_GT(num_unrenderable_textures_, 0);
     --num_unrenderable_textures_;
   }
-  if (new_condition == Texture::CAN_RENDER_NEVER ||
-      (new_condition == Texture::CAN_RENDER_ONLY_IF_NPOT &&
+  if (new_completeness == Texture::TEXTURE_INCOMPLETE ||
+      (new_completeness == Texture::TEXTURE_COMPLETE_ONLY_IF_NPOT &&
        !feature_info_->feature_flags().npot_ok))
     ++num_unrenderable_textures_;
 }
 
 void TextureManager::UpdateNumImages(int delta) {
   num_images_ += delta;
   DCHECK_GE(num_images_, 0);
 }
 
 void TextureManager::IncFramebufferStateChangeCount() {
@@ skipping 339 matching lines @@
   // The link to the memory tracking |client_id| is given a higher importance
   // than other refs.
   if (ref == ref->texture()->memory_tracking_ref_)
     importance = 2;
 
   pmd->AddOwnershipEdge(client_guid, service_guid, importance);
 }
 
 }  // namespace gles2
 }  // namespace gpu