Expose API for GL_EXT_occlusion_query_boolean but as no-ops

R=jbauman@chromium.org
BUG=88601
TEST=none


Review URL: http://codereview.chromium.org/9463027

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@123766 0039d316-1c4b-4281-b951-d872f2087c98

17 files changed, 753 insertions, 34 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index ca2c747..8a272e9 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -433,6 +433,26 @@ _ENUM_LISTS = {
       'GL_ACTIVE_UNIFORM_MAX_LENGTH',
     ],
   },
+  'QueryObjectParameter': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_QUERY_RESULT_EXT',
+      'GL_QUERY_RESULT_AVAILABLE_EXT',
+    ],
+  },
+  'QueryParameter': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_CURRENT_QUERY_EXT',
+    ],
+  },
+  'QueryTarget': {
+    'type': 'GLenum',
+    'valid': [
+      'GL_ANY_SAMPLES_PASSED_EXT',
+      'GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT',
+    ],
+  },
   'RenderBufferParameter': {
     'type': 'GLenum',
     'valid': [
@@ -1536,7 +1556,13 @@ _FUNCTION_INFO = {
     'unit_test': False,
     'pepper_interface': 'InstancedArrays',
   },
-
+  'GenQueriesEXT': {'type': 'Todo'},
+  'DeleteQueriesEXT': {'type': 'Todo'},
+  'IsQueryEXT': {'type': 'Todo'},
+  'BeginQueryEXT': {'type': 'Todo'},
+  'EndQueryEXT': {'type': 'Todo'},
+  'GetQueryivEXT': {'type': 'Todo'},
+  'GetQueryObjectuivEXT': {'type': 'Todo'},
 }
 
 
@@ -2154,11 +2180,11 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
 
   def WriteImmediateCmdInit(self, func, file):
     """Writes the Init function for the immediate version of a command."""
-    raise Error
+    raise NotImplementedError(func.name)
 
   def WriteImmediateCmdSet(self, func, file):
     """Writes the Set function for the immediate version of a command."""
-    raise Error
+    raise NotImplementedError(func.name)
 
   def WriteCmdHelper(self, func, file):
     """Writes the cmd helper definition for a cmd."""
@@ -2252,10 +2278,46 @@ class CustomHandler(TypeHandler):
 class TodoHandler(CustomHandler):
   """Handle for commands that are not yet implemented."""
 
+  def AddImmediateFunction(self, generator, func):
+    """Overrriden from TypeHandler."""
+    pass
+
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
+  def WriteGLES2ImplementationUnitTest(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteGLES2ImplementationHeader(self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("%s %s(%s) {\n" %
+               (func.return_type, func.original_name,
+                func.MakeTypedOriginalArgString("")))
+    file.Write("  // TODO: for now this is a no-op\n")
+    file.Write(
+        "  SetGLError(GL_INVALID_OPERATION, \"gl%s not implemented\");\n" %
+        func.name)
+    if func.return_type != "void":
+      file.Write("  return 0;\n")
+    file.Write("}\n")
+    file.Write("\n")
+
+  def WriteServiceImplementation(self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write(
+        "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
+    file.Write(
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
+    file.Write("  // TODO: for now this is a no-op\n")
+    file.Write(
+        "  SetGLError(GL_INVALID_OPERATION, \"gl%s not implemented\");\n" %
+        func.name)
+    file.Write("  return error::kNoError;\n")
+    file.Write("}\n")
+    file.Write("\n")
+
 
 class HandWrittenHandler(CustomHandler):
   """Handler for comands where everything must be written by hand."""
@@ -2626,7 +2688,7 @@ class GENnHandler(TypeHandler):
         'name': func.original_name,
         'typed_args': func.MakeTypedOriginalArgString(""),
         'args': func.MakeOriginalArgString(""),
-        'resource_type': func.name[3:],
+        'resource_type': func.GetInfo('resource_type') or func.name[3:],
         'count_name': func.GetOriginalArgs()[0].name,
       }
     file.Write("%(return_type)s %(name)s(%(typed_args)s) {\n" % args)
diff --git a/gpu/command_buffer/client/gles2_c_lib_autogen.h b/gpu/command_buffer/client/gles2_c_lib_autogen.h
index f4f7e11..8698dce 100644
--- a/gpu/command_buffer/client/gles2_c_lib_autogen.h
+++ b/gpu/command_buffer/client/gles2_c_lib_autogen.h
@@ -520,6 +520,27 @@ void GLES2TexStorage2DEXT(
   gles2::GetGLContext()->TexStorage2DEXT(
       target, levels, internalFormat, width, height);
 }
+void GLES2GenQueriesEXT(GLsizei n, GLuint* ids) {
+  gles2::GetGLContext()->GenQueriesEXT(n, ids);
+}
+void GLES2DeleteQueriesEXT(GLsizei n, const GLuint* ids) {
+  gles2::GetGLContext()->DeleteQueriesEXT(n, ids);
+}
+GLboolean GLES2IsQueryEXT(GLuint id) {
+  return gles2::GetGLContext()->IsQueryEXT(id);
+}
+void GLES2BeginQueryEXT(GLenum target, GLuint id) {
+  gles2::GetGLContext()->BeginQueryEXT(target, id);
+}
+void GLES2EndQueryEXT(GLenum target) {
+  gles2::GetGLContext()->EndQueryEXT(target);
+}
+void GLES2GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
+  gles2::GetGLContext()->GetQueryivEXT(target, pname, params);
+}
+void GLES2GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params) {
+  gles2::GetGLContext()->GetQueryObjectuivEXT(id, pname, params);
+}
 void GLES2SwapBuffers() {
   gles2::GetGLContext()->SwapBuffers();
 }
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index abaca98..524fd74 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -1524,6 +1524,60 @@
     }
   }
 
+  void GenQueriesEXT(GLsizei n, uint32 ids_shm_id, uint32 ids_shm_offset) {
+    gles2::GenQueriesEXT* c = GetCmdSpace<gles2::GenQueriesEXT>();
+    if (c) {
+      c->Init(n, ids_shm_id, ids_shm_offset);
+    }
+  }
+
+  void DeleteQueriesEXT(GLsizei n, uint32 ids_shm_id, uint32 ids_shm_offset) {
+    gles2::DeleteQueriesEXT* c = GetCmdSpace<gles2::DeleteQueriesEXT>();
+    if (c) {
+      c->Init(n, ids_shm_id, ids_shm_offset);
+    }
+  }
+
+  void IsQueryEXT(GLuint id) {
+    gles2::IsQueryEXT* c = GetCmdSpace<gles2::IsQueryEXT>();
+    if (c) {
+      c->Init(id);
+    }
+  }
+
+  void BeginQueryEXT(GLenum target, GLuint id) {
+    gles2::BeginQueryEXT* c = GetCmdSpace<gles2::BeginQueryEXT>();
+    if (c) {
+      c->Init(target, id);
+    }
+  }
+
+  void EndQueryEXT(GLenum target) {
+    gles2::EndQueryEXT* c = GetCmdSpace<gles2::EndQueryEXT>();
+    if (c) {
+      c->Init(target);
+    }
+  }
+
+  void GetQueryivEXT(
+      GLenum target, GLenum pname, uint32 params_shm_id,
+      uint32 params_shm_offset) {
+    gles2::GetQueryivEXT* c = GetCmdSpace<gles2::GetQueryivEXT>();
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
+  }
+
+  void GetQueryObjectuivEXT(
+      GLuint id, GLenum pname, uint32 params_shm_id,
+      uint32 params_shm_offset) {
+    gles2::GetQueryObjectuivEXT* c =
+        GetCmdSpace<gles2::GetQueryObjectuivEXT>();
+    if (c) {
+      c->Init(id, pname, params_shm_id, params_shm_offset);
+    }
+  }
+
   void SwapBuffers() {
     gles2::SwapBuffers* c = GetCmdSpace<gles2::SwapBuffers>();
     if (c) {
diff --git a/gpu/command_buffer/client/gles2_implementation_autogen.h b/gpu/command_buffer/client/gles2_implementation_autogen.h
index abf2d5b..9b33d7c 100644
--- a/gpu/command_buffer/client/gles2_implementation_autogen.h
+++ b/gpu/command_buffer/client/gles2_implementation_autogen.h
@@ -1409,6 +1409,42 @@ void TexStorage2DEXT(
   helper_->TexStorage2DEXT(target, levels, internalFormat, width, height);
 }
 
+void GenQueriesEXT(GLsizei n, GLuint* ids) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glGenQueriesEXT not implemented");
+}
+
+void DeleteQueriesEXT(GLsizei n, const GLuint* ids) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glDeleteQueriesEXT not implemented");
+}
+
+GLboolean IsQueryEXT(GLuint id) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glIsQueryEXT not implemented");
+  return 0;
+}
+
+void BeginQueryEXT(GLenum target, GLuint id) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT not implemented");
+}
+
+void EndQueryEXT(GLenum target) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT not implemented");
+}
+
+void GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glGetQueryivEXT not implemented");
+}
+
+void GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glGetQueryObjectuivEXT not implemented");
+}
+
 void SwapBuffers();
 
 GLuint GetMaxValueInBufferCHROMIUM(
diff --git a/gpu/command_buffer/cmd_buffer_functions.txt b/gpu/command_buffer/cmd_buffer_functions.txt
index 4713e11..82fd73b 100644
--- a/gpu/command_buffer/cmd_buffer_functions.txt
+++ b/gpu/command_buffer/cmd_buffer_functions.txt
@@ -149,6 +149,13 @@ GL_APICALL void         GL_APIENTRY glViewport (GLint x, GLint y, GLsizei width,
 GL_APICALL void         GL_APIENTRY glBlitFramebufferEXT (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenumBlitFilter filter);
 GL_APICALL void         GL_APIENTRY glRenderbufferStorageMultisampleEXT (GLenumRenderBufferTarget target, GLsizei samples, GLenumRenderBufferFormat internalformat, GLsizei width, GLsizei height);
 GL_APICALL void         GL_APIENTRY glTexStorage2DEXT (GLenumTextureTarget target, GLsizei levels, GLenumTextureInternalFormatStorage internalFormat, GLsizei width, GLsizei height);
+GL_APICALL void         GL_APIENTRY glGenQueriesEXT (GLsizeiNotNegative n, GLuint* ids);
+GL_APICALL void         GL_APIENTRY glDeleteQueriesEXT (GLsizeiNotNegative n, const GLuint* ids);
+GL_APICALL GLboolean    GL_APIENTRY glIsQueryEXT (GLidQuery id);
+GL_APICALL void         GL_APIENTRY glBeginQueryEXT (GLenumQueryTarget target, GLidQuery id);
+GL_APICALL void         GL_APIENTRY glEndQueryEXT (GLenumQueryTarget target);
+GL_APICALL void         GL_APIENTRY glGetQueryivEXT (GLenumQueryTarget target, GLenumQueryParameter pname, GLint* params);
+GL_APICALL void         GL_APIENTRY glGetQueryObjectuivEXT (GLidQuery id, GLenumQueryObjectParameter pname, GLuint* params);
 // Non-GL commands.
 GL_APICALL void         GL_APIENTRY glSwapBuffers (void);
 GL_APICALL GLuint       GL_APIENTRY glGetMaxValueInBufferCHROMIUM (GLidBuffer buffer_id, GLsizei count, GLenumGetMaxIndexType type, GLuint offset);
diff --git a/gpu/command_buffer/common/gles2_cmd_format.h b/gpu/command_buffer/common/gles2_cmd_format.h
index 439ea71..972771b 100644
--- a/gpu/command_buffer/common/gles2_cmd_format.h
+++ b/gpu/command_buffer/common/gles2_cmd_format.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -53,6 +53,7 @@ enum IdNamespaces {
   kProgramsAndShaders,
   kRenderbuffers,
   kTextures,
+  kQueries,
   kNumIdNamespaces
 };
 
diff --git a/gpu/command_buffer/common/gles2_cmd_format_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
index c3f4c4d..a0e05c8 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_autogen.h
@@ -8523,6 +8523,300 @@ COMPILE_ASSERT(offsetof(TexStorage2DEXT, width) == 16,
 COMPILE_ASSERT(offsetof(TexStorage2DEXT, height) == 20,
                OffsetOf_TexStorage2DEXT_height_not_20);
 
+struct GenQueriesEXT {
+  typedef GenQueriesEXT ValueType;
+  static const CommandId kCmdId = kGenQueriesEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) {
+    SetHeader();
+    n = _n;
+    ids_shm_id = _ids_shm_id;
+    ids_shm_offset = _ids_shm_offset;
+  }
+
+  void* Set(
+      void* cmd, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) {
+    static_cast<ValueType*>(cmd)->Init(_n, _ids_shm_id, _ids_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  int32 n;
+  uint32 ids_shm_id;
+  uint32 ids_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GenQueriesEXT) == 16,
+               Sizeof_GenQueriesEXT_is_not_16);
+COMPILE_ASSERT(offsetof(GenQueriesEXT, header) == 0,
+               OffsetOf_GenQueriesEXT_header_not_0);
+COMPILE_ASSERT(offsetof(GenQueriesEXT, n) == 4,
+               OffsetOf_GenQueriesEXT_n_not_4);
+COMPILE_ASSERT(offsetof(GenQueriesEXT, ids_shm_id) == 8,
+               OffsetOf_GenQueriesEXT_ids_shm_id_not_8);
+COMPILE_ASSERT(offsetof(GenQueriesEXT, ids_shm_offset) == 12,
+               OffsetOf_GenQueriesEXT_ids_shm_offset_not_12);
+
+struct DeleteQueriesEXT {
+  typedef DeleteQueriesEXT ValueType;
+  static const CommandId kCmdId = kDeleteQueriesEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) {
+    SetHeader();
+    n = _n;
+    ids_shm_id = _ids_shm_id;
+    ids_shm_offset = _ids_shm_offset;
+  }
+
+  void* Set(
+      void* cmd, GLsizei _n, uint32 _ids_shm_id, uint32 _ids_shm_offset) {
+    static_cast<ValueType*>(cmd)->Init(_n, _ids_shm_id, _ids_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  int32 n;
+  uint32 ids_shm_id;
+  uint32 ids_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(DeleteQueriesEXT) == 16,
+               Sizeof_DeleteQueriesEXT_is_not_16);
+COMPILE_ASSERT(offsetof(DeleteQueriesEXT, header) == 0,
+               OffsetOf_DeleteQueriesEXT_header_not_0);
+COMPILE_ASSERT(offsetof(DeleteQueriesEXT, n) == 4,
+               OffsetOf_DeleteQueriesEXT_n_not_4);
+COMPILE_ASSERT(offsetof(DeleteQueriesEXT, ids_shm_id) == 8,
+               OffsetOf_DeleteQueriesEXT_ids_shm_id_not_8);
+COMPILE_ASSERT(offsetof(DeleteQueriesEXT, ids_shm_offset) == 12,
+               OffsetOf_DeleteQueriesEXT_ids_shm_offset_not_12);
+
+struct IsQueryEXT {
+  typedef IsQueryEXT ValueType;
+  static const CommandId kCmdId = kIsQueryEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(GLuint _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  void* Set(void* cmd, GLuint _id) {
+    static_cast<ValueType*>(cmd)->Init(_id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32 id;
+};
+
+COMPILE_ASSERT(sizeof(IsQueryEXT) == 8,
+               Sizeof_IsQueryEXT_is_not_8);
+COMPILE_ASSERT(offsetof(IsQueryEXT, header) == 0,
+               OffsetOf_IsQueryEXT_header_not_0);
+COMPILE_ASSERT(offsetof(IsQueryEXT, id) == 4,
+               OffsetOf_IsQueryEXT_id_not_4);
+
+struct BeginQueryEXT {
+  typedef BeginQueryEXT ValueType;
+  static const CommandId kCmdId = kBeginQueryEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(GLenum _target, GLuint _id) {
+    SetHeader();
+    target = _target;
+    id = _id;
+  }
+
+  void* Set(void* cmd, GLenum _target, GLuint _id) {
+    static_cast<ValueType*>(cmd)->Init(_target, _id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32 target;
+  uint32 id;
+};
+
+COMPILE_ASSERT(sizeof(BeginQueryEXT) == 12,
+               Sizeof_BeginQueryEXT_is_not_12);
+COMPILE_ASSERT(offsetof(BeginQueryEXT, header) == 0,
+               OffsetOf_BeginQueryEXT_header_not_0);
+COMPILE_ASSERT(offsetof(BeginQueryEXT, target) == 4,
+               OffsetOf_BeginQueryEXT_target_not_4);
+COMPILE_ASSERT(offsetof(BeginQueryEXT, id) == 8,
+               OffsetOf_BeginQueryEXT_id_not_8);
+
+struct EndQueryEXT {
+  typedef EndQueryEXT ValueType;
+  static const CommandId kCmdId = kEndQueryEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(GLenum _target) {
+    SetHeader();
+    target = _target;
+  }
+
+  void* Set(void* cmd, GLenum _target) {
+    static_cast<ValueType*>(cmd)->Init(_target);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32 target;
+};
+
+COMPILE_ASSERT(sizeof(EndQueryEXT) == 8,
+               Sizeof_EndQueryEXT_is_not_8);
+COMPILE_ASSERT(offsetof(EndQueryEXT, header) == 0,
+               OffsetOf_EndQueryEXT_header_not_0);
+COMPILE_ASSERT(offsetof(EndQueryEXT, target) == 4,
+               OffsetOf_EndQueryEXT_target_not_4);
+
+struct GetQueryivEXT {
+  typedef GetQueryivEXT ValueType;
+  static const CommandId kCmdId = kGetQueryivEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      GLenum _target, GLenum _pname, uint32 _params_shm_id,
+      uint32 _params_shm_offset) {
+    SetHeader();
+    target = _target;
+    pname = _pname;
+    params_shm_id = _params_shm_id;
+    params_shm_offset = _params_shm_offset;
+  }
+
+  void* Set(
+      void* cmd, GLenum _target, GLenum _pname, uint32 _params_shm_id,
+      uint32 _params_shm_offset) {
+    static_cast<ValueType*>(
+        cmd)->Init(_target, _pname, _params_shm_id, _params_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32 target;
+  uint32 pname;
+  uint32 params_shm_id;
+  uint32 params_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GetQueryivEXT) == 20,
+               Sizeof_GetQueryivEXT_is_not_20);
+COMPILE_ASSERT(offsetof(GetQueryivEXT, header) == 0,
+               OffsetOf_GetQueryivEXT_header_not_0);
+COMPILE_ASSERT(offsetof(GetQueryivEXT, target) == 4,
+               OffsetOf_GetQueryivEXT_target_not_4);
+COMPILE_ASSERT(offsetof(GetQueryivEXT, pname) == 8,
+               OffsetOf_GetQueryivEXT_pname_not_8);
+COMPILE_ASSERT(offsetof(GetQueryivEXT, params_shm_id) == 12,
+               OffsetOf_GetQueryivEXT_params_shm_id_not_12);
+COMPILE_ASSERT(offsetof(GetQueryivEXT, params_shm_offset) == 16,
+               OffsetOf_GetQueryivEXT_params_shm_offset_not_16);
+
+struct GetQueryObjectuivEXT {
+  typedef GetQueryObjectuivEXT ValueType;
+  static const CommandId kCmdId = kGetQueryObjectuivEXT;
+  static const cmd::ArgFlags kArgFlags = cmd::kFixed;
+
+  static uint32 ComputeSize() {
+    return static_cast<uint32>(sizeof(ValueType));  // NOLINT
+  }
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      GLuint _id, GLenum _pname, uint32 _params_shm_id,
+      uint32 _params_shm_offset) {
+    SetHeader();
+    id = _id;
+    pname = _pname;
+    params_shm_id = _params_shm_id;
+    params_shm_offset = _params_shm_offset;
+  }
+
+  void* Set(
+      void* cmd, GLuint _id, GLenum _pname, uint32 _params_shm_id,
+      uint32 _params_shm_offset) {
+    static_cast<ValueType*>(
+        cmd)->Init(_id, _pname, _params_shm_id, _params_shm_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  gpu::CommandHeader header;
+  uint32 id;
+  uint32 pname;
+  uint32 params_shm_id;
+  uint32 params_shm_offset;
+};
+
+COMPILE_ASSERT(sizeof(GetQueryObjectuivEXT) == 20,
+               Sizeof_GetQueryObjectuivEXT_is_not_20);
+COMPILE_ASSERT(offsetof(GetQueryObjectuivEXT, header) == 0,
+               OffsetOf_GetQueryObjectuivEXT_header_not_0);
+COMPILE_ASSERT(offsetof(GetQueryObjectuivEXT, id) == 4,
+               OffsetOf_GetQueryObjectuivEXT_id_not_4);
+COMPILE_ASSERT(offsetof(GetQueryObjectuivEXT, pname) == 8,
+               OffsetOf_GetQueryObjectuivEXT_pname_not_8);
+COMPILE_ASSERT(offsetof(GetQueryObjectuivEXT, params_shm_id) == 12,
+               OffsetOf_GetQueryObjectuivEXT_params_shm_id_not_12);
+COMPILE_ASSERT(offsetof(GetQueryObjectuivEXT, params_shm_offset) == 16,
+               OffsetOf_GetQueryObjectuivEXT_params_shm_offset_not_16);
+
 struct SwapBuffers {
   typedef SwapBuffers ValueType;
   static const CommandId kCmdId = kSwapBuffers;
diff --git a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
index 5b0dceb..4bc2341 100644
--- a/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_format_test_autogen.h
@@ -3318,6 +3318,119 @@ TEST_F(GLES2FormatTest, TexStorage2DEXT) {
       next_cmd, sizeof(cmd));
 }
 
+TEST_F(GLES2FormatTest, GenQueriesEXT) {
+  GenQueriesEXT& cmd = *GetBufferAs<GenQueriesEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLsizei>(11),
+      static_cast<uint32>(12),
+      static_cast<uint32>(13));
+  EXPECT_EQ(static_cast<uint32>(GenQueriesEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
+  EXPECT_EQ(static_cast<uint32>(12), cmd.ids_shm_id);
+  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_offset);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, DeleteQueriesEXT) {
+  DeleteQueriesEXT& cmd = *GetBufferAs<DeleteQueriesEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLsizei>(11),
+      static_cast<uint32>(12),
+      static_cast<uint32>(13));
+  EXPECT_EQ(static_cast<uint32>(DeleteQueriesEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
+  EXPECT_EQ(static_cast<uint32>(12), cmd.ids_shm_id);
+  EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_offset);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, IsQueryEXT) {
+  IsQueryEXT& cmd = *GetBufferAs<IsQueryEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLuint>(11));
+  EXPECT_EQ(static_cast<uint32>(IsQueryEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLuint>(11), cmd.id);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, BeginQueryEXT) {
+  BeginQueryEXT& cmd = *GetBufferAs<BeginQueryEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLenum>(11),
+      static_cast<GLuint>(12));
+  EXPECT_EQ(static_cast<uint32>(BeginQueryEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
+  EXPECT_EQ(static_cast<GLuint>(12), cmd.id);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, EndQueryEXT) {
+  EndQueryEXT& cmd = *GetBufferAs<EndQueryEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLenum>(11));
+  EXPECT_EQ(static_cast<uint32>(EndQueryEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, GetQueryivEXT) {
+  GetQueryivEXT& cmd = *GetBufferAs<GetQueryivEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLenum>(11),
+      static_cast<GLenum>(12),
+      static_cast<uint32>(13),
+      static_cast<uint32>(14));
+  EXPECT_EQ(static_cast<uint32>(GetQueryivEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
+  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
+  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
+TEST_F(GLES2FormatTest, GetQueryObjectuivEXT) {
+  GetQueryObjectuivEXT& cmd = *GetBufferAs<GetQueryObjectuivEXT>();
+  void* next_cmd = cmd.Set(
+      &cmd,
+      static_cast<GLuint>(11),
+      static_cast<GLenum>(12),
+      static_cast<uint32>(13),
+      static_cast<uint32>(14));
+  EXPECT_EQ(static_cast<uint32>(GetQueryObjectuivEXT::kCmdId),
+            cmd.header.command);
+  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
+  EXPECT_EQ(static_cast<GLuint>(11), cmd.id);
+  EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
+  EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
+  EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
+  CheckBytesWrittenMatchesExpectedSize(
+      next_cmd, sizeof(cmd));
+}
+
 TEST_F(GLES2FormatTest, SwapBuffers) {
   SwapBuffers& cmd = *GetBufferAs<SwapBuffers>();
   void* next_cmd = cmd.Set(
diff --git a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
index 5d64dcf..9a311a8 100644
--- a/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_ids_autogen.h
@@ -196,25 +196,32 @@
   OP(BlitFramebufferEXT)                                       /* 439 */ \
   OP(RenderbufferStorageMultisampleEXT)                        /* 440 */ \
   OP(TexStorage2DEXT)                                          /* 441 */ \
-  OP(SwapBuffers)                                              /* 442 */ \
-  OP(GetMaxValueInBufferCHROMIUM)                              /* 443 */ \
-  OP(GenSharedIdsCHROMIUM)                                     /* 444 */ \
-  OP(DeleteSharedIdsCHROMIUM)                                  /* 445 */ \
-  OP(RegisterSharedIdsCHROMIUM)                                /* 446 */ \
-  OP(EnableFeatureCHROMIUM)                                    /* 447 */ \
-  OP(ResizeCHROMIUM)                                           /* 448 */ \
-  OP(GetRequestableExtensionsCHROMIUM)                         /* 449 */ \
-  OP(RequestExtensionCHROMIUM)                                 /* 450 */ \
-  OP(GetMultipleIntegervCHROMIUM)                              /* 451 */ \
-  OP(GetProgramInfoCHROMIUM)                                   /* 452 */ \
-  OP(CreateStreamTextureCHROMIUM)                              /* 453 */ \
-  OP(DestroyStreamTextureCHROMIUM)                             /* 454 */ \
-  OP(GetTranslatedShaderSourceANGLE)                           /* 455 */ \
-  OP(PostSubBufferCHROMIUM)                                    /* 456 */ \
-  OP(TexImageIOSurface2DCHROMIUM)                              /* 457 */ \
-  OP(DrawArraysInstancedANGLE)                                 /* 458 */ \
-  OP(DrawElementsInstancedANGLE)                               /* 459 */ \
-  OP(VertexAttribDivisorANGLE)                                 /* 460 */ \
+  OP(GenQueriesEXT)                                            /* 442 */ \
+  OP(DeleteQueriesEXT)                                         /* 443 */ \
+  OP(IsQueryEXT)                                               /* 444 */ \
+  OP(BeginQueryEXT)                                            /* 445 */ \
+  OP(EndQueryEXT)                                              /* 446 */ \
+  OP(GetQueryivEXT)                                            /* 447 */ \
+  OP(GetQueryObjectuivEXT)                                     /* 448 */ \
+  OP(SwapBuffers)                                              /* 449 */ \
+  OP(GetMaxValueInBufferCHROMIUM)                              /* 450 */ \
+  OP(GenSharedIdsCHROMIUM)                                     /* 451 */ \
+  OP(DeleteSharedIdsCHROMIUM)                                  /* 452 */ \
+  OP(RegisterSharedIdsCHROMIUM)                                /* 453 */ \
+  OP(EnableFeatureCHROMIUM)                                    /* 454 */ \
+  OP(ResizeCHROMIUM)                                           /* 455 */ \
+  OP(GetRequestableExtensionsCHROMIUM)                         /* 456 */ \
+  OP(RequestExtensionCHROMIUM)                                 /* 457 */ \
+  OP(GetMultipleIntegervCHROMIUM)                              /* 458 */ \
+  OP(GetProgramInfoCHROMIUM)                                   /* 459 */ \
+  OP(CreateStreamTextureCHROMIUM)                              /* 460 */ \
+  OP(DestroyStreamTextureCHROMIUM)                             /* 461 */ \
+  OP(GetTranslatedShaderSourceANGLE)                           /* 462 */ \
+  OP(PostSubBufferCHROMIUM)                                    /* 463 */ \
+  OP(TexImageIOSurface2DCHROMIUM)                              /* 464 */ \
+  OP(DrawArraysInstancedANGLE)                                 /* 465 */ \
+  OP(DrawElementsInstancedANGLE)                               /* 466 */ \
+  OP(VertexAttribDivisorANGLE)                                 /* 467 */ \
 
 enum CommandId {
   kStartPoint = cmd::kLastCommonId,  // All GLES2 commands start after this.
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
index e59d000..7a30e0c 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_autogen.h
@@ -33,6 +33,9 @@ static std::string GetStringIndexType(uint32 value);
 static std::string GetStringPixelStore(uint32 value);
 static std::string GetStringPixelType(uint32 value);
 static std::string GetStringProgramParameter(uint32 value);
+static std::string GetStringQueryObjectParameter(uint32 value);
+static std::string GetStringQueryParameter(uint32 value);
+static std::string GetStringQueryTarget(uint32 value);
 static std::string GetStringReadPixelFormat(uint32 value);
 static std::string GetStringRenderBufferFormat(uint32 value);
 static std::string GetStringRenderBufferParameter(uint32 value);
diff --git a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
index f652a3f..26e7bf8 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
+++ b/gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h
@@ -919,6 +919,33 @@ std::string GLES2Util::GetStringProgramParameter(uint32 value) {
       string_table, arraysize(string_table), value);
 }
 
+std::string GLES2Util::GetStringQueryObjectParameter(uint32 value) {
+  static EnumToString string_table[] = {
+    { GL_QUERY_RESULT_EXT, "GL_QUERY_RESULT_EXT" },
+    { GL_QUERY_RESULT_AVAILABLE_EXT, "GL_QUERY_RESULT_AVAILABLE_EXT" },
+  };
+  return GLES2Util::GetQualifiedEnumString(
+      string_table, arraysize(string_table), value);
+}
+
+std::string GLES2Util::GetStringQueryParameter(uint32 value) {
+  static EnumToString string_table[] = {
+    { GL_CURRENT_QUERY_EXT, "GL_CURRENT_QUERY_EXT" },
+  };
+  return GLES2Util::GetQualifiedEnumString(
+      string_table, arraysize(string_table), value);
+}
+
+std::string GLES2Util::GetStringQueryTarget(uint32 value) {
+  static EnumToString string_table[] = {
+    { GL_ANY_SAMPLES_PASSED_EXT, "GL_ANY_SAMPLES_PASSED_EXT" },
+    { GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
+    "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT" },
+  };
+  return GLES2Util::GetQualifiedEnumString(
+      string_table, arraysize(string_table), value);
+}
+
 std::string GLES2Util::GetStringReadPixelFormat(uint32 value) {
   static EnumToString string_table[] = {
     { GL_ALPHA, "GL_ALPHA" },
diff --git a/gpu/command_buffer/service/gl_utils.h b/gpu/command_buffer/service/gl_utils.h
index bf7f946..ce65cb2 100644
--- a/gpu/command_buffer/service/gl_utils.h
+++ b/gpu/command_buffer/service/gl_utils.h
@@ -69,6 +69,13 @@
 // GL_ANGLE_instanced_arrays
 #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE   0x88FE
 
+// GL_EXT_occlusion_query_boolean
+#define GL_ANY_SAMPLES_PASSED_EXT              0x8C2F
+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT 0x8D6A
+#define GL_CURRENT_QUERY_EXT                   0x8865
+#define GL_QUERY_RESULT_EXT                    0x8866
+#define GL_QUERY_RESULT_AVAILABLE_EXT          0x8867
+
 #define GL_GLEXT_PROTOTYPES 1
 
 // Define this for extra GL error debugging (slower).
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index 9725642..79b726d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -2607,6 +2607,55 @@ error::Error GLES2DecoderImpl::HandleTexStorage2DEXT(
   return error::kNoError;
 }
 
+error::Error GLES2DecoderImpl::HandleGenQueriesEXT(
+    uint32 immediate_data_size, const gles2::GenQueriesEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glGenQueriesEXT not implemented");
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleDeleteQueriesEXT(
+    uint32 immediate_data_size, const gles2::DeleteQueriesEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glDeleteQueriesEXT not implemented");
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleIsQueryEXT(
+    uint32 immediate_data_size, const gles2::IsQueryEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glIsQueryEXT not implemented");
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleBeginQueryEXT(
+    uint32 immediate_data_size, const gles2::BeginQueryEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT not implemented");
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleEndQueryEXT(
+    uint32 immediate_data_size, const gles2::EndQueryEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT not implemented");
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleGetQueryivEXT(
+    uint32 immediate_data_size, const gles2::GetQueryivEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glGetQueryivEXT not implemented");
+  return error::kNoError;
+}
+
+error::Error GLES2DecoderImpl::HandleGetQueryObjectuivEXT(
+    uint32 immediate_data_size, const gles2::GetQueryObjectuivEXT& c) {
+  // TODO: for now this is a no-op
+  SetGLError(GL_INVALID_OPERATION, "glGetQueryObjectuivEXT not implemented");
+  return error::kNoError;
+}
+
 error::Error GLES2DecoderImpl::HandleGetMaxValueInBufferCHROMIUM(
     uint32 immediate_data_size, const gles2::GetMaxValueInBufferCHROMIUM& c) {
   GLuint buffer_id = c.buffer_id;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
index 75db49c..ffe0dad 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h
@@ -1806,22 +1806,23 @@ TEST_F(GLES2DecoderTest2, ViewportInvalidArgs3_0) {
 // TODO(gman): BlitFramebufferEXT
 // TODO(gman): RenderbufferStorageMultisampleEXT
 // TODO(gman): TexStorage2DEXT
-// TODO(gman): SwapBuffers
-// TODO(gman): GetMaxValueInBufferCHROMIUM
-// TODO(gman): GenSharedIdsCHROMIUM
+// TODO(gman): GenQueriesEXT
+
+// TODO(gman): DeleteQueriesEXT
 
-// TODO(gman): DeleteSharedIdsCHROMIUM
+// TODO(gman): IsQueryEXT
 
-// TODO(gman): RegisterSharedIdsCHROMIUM
+// TODO(gman): BeginQueryEXT
 
-// TODO(gman): EnableFeatureCHROMIUM
+// TODO(gman): EndQueryEXT
 
-// TODO(gman): ResizeCHROMIUM
-// TODO(gman): GetRequestableExtensionsCHROMIUM
+// TODO(gman): GetQueryivEXT
 
-// TODO(gman): RequestExtensionCHROMIUM
+// TODO(gman): GetQueryObjectuivEXT
 
-// TODO(gman): GetMultipleIntegervCHROMIUM
+// TODO(gman): SwapBuffers
+// TODO(gman): GetMaxValueInBufferCHROMIUM
+// TODO(gman): GenSharedIdsCHROMIUM
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
index b26f7f1..bef7a9e 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_3_autogen.h
@@ -10,6 +10,19 @@
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_3_AUTOGEN_H_
 
+// TODO(gman): DeleteSharedIdsCHROMIUM
+
+// TODO(gman): RegisterSharedIdsCHROMIUM
+
+// TODO(gman): EnableFeatureCHROMIUM
+
+// TODO(gman): ResizeCHROMIUM
+// TODO(gman): GetRequestableExtensionsCHROMIUM
+
+// TODO(gman): RequestExtensionCHROMIUM
+
+// TODO(gman): GetMultipleIntegervCHROMIUM
+
 // TODO(gman): GetProgramInfoCHROMIUM
 
 // TODO(gman): CreateStreamTextureCHROMIUM
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
index 250fbbd..34ebb6f 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_autogen.h
@@ -35,6 +35,9 @@ ValueValidator<GLenum> pixel_store;
 ValueValidator<GLint> pixel_store_alignment;
 ValueValidator<GLenum> pixel_type;
 ValueValidator<GLenum> program_parameter;
+ValueValidator<GLenum> query_object_parameter;
+ValueValidator<GLenum> query_parameter;
+ValueValidator<GLenum> query_target;
 ValueValidator<GLenum> read_pixel_format;
 ValueValidator<GLenum> render_buffer_format;
 ValueValidator<GLenum> render_buffer_parameter;
diff --git a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
index d78cfde..8574e53 100644
--- a/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_validation_implementation_autogen.h
@@ -267,6 +267,20 @@ static GLenum valid_program_parameter_table[] = {
   GL_ACTIVE_UNIFORM_MAX_LENGTH,
 };
 
+static GLenum valid_query_object_parameter_table[] = {
+  GL_QUERY_RESULT_EXT,
+  GL_QUERY_RESULT_AVAILABLE_EXT,
+};
+
+static GLenum valid_query_parameter_table[] = {
+  GL_CURRENT_QUERY_EXT,
+};
+
+static GLenum valid_query_target_table[] = {
+  GL_ANY_SAMPLES_PASSED_EXT,
+  GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
+};
+
 static GLenum valid_read_pixel_format_table[] = {
   GL_ALPHA,
   GL_RGB,
@@ -528,6 +542,13 @@ Validators::Validators()
       program_parameter(
           valid_program_parameter_table, arraysize(
               valid_program_parameter_table)),
+      query_object_parameter(
+          valid_query_object_parameter_table, arraysize(
+              valid_query_object_parameter_table)),
+      query_parameter(
+          valid_query_parameter_table, arraysize(valid_query_parameter_table)),
+      query_target(
+          valid_query_target_table, arraysize(valid_query_target_table)),
       read_pixel_format(
           valid_read_pixel_format_table, arraysize(
               valid_read_pixel_format_table)),