Mark zero dimension textures as unrenderable

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 "base/bits.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
@@ skipping 145 matching lines @@
       estimated_size(rhs.estimated_size) {
 }
 
 Texture::LevelInfo::~LevelInfo() {
 }
 
 bool Texture::CanRender(const FeatureInfo* feature_info) const {
   if (target_ == 0) {
     return false;
   }
+
+  if (target_ == GL_TEXTURE_EXTERNAL_OES) {
+    if (!IsStreamTexture()) {
+      return false;
+    }
+  } else {
+    if (level_infos_.empty()) {
+      return false;
+    }
+
+    const Texture::LevelInfo& first_face = level_infos_[0][0];
+    if (target_ != GL_TEXTURE_EXTERNAL_OES &&

[no sievers, 2013/05/17 00:25:13]

nit: It can never be GL_TEXTURE_EXTERNAL_OES in the else-block here.

+        (first_face.width == 0 ||
+         first_face.height == 0 ||
+         first_face.depth == 0)) {
+      return false;
+    }
+  }
+
   bool needs_mips = NeedsMips();
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       (target_ == GL_TEXTURE_RECTANGLE_ARB)) {
     return !needs_mips &&
            wrap_s_ == GL_CLAMP_TO_EDGE &&
            wrap_t_ == GL_CLAMP_TO_EDGE;
   }
   if (needs_mips) {
     if (target_ == GL_TEXTURE_2D) {
       return texture_complete();
@@ skipping 60 matching lines @@
                    info1.border,
                    info1.format,
                    info1.type,
                    true);
     }
   }
 
   return true;
 }
 
-void Texture::SetTarget(GLenum target, GLint max_levels) {
+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;
   level_infos_.resize(num_faces);
   for (size_t ii = 0; ii < num_faces; ++ii) {
     level_infos_[ii].resize(max_levels);
   }
 
   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);
 }
 
 bool Texture::CanGenerateMipmaps(
     const FeatureInfo* feature_info) const {
   if ((npot() && !feature_info->feature_flags().npot_ok) ||
       level_infos_.empty() ||
       target_ == GL_TEXTURE_EXTERNAL_OES ||
       target_ == GL_TEXTURE_RECTANGLE_ARB) {
     return false;
   }
@@ skipping 237 matching lines @@
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
   Update(feature_info);
   UpdateCleared();
   return GL_NO_ERROR;
 }
 
 void Texture::Update(const FeatureInfo* feature_info) {
   // Update npot status.
-  npot_ = false;
+  // Assume GL_TEXTURE_EXTERNAL_OES textures are npot, all others
+  npot_ = target_ == GL_TEXTURE_EXTERNAL_OES;
 
   if (level_infos_.empty()) {
     texture_complete_ = false;
     cube_complete_ = false;
     return;
   }
 
   // checks that the first mip of any face is npot.
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const Texture::LevelInfo& info = level_infos_[ii][0];
@@ skipping 293 matching lines @@
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetTarget(Texture* texture, GLenum target) {
   DCHECK(texture);
   if (!texture->CanRender(feature_info_)) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
-  texture->SetTarget(target, MaxLevelsForTarget(target));
+  texture->SetTarget(feature_info_, target, MaxLevelsForTarget(target));
   if (!texture->CanRender(feature_info_)) {
     ++num_unrenderable_textures_;
   }
+}
+
+void TextureManager::SetStreamTexture(Texture* texture, bool stream_texture) {
+  DCHECK(texture);
+  if (!texture->CanRender(feature_info_)) {
+    DCHECK_NE(0, num_unrenderable_textures_);
+    --num_unrenderable_textures_;
+  }
+  texture->SetStreamTexture(stream_texture);
+  if (!texture->CanRender(feature_info_)) {
+    ++num_unrenderable_textures_;
+  }
 }
 
 void TextureManager::SetLevelCleared(Texture* texture,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
   DCHECK(texture);
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
@@ skipping 392 matching lines @@
 void TextureManager::AddToSignature(
     Texture* texture,
     GLenum target,
     GLint level,
     std::string* signature) const {
   texture->AddToSignature(feature_info_.get(), target, level, signature);
 }
 
 }  // namespace gles2
 }  // namespace gpu