Add a base class of Texture for interfacing with the mailbox manager.

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 20 matching lines @@
 
 class GLES2Decoder;
 class GLStreamTextureImage;
 struct ContextState;
 struct DecoderFramebufferState;
 class Display;
 class ErrorState;
 class FeatureInfo;
 class FramebufferManager;
 class MailboxManager;
+class Texture;
 class TextureManager;
 class TextureRef;
 
+class GPU_EXPORT TextureBase {
+ public:
+  explicit TextureBase(GLuint service_id);
+  virtual ~TextureBase();
+
+  // The service side OpenGL id of the texture.
+  GLuint service_id() const { return service_id_; }
+
+  // Down-cast to other texture classes
+  virtual Texture* AsTexture();

[piman, 2016/09/07 17:38:31]

Will we ever use more than one derived type in a given MailboxManager? If not,
this is unnecessary and could be replaced with static casts.

[Geoff Lang, 2016/09/07 18:14:49]

No, each mailbox manager will only ever use one kind of texture object.  I can
fall back to static_casts, but I wasn't sure how comfortable you would be with
that more "unsafe" style.

Done.

+
+ protected:
+  // The id of the texture.
+  GLuint service_id_;
+
+  void DeleteFromMailboxManager();
+
+ private:
+  friend class MailboxManagerSync;
+  friend class MailboxManagerImpl;
+
+  void SetMailboxManager(MailboxManager* mailbox_manager);
+
+  MailboxManager* mailbox_manager_;
+};
+
 // 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 {
+class GPU_EXPORT Texture final : public TextureBase {
  public:
   enum ImageState {
     // If an image is associated with the texture and image state is UNBOUND,
     // then sampling out of the texture or using it as a target for drawing
     // will not read/write from/to the image.
     UNBOUND,
     // If image state is BOUND, then sampling from the texture will return the
     // contents of the image and using it as a target will modify the image.
     BOUND,
     // Image state is set to COPIED if the contents of the image has been
     // copied to the texture. Sampling from the texture will be equivalent
     // to sampling out the image (assuming image has not been changed since
     // it was copied). Using the texture as a target for drawing will only
     // modify the texture and not the image.
     COPIED
   };
 
   struct CompatibilitySwizzle {
     GLenum format;
     GLenum dest_format;
     GLenum red;
     GLenum green;
     GLenum blue;
     GLenum alpha;
   };
 
   explicit Texture(GLuint service_id);
 
+  Texture* AsTexture() final;
+
   const SamplerState& sampler_state() const {
     return sampler_state_;
   }
 
   GLenum min_filter() const {
     return sampler_state_.min_filter;
   }
 
   GLenum mag_filter() const {
     return sampler_state_.mag_filter;
@@ skipping 48 matching lines @@
   GLenum swizzle_a() const { return swizzle_a_; }
 
   int num_uncleared_mips() const {
     return num_uncleared_mips_;
   }
 
   uint32_t estimated_size() const { return estimated_size_; }
 
   bool CanRenderTo(const FeatureInfo* feature_info, GLint level) const;
 
-  // The service side OpenGL id of the texture.
-  GLuint service_id() const {
-    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;
   }
 
   // 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.
@@ skipping 123 matching lines @@
 
  private:
   friend class MailboxManagerImpl;
   friend class MailboxManagerSync;
   friend class MailboxManagerTest;
   friend class TextureDefinition;
   friend class TextureManager;
   friend class TextureRef;
   friend class TextureTestHelper;
 
-  ~Texture();
+  ~Texture() override;
   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
   // depends on context support for non-power-of-two textures (i.e. will be
   // renderable if NPOT support is in the context, otherwise not, e.g. texture
   // with a NPOT level). ALWAYS means it doesn't depend on context features
   // (e.g. complete POT), NEVER means it's not renderable regardless (e.g.
   // incomplete).
@@ skipping 170 matching lines @@
   void SetTarget(GLenum target, GLint max_levels);
 
   // Update info about this texture.
   void Update();
 
   // 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,
                         GLsizei width,
                         GLsizei height,
                         const gfx::Rect& cleared_rect);
@@ skipping 25 matching lines @@
   // this texture.
   void IncrementManagerServiceIdGeneration();
 
   // Return the service id of the texture that we will delete when we are
   // 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 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 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_;
 
@@ skipping 638 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_