Add GLStreamTextureImage

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/sampler_manager.h"
 #include "gpu/gpu_export.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_image.h"
 
+namespace gl {
+class GLStreamTextureImage;
+}
+
 namespace gpu {
 namespace gles2 {
 
 class GLES2Decoder;
 struct ContextState;
 struct DecoderFramebufferState;
 class Display;
 class ErrorState;
 class FeatureInfo;
 class FramebufferManager;
@@ skipping 123 matching lines @@
   // Get the type of a level. Returns false if level does not exist.
   bool GetLevelType(
       GLint target, GLint level, GLenum* type, GLenum* internal_format) const;
 
   // Set the image for a particular level.
   void SetLevelImage(GLenum target,
                      GLint level,
                      gl::GLImage* image,
                      ImageState state);
 
+  // Set the GLStreamTextureImage for a particular level.  This is identical
+  // to SetLevelImage, but it also permits GetLevelStreamTextureImage to return
+  // the image.
+  void SetLevelStreamTextureImage(GLenum target,
+                                  GLint level,
+                                  gl::GLStreamTextureImage* image,
+                                  ImageState state);
+
   // Get the image associated with a particular level. Returns NULL if level
   // does not exist.
   gl::GLImage* GetLevelImage(GLint target,
                              GLint level,
                              ImageState* state) const;
   gl::GLImage* GetLevelImage(GLint target, GLint level) const;
 
+  // Like GetLevelImage, but will return NULL if the image wasn't set via
+  // a call to SetLevelStreamTextureImage.
+  gl::GLStreamTextureImage* GetLevelStreamTextureImage(GLint target,
+                                                       GLint level) const;
+
   bool HasImages() const {
     return has_images_;
   }
 
   // Returns true of the given dimensions are inside the dimensions of the
   // level.
   bool ValidForTexture(
       GLint target,
       GLint level,
       GLint xoffset,
@@ skipping 82 matching lines @@
     GLenum target;
     GLint level;
     GLenum internal_format;
     GLsizei width;
     GLsizei height;
     GLsizei depth;
     GLint border;
     GLenum format;
     GLenum type;
     scoped_refptr<gl::GLImage> image;
+    scoped_refptr<gl::GLStreamTextureImage> stream_texture_image;
     ImageState image_state;
     uint32_t estimated_size;
     bool internal_workaround;
   };
 
   struct FaceInfo {
     FaceInfo();
     ~FaceInfo();
 
     // This is relative to base_level and max_level of a texture.
     GLsizei num_mip_levels;
     // This contains slots for all levels starting at 0.
     std::vector<LevelInfo> level_infos;
   };
 
+  // Helper for SetLevel*Image.  |stream_texture_image| may be null.
+  void SetLevelImageInternal(GLenum target,
+                             GLint level,
+                             gl::GLImage* image,
+                             gl::GLStreamTextureImage* stream_texture_image,
+                             ImageState state);
+
+  // Helper for GetLevel*Image.  Returns the LevelInfo for |target| and |level|
+  // if it's set, else NULL.
+  const LevelInfo* GetLevelInfo(GLint target, GLint level) const;
+
   // Set the info for a particular level.
   void SetLevelInfo(GLenum target,
                     GLint level,
                     GLenum internal_format,
                     GLsizei width,
                     GLsizei height,
                     GLsizei depth,
                     GLint border,
                     GLenum format,
                     GLenum type,
@@ skipping 540 matching lines @@
   size_t mem_represented() const {
     return memory_type_tracker_->GetMemRepresented();
   }
 
   void SetLevelImage(TextureRef* ref,
                      GLenum target,
                      GLint level,
                      gl::GLImage* image,
                      Texture::ImageState state);
 
+  void SetLevelStreamTextureImage(TextureRef* ref,
+                                  GLenum target,
+                                  GLint level,
+                                  gl::GLStreamTextureImage* image,
+                                  Texture::ImageState state);
+
   size_t GetSignatureSize() const;
 
   void AddToSignature(
       TextureRef* ref,
       GLenum target,
       GLint level,
       std::string* signature) const;
 
   void AddObserver(DestructionObserver* observer) {
     destruction_observers_.push_back(observer);
@@ skipping 199 matching lines @@
  private:
   DecoderTextureState* texture_state_;
   base::TimeTicks begin_time_;
   DISALLOW_COPY_AND_ASSIGN(ScopedTextureUploadTimer);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_