Remove StreamTextureManager

gpu/command_buffer/service/texture_manager.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_
 
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "gpu/command_buffer/service/async_pixel_transfer_delegate.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/gpu_export.h"
 #include "ui/gl/gl_image.h"
 
 namespace gpu {
 
-class StreamTextureManager;
-
 namespace gles2 {
 
 class GLES2Decoder;
 class Display;
 class ErrorState;
 class FeatureInfo;
 class FramebufferManager;
 class MailboxManager;
 class TextureManager;
 class TextureRef;
@@ skipping 31 matching lines @@
 
   int num_uncleared_mips() const {
     return num_uncleared_mips_;
   }
 
   uint32 estimated_size() const {
     return estimated_size_;
   }
 
   bool CanRenderTo() const {
-    return !stream_texture_ && target_ != GL_TEXTURE_EXTERNAL_OES;
+    return target_ != GL_TEXTURE_EXTERNAL_OES;
   }
 
   // The service side OpenGL id of the texture.
   GLuint service_id() const {
     return service_id_;
   }
 
   void SetServiceId(GLuint service_id) {
     DCHECK(service_id);
     service_id_ = service_id;
@@ skipping 45 matching lines @@
 
   void AttachToFramebuffer() {
     ++framebuffer_attachment_count_;
   }
 
   void DetachFromFramebuffer() {
     DCHECK_GT(framebuffer_attachment_count_, 0);
     --framebuffer_attachment_count_;
   }
 
-  bool IsStreamTexture() const {
-    return stream_texture_;
-  }
-
   void SetImmutable(bool immutable) {
     immutable_ = immutable;
   }
 
   bool IsImmutable() const {
     return immutable_;
   }
 
   // Whether a particular level/face is cleared.
   bool IsLevelCleared(GLenum target, GLint level) const;
@@ skipping 71 matching lines @@
   // same format, all the same dimensions and all width = height.
   bool cube_complete() const {
     return cube_complete_;
   }
 
   // Whether or not this texture is a non-power-of-two texture.
   bool npot() const {
     return npot_;
   }
 
-  void SetStreamTexture(bool stream_texture) {
-    stream_texture_ = stream_texture;
-    UpdateCanRenderCondition();
-  }
-
   // Marks a particular level as cleared or uncleared.
   void SetLevelCleared(GLenum target, GLint level, bool cleared);
 
   // Updates the cleared flag for this texture by inspecting all the mips.
   void UpdateCleared();
 
   // Clears any renderable uncleared levels.
   // Returns false if a GL error was generated.
   bool ClearRenderableLevels(GLES2Decoder* decoder);
 
@@ skipping 108 matching lines @@
 
   // Whether or not this texture is non-power-of-two
   bool npot_;
 
   // Whether this texture has ever been bound.
   bool has_been_bound_;
 
   // The number of framebuffers this texture is attached to.
   int framebuffer_attachment_count_;
 
-  // Whether this is a special streaming texture.
-  bool stream_texture_;
-
   // Whether the texture is immutable and no further changes to the format
   // or dimensions of the texture object can be made.
   bool immutable_;
 
   // Size in bytes this texture is assumed to take in memory.
   uint32 estimated_size_;
 
   // Cache of the computed CanRenderCondition flag.
   CanRenderCondition can_render_condition_;
 
   DISALLOW_COPY_AND_ASSIGN(Texture);
 };
 
 // This class represents a texture in a client context group. It's mostly 1:1
 // with a client id, though it can outlive the client id if it's still bound to
 // a FBO or another context when destroyed.
 // Multiple TextureRef can point to the same texture with cross-context sharing.
-//
-// Note: for stream textures, the TextureRef that created the stream texture is
-// set as the "owner" of the stream texture, i.e. it will call
-// DestroyStreamTexture on destruction. This is because the StreamTextureManager
-// isn't generally shared between ContextGroups, so ownership can't be at the
-// Texture level. We also can't have multiple StreamTexture on the same service
-// id, so there can be only one owner.
 class GPU_EXPORT TextureRef : public base::RefCounted<TextureRef> {
  public:
   TextureRef(TextureManager* manager, GLuint client_id, Texture* texture);
   static scoped_refptr<TextureRef> Create(TextureManager* manager,
                                           GLuint client_id,
                                           GLuint service_id);
   const Texture* texture() const { return texture_; }
   Texture* texture() { return texture_; }
   GLuint client_id() const { return client_id_; }
   GLuint service_id() const { return texture_->service_id(); }
 
  private:
   friend class base::RefCounted<TextureRef>;
   friend class Texture;
   friend class TextureManager;
 
   ~TextureRef();
   const TextureManager* manager() const { return manager_; }
   TextureManager* manager() { return manager_; }
   void reset_client_id() { client_id_ = 0; }
-  void set_is_stream_texture_owner(bool owner) {
-    is_stream_texture_owner_ = owner;
-  }
-  bool is_stream_texture_owner() const { return is_stream_texture_owner_; }
 
   TextureManager* manager_;
   Texture* texture_;
   GLuint client_id_;
-  bool is_stream_texture_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureRef);
 };
 
 // This class keeps track of the textures and their sizes so we can do NPOT and
 // texture complete checking.
 //
 // NOTE: To support shared resources an instance of this class will need to be
 // shared by multiple GLES2Decoders.
 class GPU_EXPORT TextureManager {
@@ skipping 24 matching lines @@
   TextureManager(MemoryTracker* memory_tracker,
                  FeatureInfo* feature_info,
                  GLsizei max_texture_size,
                  GLsizei max_cube_map_texture_size);
   ~TextureManager();
 
   void set_framebuffer_manager(FramebufferManager* manager) {
     framebuffer_manager_ = manager;
   }
 
-  void set_stream_texture_manager(StreamTextureManager* manager) {
-    stream_texture_manager_ = manager;
-  }
-
   // Init the texture manager.
   bool Initialize();
 
   // Must call before destruction.
   void Destroy(bool have_context);
 
   // Returns the maximum number of levels.
   GLint MaxLevelsForTarget(GLenum target) const {
     switch (target) {
       case GL_TEXTURE_2D:
@@ skipping 37 matching lines @@
   }
 
   // Sets the Texture's target
   // Parameters:
   //   target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP
   //   max_levels: The maximum levels this type of target can have.
   void SetTarget(
       TextureRef* ref,
       GLenum target);
 
-  // Marks a texture as a stream texture, and the ref as the stream texture
-  // owner.
-  void SetStreamTexture(TextureRef* ref, bool stream_texture);
-
-  // Whether the TextureRef is the stream texture owner.
-  bool IsStreamTextureOwner(TextureRef* ref);
-
   // Set the info for a particular level in a TexureInfo.
   void SetLevelInfo(
       TextureRef* ref,
       GLenum target,
       GLint level,
       GLenum internal_format,
       GLsizei width,
       GLsizei height,
       GLsizei depth,
       GLint border,
@@ skipping 139 matching lines @@
                                 Texture::CanRenderCondition new_condition);
   void IncFramebufferStateChangeCount();
 
   MemoryTypeTracker* GetMemTracker(GLenum texture_pool);
   scoped_ptr<MemoryTypeTracker> memory_tracker_managed_;
   scoped_ptr<MemoryTypeTracker> memory_tracker_unmanaged_;
 
   scoped_refptr<FeatureInfo> feature_info_;
 
   FramebufferManager* framebuffer_manager_;
-  StreamTextureManager* stream_texture_manager_;
 
   // Info for each texture in the system.
   typedef base::hash_map<GLuint, scoped_refptr<TextureRef> > TextureMap;
   TextureMap textures_;
 
   GLsizei max_texture_size_;
   GLsizei max_cube_map_texture_size_;
   GLint max_levels_;
   GLint max_cube_map_levels_;
 
@@ skipping 17 matching lines @@
 
   ObserverList<DestructionObserver> destruction_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_