gpu: Change Produce/ConsumeTexture to allow texture sharing

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/hash_tables.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.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 {
 namespace gles2 {
 
 class GLES2Decoder;
 class Display;
 class ErrorState;
 class FeatureInfo;
 class FramebufferManager;
-class TextureDefinition;
+class MailboxManager;
 class TextureManager;
 class TextureRef;
 
 // Info about Textures currently in the system.
 // This class wraps a real GL texture, keeping track of its meta-data. It is
 // jointly owned by possibly multiple TextureRef.
 class GPU_EXPORT Texture {
  public:
   explicit Texture(GLuint service_id);
 
@@ skipping 122 matching lines @@
 
   // Whether a particular level/face is cleared.
   bool IsLevelCleared(GLenum target, GLint level) const;
 
   // Whether the texture has been defined
   bool IsDefined() const {
     return estimated_size() > 0;
   }
 
  private:
+  friend class MailboxManager;
   friend class TextureManager;
   friend class TextureRef;
   friend class TextureTestHelper;
 
   ~Texture();
   void AddTextureRef(TextureRef* ref);
   void RemoveTextureRef(TextureRef* ref, bool have_context);
   MemoryTypeTracker* GetMemTracker();
 
   // Condition on which this texture is renderable. Can be ONLY_IF_NPOT if it
@@ skipping 114 matching lines @@
       const FeatureInfo* feature_info,
       GLenum target,
       GLint level,
       gfx::GLImage* image);
 
   // Appends a signature for the given level.
   void AddToSignature(
       const FeatureInfo* feature_info,
       GLenum target, GLint level, std::string* signature) const;
 
+  void SetMailboxManager(MailboxManager* mailbox_manager);
+
   // Updates the unsafe textures count in all the managers referencing this
   // texture.
   void UpdateSafeToRenderFrom(bool cleared);
 
   // Updates the uncleared mip count in all the managers referencing this
   // texture.
   void UpdateMipCleared(LevelInfo* info, bool cleared);
 
   // Computes the CanRenderCondition flag.
   CanRenderCondition GetCanRenderCondition() const;
 
   // Updates the unrenderable texture count in all the managers referencing this
   // texture.
   void UpdateCanRenderCondition();
 
   // Increment the framebuffer state change count in all the managers
   // referencing this texture.
   void IncAllFramebufferStateChangeCount();
 
+  MailboxManager* mailbox_manager_;
+
   // Info about each face and level of texture.
   std::vector<std::vector<LevelInfo> > level_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_;
@@ skipping 54 matching lines @@
 
   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.
 class GPU_EXPORT TextureRef : public base::RefCounted<TextureRef> {
  public:
-  TextureRef(TextureManager* manager, Texture* texture);
+  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_; }

[greggman, 2013/05/23 17:36:19]

I'm not sure I follow the need for this. Is it only for testing? Then there's
also the reset_client_id as well but there's still going to be a mapping from
client_id to TextureRef in textures_.  

[piman, 2013/05/23 18:02:38]

It's there to be able to do the Delete in Consume. We could go through the list,
but since we're likely going to Consume somewhat often on a context with many
textures, this seems heavy.

reset_client_id is called when we remove the TextureRef from textures_. That
way, if we delete the texture in one context and the texture is bound in
another, if we switch to the other context and call Consume, we won't try to
delete an unrelated texture (if the client id was reused in the mean time).

   GLuint service_id() const { return texture_->service_id(); }
 
   // Sets the async transfer state for this texture. Only a single TextureRef
   // can set this on a given texture at any time.
   // NOTE: this should be per-context rather than per-texture. crbug.com/240504
   void SetAsyncTransferState(
       scoped_ptr<AsyncPixelTransferState> state) {
     DCHECK(!state || !texture_->GetAsyncTransferState());
     async_transfer_state_ = state.Pass();
   }
 
  private:
   friend class base::RefCounted<TextureRef>;
   friend class Texture;
   friend class TextureManager;
 
   ~TextureRef();
   const TextureManager* manager() const { return manager_; }
   TextureManager* manager() { return manager_; }
   AsyncPixelTransferState* async_transfer_state() const {
     return async_transfer_state_.get();
   }
+  void reset_client_id() { client_id_ = 0; }
 
   TextureManager* manager_;
   Texture* texture_;
+  GLuint client_id_;
 
   // State to facilitate async transfers on this texture.
   scoped_ptr<AsyncPixelTransferState> async_transfer_state_;
 
   DISALLOW_COPY_AND_ASSIGN(TextureRef);
 };
 
 // This class keeps track of the textures and their sizes so we can do NPOT and
 // texture complete checking.
 //
@@ skipping 96 matching lines @@
   // Adapter to call above function.
   void SetLevelInfoFromParams(TextureRef* ref,
                               const gpu::AsyncTexImage2DParams& params) {
     SetLevelInfo(
         ref, params.target, params.level, params.internal_format,
         params.width, params.height, 1 /* depth */,
         params.border, params.format,
         params.type, true /* cleared */ );
   }
 
-  // Save the texture definition and leave it undefined.
-  TextureDefinition* Save(TextureRef* ref);
+  Texture* Produce(TextureRef* ref);
 
-  // Redefine all the levels from the texture definition.
-  bool Restore(
-      const char* function_name,
-      GLES2Decoder* decoder,
-      TextureRef* ref,
-      TextureDefinition* definition);
+  // Maps an existing texture into the texture manager, at a given client ID.
+  TextureRef* Consume(GLuint client_id, Texture* texture);
 
   // Sets a mip as cleared.
   void SetLevelCleared(TextureRef* ref, GLenum target,
                        GLint level, bool cleared);
 
   // Sets a texture parameter of a Texture
   // Returns GL_NO_ERROR on success. Otherwise the error to generate.
   // TODO(gman): Expand to SetParameteri,f,iv,fv
   void SetParameter(
       const char* function_name, ErrorState* error_state,
@@ skipping 137 matching lines @@
   // The default textures for each target (texture name = 0)
   scoped_refptr<TextureRef> default_textures_[kNumDefaultTextures];
 
   DISALLOW_COPY_AND_ASSIGN(TextureManager);
 };
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_TEXTURE_MANAGER_H_