Remove StreamTextureManager

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/error_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
-#include "gpu/command_buffer/service/stream_texture_manager.h"
 
 namespace gpu {
 namespace gles2 {
 
 static size_t GLTargetToFaceIndex(GLenum target) {
   switch (target) {
     case GL_TEXTURE_2D:
     case GL_TEXTURE_EXTERNAL_OES:
     case GL_TEXTURE_RECTANGLE_ARB:
       return 0;
@@ skipping 82 matching lines @@
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
       max_level_set_(-1),
       texture_complete_(false),
       cube_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
-      stream_texture_(false),
       immutable_(false),
       estimated_size_(0),
       can_render_condition_(CAN_RENDER_ALWAYS) {
 }
 
 Texture::~Texture() {
   if (mailbox_manager_)
     mailbox_manager_->TextureDeleted(this);
 }
 
@@ skipping 62 matching lines @@
 }
 
 Texture::LevelInfo::~LevelInfo() {
 }
 
 Texture::CanRenderCondition Texture::GetCanRenderCondition() const {
   if (target_ == 0)
     return CAN_RENDER_ALWAYS;
 
   if (target_ == GL_TEXTURE_EXTERNAL_OES) {
-    if (!IsStreamTexture()) {
+    if (!GetLevelImage(target_, 0)) {
       return CAN_RENDER_NEVER;
     }
   } else {
     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 ||
@@ skipping 584 matching lines @@
   }
   return 0;
 }
 
 
 TextureRef::TextureRef(TextureManager* manager,
                        GLuint client_id,
                        Texture* texture)
     : manager_(manager),
       texture_(texture),
-      client_id_(client_id),
-      is_stream_texture_owner_(false) {
+      client_id_(client_id) {
   DCHECK(manager_);
   DCHECK(texture_);
   texture_->AddTextureRef(this);
   manager_->StartTracking(this);
 }
 
 scoped_refptr<TextureRef> TextureRef::Create(TextureManager* manager,
                                              GLuint client_id,
                                              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)),
       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_texture_size,
                                      max_texture_size)),
       max_cube_map_levels_(ComputeMipMapCount(max_cube_map_texture_size,
                                               max_cube_map_texture_size,
                                               max_cube_map_texture_size)),
       num_unrenderable_textures_(0),
       num_unsafe_textures_(0),
@@ skipping 125 matching lines @@
          (target != GL_TEXTURE_CUBE_MAP || (width == height && depth == 1)) &&
          (target != GL_TEXTURE_2D || (depth == 1));
 }
 
 void TextureManager::SetTarget(TextureRef* ref, GLenum target) {
   DCHECK(ref);
   ref->texture()
       ->SetTarget(feature_info_.get(), target, MaxLevelsForTarget(target));
 }
 
-void TextureManager::SetStreamTexture(TextureRef* ref, bool stream_texture) {
-  DCHECK(ref);
-  // Only the owner can mark as non-stream texture.
-  DCHECK_EQ(stream_texture, !ref->is_stream_texture_owner_);
-  ref->texture()->SetStreamTexture(stream_texture);
-  ref->set_is_stream_texture_owner(stream_texture);
-}
-
-bool TextureManager::IsStreamTextureOwner(TextureRef* ref) {
-  DCHECK(ref);
-  return ref->is_stream_texture_owner();
-}
-
 void TextureManager::SetLevelCleared(TextureRef* ref,
                                      GLenum target,
                                      GLint level,
                                      bool cleared) {
   DCHECK(ref);
   ref->texture()->SetLevelCleared(target, level, cleared);
 }
 
 bool TextureManager::ClearRenderableLevels(
     GLES2Decoder* decoder, TextureRef* ref) {
@@ skipping 126 matching lines @@
   if (!texture->CanRender(feature_info_.get()))
     ++num_unrenderable_textures_;
 }
 
 void TextureManager::StopTracking(TextureRef* ref) {
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnTextureRefDestroying(ref));
 
   Texture* texture = ref->texture();
-  if (ref->is_stream_texture_owner_ && stream_texture_manager_) {
-    DCHECK(texture->IsStreamTexture());
-    stream_texture_manager_->DestroyStreamTexture(texture->service_id());
-  }
 
   --texture_count_;
   if (!texture->CanRender(feature_info_.get())) {
     DCHECK_NE(0, num_unrenderable_textures_);
     --num_unrenderable_textures_;
   }
   if (!texture->SafeToRenderFrom()) {
     DCHECK_NE(0, num_unsafe_textures_);
     --num_unsafe_textures_;
   }
@@ skipping 75 matching lines @@
 }
 
 void TextureManager::IncFramebufferStateChangeCount() {
   if (framebuffer_manager_)
     framebuffer_manager_->IncFramebufferStateChangeCount();
 
 }
 
 }  // namespace gles2
 }  // namespace gpu