Allow rendering from non-stream GL_TEXTURE_EXTERNAL_OES

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/strings/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/error_state.h"
@@ skipping 180 matching lines @@
       estimated_size(rhs.estimated_size) {
 }
 
 Texture::LevelInfo::~LevelInfo() {
 }
 
 Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
   if (target_ == 0)
     return CAN_RENDER_ALWAYS;
 
-  if (target_ == GL_TEXTURE_EXTERNAL_OES) {
-    if (!IsStreamTexture()) {
-      return CAN_RENDER_NEVER;
-    }
-  } else {
+  if (target_ != GL_TEXTURE_EXTERNAL_OES) {
     if (level_infos_.empty()) {
       return CAN_RENDER_NEVER;
     }
 
     const Texture::LevelInfo& first_face = level_infos_[0][0];
     if (first_face.width == 0 ||
         first_face.height == 0 ||
         first_face.depth == 0) {
       return CAN_RENDER_NEVER;
     }
@@ skipping 71 matching lines @@
   if (!CanGenerateMipmaps(feature_info)) {
     return false;
   }
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     const Texture::LevelInfo& info1 = level_infos_[ii][0];
     GLsizei width = info1.width;
     GLsizei height = info1.height;
     GLsizei depth = info1.depth;
     GLenum target = target_ == GL_TEXTURE_2D ? GL_TEXTURE_2D :
                                FaceIndexToGLTarget(ii);
-    int num_mips = TextureManager::ComputeMipMapCount(width, height, depth);
+    int num_mips =
+        TextureManager::ComputeMipMapCount(target_, width, height, depth);
     for (int level = 1; 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,
                    info1.internal_format,
                    width,
                    height,
@@ skipping 75 matching lines @@
   UpdateCleared();
 }
 
 void Texture::UpdateCleared() {
   if (level_infos_.empty()) {
     return;
   }
 
   const Texture::LevelInfo& first_face = level_infos_[0][0];
   int levels_needed = TextureManager::ComputeMipMapCount(
-      first_face.width, first_face.height, first_face.depth);
+      target_, first_face.width, first_face.height, first_face.depth);
   bool cleared = true;
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     for (GLint jj = 0; jj < levels_needed; ++jj) {
       const Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.width > 0 && info.height > 0 && info.depth > 0 &&
           !info.cleared) {
         cleared = false;
         break;
       }
     }
@@ skipping 232 matching lines @@
         GLES2Util::IsNPOT(info.height) ||
         GLES2Util::IsNPOT(info.depth)) {
       npot_ = true;
       break;
     }
   }
 
   // Update texture_complete and cube_complete status.
   const Texture::LevelInfo& first_face = level_infos_[0][0];
   int levels_needed = TextureManager::ComputeMipMapCount(
-      first_face.width, first_face.height, first_face.depth);
+      target_, first_face.width, first_face.height, first_face.depth);
   texture_complete_ =
       max_level_set_ >= (levels_needed - 1) && max_level_set_ >= 0;
   cube_complete_ = (level_infos_.size() == 6) &&
                    (first_face.width == first_face.height);
 
   if (first_face.width == 0 || first_face.height == 0) {
     texture_complete_ = false;
   }
   if (first_face.type == GL_FLOAT &&
       !feature_info->feature_flags().enable_texture_float_linear &&
@@ skipping 44 matching lines @@
 }
 
 bool Texture::ClearRenderableLevels(GLES2Decoder* decoder) {
   DCHECK(decoder);
   if (cleared_) {
     return true;
   }
 
   const Texture::LevelInfo& first_face = level_infos_[0][0];
   int levels_needed = TextureManager::ComputeMipMapCount(
-      first_face.width, first_face.height, first_face.depth);
+      target_, first_face.width, first_face.height, first_face.depth);
 
   for (size_t ii = 0; ii < level_infos_.size(); ++ii) {
     for (GLint jj = 0; jj < levels_needed; ++jj) {
       Texture::LevelInfo& info = level_infos_[ii][jj];
       if (info.target != 0) {
         if (!ClearLevel(decoder, info.target, jj)) {
           return false;
         }
       }
     }
@@ skipping 95 matching lines @@
                                              GLuint service_id) {
   return new TextureRef(manager, client_id, new Texture(service_id));
 }
 
 TextureRef::~TextureRef() {
   manager_->StopTracking(this);
   texture_->RemoveTextureRef(this, manager_->have_context_);
   manager_ = NULL;
 }
 
-TextureManager::TextureManager(
-    MemoryTracker* memory_tracker,
-    FeatureInfo* feature_info,
-    GLint max_texture_size,
-    GLint max_cube_map_texture_size)
-    : memory_tracker_managed_(
-          new MemoryTypeTracker(memory_tracker, MemoryTracker::kManaged)),
+TextureManager::TextureManager(MemoryTracker* memory_tracker,
+                               FeatureInfo* feature_info,
+                               GLint max_texture_size,
+                               GLint max_cube_map_texture_size)
+    : memory_tracker_managed_(new MemoryTypeTracker(memory_tracker,
+                                                    MemoryTracker::kManaged)),
       memory_tracker_unmanaged_(
           new MemoryTypeTracker(memory_tracker, MemoryTracker::kUnmanaged)),
       feature_info_(feature_info),
       framebuffer_manager_(NULL),
       stream_texture_manager_(NULL),
       max_texture_size_(max_texture_size),
       max_cube_map_texture_size_(max_cube_map_texture_size),
-      max_levels_(ComputeMipMapCount(max_texture_size,
+      max_levels_(ComputeMipMapCount(GL_TEXTURE_2D,
+                                     max_texture_size,
                                      max_texture_size,
                                      max_texture_size)),
-      max_cube_map_levels_(ComputeMipMapCount(max_cube_map_texture_size,
+      max_cube_map_levels_(ComputeMipMapCount(GL_TEXTURE_CUBE_MAP,
+                                              max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
       num_uncleared_mips_(0),
       texture_count_(0),
       have_context_(true) {
   for (int ii = 0; ii < kNumDefaultTextures; ++ii) {
     black_texture_ids_[ii] = 0;
   }
@@ skipping 322 matching lines @@
   // This doesn't need to be fast. It's only used during slow queries.
   for (TextureMap::const_iterator it = textures_.begin();
        it != textures_.end(); ++it) {
     Texture* texture = it->second->texture();
     if (texture->service_id() == service_id)
       return texture;
   }
   return NULL;
 }
 
-GLsizei TextureManager::ComputeMipMapCount(
-    GLsizei width, GLsizei height, GLsizei depth) {
-  return 1 + base::bits::Log2Floor(std::max(std::max(width, height), depth));
+GLsizei TextureManager::ComputeMipMapCount(GLenum target,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth) {
+  switch (target) {
+    case GL_TEXTURE_EXTERNAL_OES:
+      return 1;
+    default:
+      return 1 +
+             base::bits::Log2Floor(std::max(std::max(width, height), depth));
+  }
 }
 
 void TextureManager::SetLevelImage(
     TextureRef* ref,
     GLenum target,
     GLint level,
     gfx::GLImage* image) {
   DCHECK(ref);
   ref->texture()->SetLevelImage(feature_info_.get(), target, level, image);
 }
@@ skipping 265 matching lines @@
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::HighResNow() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu