Updating texture validation to account for sampler objects in ES3

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 <algorithm>
 #include <list>
 #include <set>
 #include <string>
 #include <vector>
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.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 gpu {
 namespace gles2 {
 
 class GLES2Decoder;
 struct ContextState;
 struct DecoderFramebufferState;
@@ skipping 19 matching lines @@
     // 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
   };
 
-  explicit Texture(GLuint service_id);
+  Texture(GLuint service_id, bool is_es3_enabled);
+
+  const SamplerState* sampler_state() const {
+    return &sampler_state_;
+  }
 
   GLenum min_filter() const {
-    return min_filter_;
+    return sampler_state_.min_filter;
   }
 
   GLenum mag_filter() const {
-    return mag_filter_;
+    return sampler_state_.mag_filter;
   }
 
   GLenum wrap_r() const {
-    return wrap_r_;
+    return sampler_state_.wrap_r;
   }
 
   GLenum wrap_s() const {
-    return wrap_s_;
+    return sampler_state_.wrap_s;
   }
 
   GLenum wrap_t() const {
-    return wrap_t_;
+    return sampler_state_.wrap_t;
   }
 
   GLenum usage() const {
     return usage_;
   }
 
   GLenum compare_func() const {
-    return compare_func_;
+    return sampler_state_.compare_func;
   }
 
   GLenum compare_mode() const {
-    return compare_mode_;
+    return sampler_state_.compare_mode;
   }
 
   GLfloat max_lod() const {
-    return max_lod_;
+    return sampler_state_.max_lod;
   }
 
   GLfloat min_lod() const {
-    return min_lod_;
+    return sampler_state_.min_lod;
   }
 
   GLint base_level() const {
     return base_level_;
   }
 
   GLint max_level() const {
     return max_level_;
   }
 
@@ skipping 107 matching lines @@
     return estimated_size() > 0;
   }
 
   // Initialize TEXTURE_MAX_ANISOTROPY to 1 if we haven't done so yet.
   void InitTextureMaxAnisotropyIfNeeded(GLenum target);
 
   void DumpLevelMemory(base::trace_event::ProcessMemoryDump* pmd,
                        uint64_t client_tracing_id,
                        const std::string& dump_name) const;
 
+  // Whether the texture has been defined
+  bool IsES3Enabled() const {
+    return is_es3_enabled_;
+  }
+
  private:
   friend class MailboxManagerImpl;
   friend class MailboxManagerSync;
   friend class MailboxManagerTest;
   friend class TextureDefinition;
   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
   // 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).
   enum CanRenderCondition {
     CAN_RENDER_ALWAYS,
     CAN_RENDER_NEVER,
-    CAN_RENDER_ONLY_IF_NPOT
+    CAN_RENDER_ONLY_IF_NPOT,
+    CAN_RENDER_WITH_VALID_SAMPLER
   };
 
   struct LevelInfo {
     LevelInfo();
     LevelInfo(const LevelInfo& rhs);
     ~LevelInfo();
 
     gfx::Rect cleared_rect;
     GLenum target;
     GLint level;
@@ skipping 74 matching lines @@
   // Returns GL_NO_ERROR on success. Otherwise the error to generate.
   GLenum SetParameteri(
       const FeatureInfo* feature_info, GLenum pname, GLint param);
   GLenum SetParameterf(
       const FeatureInfo* feature_info, GLenum pname, GLfloat param);
 
   // Makes each of the mip levels as though they were generated.
   bool MarkMipmapsGenerated(const FeatureInfo* feature_info);
 
   bool NeedsMips() const {
-    return min_filter_ != GL_NEAREST && min_filter_ != GL_LINEAR;
+    return sampler_state_.min_filter != GL_NEAREST &&
+           sampler_state_.min_filter != GL_LINEAR;
   }
 
   // True if this texture meets all the GLES2 criteria for rendering.
   // See section 3.8.2 of the GLES2 spec.
   bool CanRender(const FeatureInfo* feature_info) const;
+  bool CanRenderWithSampler(const FeatureInfo* feature_info,
+                            const SamplerState* sampler_state) const;
 
   // Returns true if mipmaps can be generated by GL.
   bool CanGenerateMipmaps(const FeatureInfo* feature_info) const;
 
   // Returns true if any of the texture dimensions are not a power of two.
   static bool TextureIsNPOT(GLsizei width, GLsizei height, GLsizei depth);
 
   // Returns true if texture face is complete relative to the first face.
   static bool TextureFaceComplete(const Texture::LevelInfo& first_face,
                                   size_t face_index,
@@ skipping 86 matching lines @@
   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).
   GLenum target_;
 
   // Texture parameters.
-  GLenum min_filter_;
-  GLenum mag_filter_;
-  GLenum wrap_r_;
-  GLenum wrap_s_;
-  GLenum wrap_t_;
+  SamplerState sampler_state_;
   GLenum usage_;
-  GLenum compare_func_;
-  GLenum compare_mode_;
-  GLfloat max_lod_;
-  GLfloat min_lod_;
   GLint base_level_;
   GLint max_level_;
 
   // The maximum level that has been set.
   GLint max_level_set_;
 
   // Whether or not this texture is "texture complete"
   bool texture_complete_;
 
   // Whether mip levels have changed and should be reverified.
@@ skipping 23 matching lines @@
 
   // Size in bytes this texture is assumed to take in memory.
   uint32 estimated_size_;
 
   // Cache of the computed CanRenderCondition flag.
   CanRenderCondition can_render_condition_;
 
   // Whether we have initialized TEXTURE_MAX_ANISOTROPY to 1.
   bool texture_max_anisotropy_initialized_;
 
+  // Whether this texture was created by an ES3 context
+  bool is_es3_enabled_;
+
   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, GLuint client_id, Texture* texture);
@@ skipping 149 matching lines @@
   static GLenum ExtractFormatFromStorageFormat(GLenum internalformat);
   static GLenum ExtractTypeFromStorageFormat(GLenum internalformat);
 
   // Checks if a dimensions are valid for a given target.
   bool ValidForTarget(
       GLenum target, GLint level,
       GLsizei width, GLsizei height, GLsizei depth);
 
   // True if this texture meets all the GLES2 criteria for rendering.
   // See section 3.8.2 of the GLES2 spec.
-  bool CanRender(const TextureRef* ref) const {
+  bool CanRender(
+      const TextureRef* ref) const {
     return ref->texture()->CanRender(feature_info_.get());
   }
 
+  bool CanRenderWithSampler(
+      const TextureRef* ref, const SamplerState* sampler_state) const {
+    return ref->texture()->CanRenderWithSampler(
+        feature_info_.get(), sampler_state);
+  }
+
   // Returns true if mipmaps can be generated by GL.
   bool CanGenerateMipmaps(const TextureRef* ref) const {
     return ref->texture()->CanGenerateMipmaps(feature_info_.get());
   }
 
   // Sets the Texture's target
   // Parameters:
   //   target: GL_TEXTURE_2D or GL_TEXTURE_CUBE_MAP
   //           GL_TEXTURE_2D_ARRAY or GL_TEXTURE_3D (for GLES3)
   //   max_levels: The maximum levels this type of target can have.
@@ skipping 76 matching lines @@
       case GL_TEXTURE_EXTERNAL_OES:
         return default_textures_[kExternalOES].get();
       case GL_TEXTURE_RECTANGLE_ARB:
         return default_textures_[kRectangleARB].get();
       default:
         NOTREACHED();
         return NULL;
     }
   }
 
-  bool HaveUnrenderableTextures() const {
-    return num_unrenderable_textures_ > 0;
+  bool NeedsTextureRenderChecks() const {
+    return feature_info_->IsES3Enabled() || num_unrenderable_textures_ > 0;
   }
 
   bool HaveUnsafeTextures() const {
     return num_unsafe_textures_ > 0;
   }
 
   bool HaveUnclearedMips() const {
     return num_uncleared_mips_ > 0;
   }
 
@@ skipping 230 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_