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 <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 gpu {
 namespace gles2 {
 
 class GLES2Decoder;
 struct ContextState;
 struct DecoderFramebufferState;
@@ skipping 21 matching lines @@
     // 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);
 
+  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 134 matching lines @@
 
   // 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_NEEDS_VALIDATION,
   };
 
   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.
   void 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 104 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 196 matching lines @@
   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 {
     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 75 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 HaveUnsafeTextures() const {
     return num_unsafe_textures_ > 0;
   }
 
   bool HaveUnclearedMips() const {
     return num_uncleared_mips_ > 0;
   }
 
   bool HaveImages() const {
     return num_images_ > 0;
@@ skipping 193 matching lines @@
   GLsizei max_texture_size_;
   GLsizei max_cube_map_texture_size_;
   GLsizei max_rectangle_texture_size_;
   GLsizei max_3d_texture_size_;
   GLint max_levels_;
   GLint max_cube_map_levels_;
   GLint max_3d_levels_;
 
   const bool use_default_textures_;
 
-  int num_unrenderable_textures_;
   int num_unsafe_textures_;
   int num_uncleared_mips_;
   int num_images_;
 
   // Counts the number of Textures allocated with 'this' as its manager.
   // Allows to check no Texture will outlive this.
   unsigned int texture_count_;
 
   bool have_context_;
 
@@ skipping 21 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_