StreamTextureImages can now override a Texture's service id

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>
 
@@ skipping 135 matching lines @@
     return service_id_;
   }
 
   void SetServiceId(GLuint service_id) {
     DCHECK(service_id);
     DCHECK_EQ(owned_service_id_, service_id_);
     service_id_ = service_id;
     owned_service_id_ = service_id;
   }
 
-  // Causes us to report |service_id| as our service id, but does not delete
-  // it when we are destroyed.  Will rebind any OES_EXTERNAL texture units to
-  // our new service id in all contexts.  If |service_id| is zero, then we
-  // revert to our original service id.
-  void SetUnownedServiceId(GLuint service_id);
-
   // Returns the target this texure was first bound to or 0 if it has not
   // been bound. Once a texture is bound to a specific target it can never be
   // bound to a different target.
   GLenum target() const {
     return target_;
   }
 
   bool SafeToRenderFrom() const {
     return cleared_;
   }
 
   // Get the width/height/depth for a particular level. Returns false if level
   // does not exist.
   // |depth| is optional and can be nullptr.
   bool GetLevelSize(
       GLint target, GLint level,
       GLsizei* width, GLsizei* height, GLsizei* depth) const;
 
   // 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.
+  // Set the image for a particular level. If a GLStreamTextureImage was
+  // previously set with SetLevelStreamTextureImage(), this will reset
+  // |service_id_| back to |owned_service_id_|, removing the service id override
+  // set by the GLStreamTextureImage.
   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.
+  // Set the GLStreamTextureImage for a particular level.  This is like
+  // SetLevelImage, but it also makes it optional to override |service_id_| with
+  // a texture bound to the stream texture, and permits
+  // GetLevelStreamTextureImage to return the image. See
+  // SetStreamTextureServiceId() for the details of how |service_id| is used.
   void SetLevelStreamTextureImage(GLenum target,
                                   GLint level,
                                   GLStreamTextureImage* image,
-                                  ImageState state);
+                                  ImageState state,
+                                  GLuint service_id);
+
+  // Set the ImageState for the image bound to the given level.
+  void SetLevelImageState(GLenum target, GLint level, 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.
@@ skipping 128 matching lines @@
     std::vector<LevelInfo> level_infos;
   };
 
   // Helper for SetLevel*Image.  |stream_texture_image| may be null.
   void SetLevelImageInternal(GLenum target,
                              GLint level,
                              gl::GLImage* image,
                              GLStreamTextureImage* stream_texture_image,
                              ImageState state);
 
-  // Helper for GetLevel*Image.  Returns the LevelInfo for |target| and |level|
-  // if it's set, else NULL.
+  // 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,
                     const gfx::Rect& cleared_rect);
 
+  // Causes us to report |service_id| as our service id, but does not delete
+  // it when we are destroyed.  Will rebind any OES_EXTERNAL texture units to
+  // our new service id in all contexts.  If |service_id| is zero, then we
+  // revert to |owned_service_id_|.
+  void SetStreamTextureServiceId(GLuint service_id);
+
   void MarkLevelAsInternalWorkaround(GLenum target, GLint level);
 
   // In GLES2 "texture complete" means it has all required mips for filtering
   // down to a 1x1 pixel texture, they are in the correct order, they are all
   // the same format.
   bool texture_complete() const {
     return texture_complete_;
   }
 
   // In GLES2 "cube complete" means all 6 faces level 0 are defined, all the
@@ skipping 134 matching lines @@
 
   void UpdateBaseLevel(GLint base_level);
   void UpdateMaxLevel(GLint max_level);
   void UpdateNumMipLevels();
 
   // Increment the generation counter for all managers that have a reference to
   // this texture.
   void IncrementManagerServiceIdGeneration();
 
   // Return the service id of the texture that we will delete when we are
-  // destroyed.  Normally, this is the same as service_id(), unless it is
-  // overridden by SetUnownedServiceId.
+  // destroyed.
   GLuint owned_service_id() const { return owned_service_id_; }
 
   GLenum GetCompatibilitySwizzleForChannel(GLenum channel);
   void SetCompatibilitySwizzle(const CompatibilitySwizzle* swizzle);
 
   MailboxManager* mailbox_manager_;
 
   // Info about each face and level of texture.
   std::vector<FaceInfo> face_infos_;
 
   // The texture refs that point to this Texture.
   typedef std::set<TextureRef*> RefSet;
   RefSet refs_;
 
   // The single TextureRef that accounts for memory for this texture. Must be
   // one of refs_.
   TextureRef* memory_tracking_ref_;
 
-  // The id of the texure
+  // The id of the texture.
   GLuint service_id_;
 
-  // The id of the texture that we are responsible for deleting.  Normally,
-  // this is the same as service_id_, unless a call to SetUnownedServiceId
-  // overrides it.  In that case, we'll use the overridden service id (stored
-  // in |service_id_|) for all purposes except deleting the texture name.
-  // Whoever calls SetUnownedServiceId is assumed to handle deleting that id,
-  // and only after we are either deleted or told to stop using it via
-  // another call to SetUnownedServiceId.
+  // The id of the texture that we are responsible for deleting.  Normally, this
+  // is the same as |service_id_|, unless a GLStreamTextureImage with its own
+  // service id is bound. In that case the GLStreamTextureImage service id is
+  // stored in |service_id_| and overrides the owned service id for all purposes
+  // except deleting the texture name.
   GLuint owned_service_id_;
 
   // Whether all renderable mips of this texture have been cleared.
   bool cleared_;
 
   int num_uncleared_mips_;
   int num_npot_faces_;
 
   // The target. 0 if unset, otherwise GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP.
   //             Or GL_TEXTURE_2D_ARRAY or GL_TEXTURE_3D (for GLES3).
@@ skipping 374 matching lines @@
   void SetLevelImage(TextureRef* ref,
                      GLenum target,
                      GLint level,
                      gl::GLImage* image,
                      Texture::ImageState state);
 
   void SetLevelStreamTextureImage(TextureRef* ref,
                                   GLenum target,
                                   GLint level,
                                   GLStreamTextureImage* image,
-                                  Texture::ImageState state);
+                                  Texture::ImageState state,
+                                  GLuint service_id);
+
+  void SetLevelImageState(TextureRef* ref,
+                          GLenum target,
+                          GLint level,
+                          Texture::ImageState state);
 
   size_t GetSignatureSize() const;
 
   void AddToSignature(
       TextureRef* ref,
       GLenum target,
       GLint level,
       std::string* signature) const;
 
   void AddObserver(DestructionObserver* observer) {
@@ skipping 225 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_