Update GetTexParameter* and TexParameter* for ES3 in GPU command buffer

gpu/command_buffer/service/texture_manager.cc

 // 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.
 
 #include "gpu/command_buffer/service/texture_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bits.h"
@@ skipping 11 matching lines @@
 namespace gpu {
 namespace gles2 {
 
 // This should contain everything to uniquely identify a Texture.
 static const char TextureTag[] = "|Texture|";
 struct TextureSignature {
   GLenum target_;
   GLint level_;
   GLenum min_filter_;
   GLenum mag_filter_;
+  GLenum wrap_r_;
   GLenum wrap_s_;
   GLenum wrap_t_;
   GLenum usage_;
   GLenum internal_format_;
+  GLenum compare_func_;
+  GLenum compare_mode_;
   GLsizei width_;
   GLsizei height_;
   GLsizei depth_;
+  GLfloat max_lod_;
+  GLfloat min_lod_;
+  GLint base_level_;
   GLint border_;
+  GLint max_level_;
   GLenum format_;
   GLenum type_;
   bool has_image_;
   bool can_render_;
   bool can_render_to_;
   bool npot_;
 
   // Since we will be hashing this signature structure, the padding must be
   // zero initialized. Although the C++11 specifications specify that this is
   // true, we will use a constructor with a memset to further enforce it instead
   // of relying on compilers adhering to this deep dark corner specification.
   TextureSignature(GLenum target,
                    GLint level,
                    GLenum min_filter,
                    GLenum mag_filter,
+                   GLenum wrap_r,
                    GLenum wrap_s,
                    GLenum wrap_t,
                    GLenum usage,
                    GLenum internal_format,
+                   GLenum compare_func,
+                   GLenum compare_mode,
                    GLsizei width,
                    GLsizei height,
                    GLsizei depth,
+                   GLfloat max_lod,
+                   GLfloat min_lod,
+                   GLint base_level,
                    GLint border,
+                   GLint max_level,
                    GLenum format,
                    GLenum type,
                    bool has_image,
                    bool can_render,
                    bool can_render_to,
                    bool npot) {
     memset(this, 0, sizeof(TextureSignature));
     target_ = target;
     level_ = level;
     min_filter_ = min_filter;
     mag_filter_ = mag_filter;
+    wrap_r_ = wrap_r;
     wrap_s_ = wrap_s;
     wrap_t_ = wrap_t;
     usage_ = usage;
     internal_format_ = internal_format;
+    compare_func_ = compare_func;
+    compare_mode_ = compare_mode;
     width_ = width;
     height_ = height;
     depth_ = depth;
+    max_lod_ = max_lod;
+    min_lod_ = min_lod;
+    base_level_ = base_level;
     border_ = border;
+    max_level_ = max_level;
     format_ = format;
     type_ = type;
     has_image_ = has_image;
     can_render_ = can_render;
     can_render_to_ = can_render_to;
     npot_ = npot;
   }
 };
 
 TextureManager::DestructionObserver::DestructionObserver() {}
@@ skipping 34 matching lines @@
 Texture::Texture(GLuint service_id)
     : mailbox_manager_(NULL),
       memory_tracking_ref_(NULL),
       service_id_(service_id),
       cleared_(true),
       num_uncleared_mips_(0),
       num_npot_faces_(0),
       target_(0),
       min_filter_(GL_NEAREST_MIPMAP_LINEAR),
       mag_filter_(GL_LINEAR),
+      wrap_r_(GL_REPEAT),
       wrap_s_(GL_REPEAT),
       wrap_t_(GL_REPEAT),
       usage_(GL_NONE),
       pool_(GL_TEXTURE_POOL_UNMANAGED_CHROMIUM),
+      compare_func_(GL_LEQUAL),
+      compare_mode_(GL_NONE),
+      max_lod_(1000.0f),
+      min_lod_(-1000.0f),
+      base_level_(0),
+      max_level_(1000),
       max_level_set_(-1),
       texture_complete_(false),
       texture_mips_dirty_(false),
       texture_mips_complete_(false),
       cube_complete_(false),
       texture_level0_dirty_(false),
       texture_level0_complete_(false),
       npot_(false),
       has_been_bound_(false),
       framebuffer_attachment_count_(0),
@@ skipping 148 matching lines @@
   DCHECK_LT(static_cast<size_t>(level),
             face_infos_[face_index].level_infos.size());
 
   const Texture::LevelInfo& info =
       face_infos_[face_index].level_infos[level];
 
   TextureSignature signature_data(target,
                                   level,
                                   min_filter_,
                                   mag_filter_,
+                                  wrap_r_,
                                   wrap_s_,
                                   wrap_t_,
                                   usage_,
                                   info.internal_format,
+                                  compare_func_,
+                                  compare_mode_,
                                   info.width,
                                   info.height,
                                   info.depth,
+                                  max_lod_,
+                                  min_lod_,
+                                  base_level_,
                                   info.border,
+                                  max_level_,
                                   info.format,
                                   info.type,
                                   info.image.get() != NULL,
                                   CanRender(feature_info),
                                   CanRenderTo(),
                                   npot_);
 
   signature->append(TextureTag, sizeof(TextureTag));
   signature->append(reinterpret_cast<const char*>(&signature_data),
                     sizeof(signature_data));
@@ skipping 412 matching lines @@
       mag_filter_ = param;
       break;
     case GL_TEXTURE_POOL_CHROMIUM:
       if (!feature_info->validators()->texture_pool.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       GetMemTracker()->TrackMemFree(estimated_size());
       pool_ = param;
       GetMemTracker()->TrackMemAlloc(estimated_size());
       break;
+    case GL_TEXTURE_WRAP_R:
+      if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
+        return GL_INVALID_ENUM;
+      }
+      wrap_r_ = param;
+      break;
     case GL_TEXTURE_WRAP_S:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       wrap_s_ = param;
       break;
     case GL_TEXTURE_WRAP_T:
       if (!feature_info->validators()->texture_wrap_mode.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       wrap_t_ = param;
       break;
+    case GL_TEXTURE_COMPARE_FUNC:
+      if (!feature_info->validators()->texture_compare_func.IsValid(param)) {
+        return GL_INVALID_ENUM;
+      }
+      compare_func_ = param;
+      break;
+    case GL_TEXTURE_COMPARE_MODE:
+      if (!feature_info->validators()->texture_compare_mode.IsValid(param)) {
+        return GL_INVALID_ENUM;
+      }
+      compare_mode_ = param;
+      break;
+    case GL_TEXTURE_BASE_LEVEL:

[legend, 2015/05/11 07:17:14]

I have not found the legal range of GL_TEXTURE_BASE_LEVEL and
GL_TEXTURE_MAX_LEVEL in specifications. Any advices?

[piman, 2015/05/11 21:39:34]

In https://www.khronos.org/registry/gles/specs/3.0/es_spec_3.0.4.pdf, section
"3.8.7 Texture Parameters", it says "any non-negative integer" for both, so you
have to check for that.

[legend, 2015/05/12 02:34:16]

Done.

+      base_level_ = param;
+      break;
+    case GL_TEXTURE_MAX_LEVEL:
+      max_level_ = param;
+      break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       if (param < 1) {
         return GL_INVALID_VALUE;
       }
       break;
     case GL_TEXTURE_USAGE_ANGLE:
       if (!feature_info->validators()->texture_usage.IsValid(param)) {
         return GL_INVALID_ENUM;
       }
       usage_ = param;
@@ skipping 14 matching lines @@
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_MAG_FILTER:
     case GL_TEXTURE_POOL_CHROMIUM:
     case GL_TEXTURE_WRAP_S:
     case GL_TEXTURE_WRAP_T:
     case GL_TEXTURE_USAGE_ANGLE:
       {
         GLint iparam = static_cast<GLint>(param);
         return SetParameteri(feature_info, pname, iparam);
       }
+    case GL_TEXTURE_MIN_LOD:
+      min_lod_ = param;
+      break;
+    case GL_TEXTURE_MAX_LOD:
+      max_lod_ = param;
+      break;
     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
       if (param < 1.f) {
         return GL_INVALID_VALUE;
       }
       break;
     default:
       NOTREACHED();
       return GL_INVALID_ENUM;
   }
   return GL_NO_ERROR;
@@ skipping 941 matching lines @@
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
   texture_state_->texture_upload_count++;
   texture_state_->total_texture_upload_time +=
       base::TimeTicks::Now() - begin_time_;
 }
 
 }  // namespace gles2
 }  // namespace gpu