Implement basic query functionality in the passthrough command buffer.

gpu/command_buffer/service/gles2_cmd_decoder_passthrough_doers.cc

 // Copyright (c) 2016 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/gles2_cmd_decoder_passthrough.h"
 
 #include "base/strings/string_number_conversions.h"
 
 namespace gpu {
 namespace gles2 {
@@ skipping 678 matching lines @@
 
 error::Error GLES2DecoderPassthroughImpl::DoFenceSync(GLenum condition,
                                                       GLbitfield flags,
                                                       GLuint client_id) {
   NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFinish() {
   glFinish();
-  return error::kNoError;
+  return ProcessQueries(true);
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFlush() {
   glFlush();
-  return error::kNoError;
+  return ProcessQueries(false);
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFlushMappedBufferRange(
     GLenum target,
     GLintptr offset,
     GLsizeiptr size) {
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFramebufferRenderbuffer(
@@ skipping 181 matching lines @@
     GLenum target,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint* params) {
   glGetBufferParameterivRobustANGLE(target, pname, bufsize, length, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetError(uint32_t* result) {
-  *result = glGetError();
+  FlushErrors();
+  *result = PopError();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetFloatv(GLenum pname,
                                                       GLsizei bufsize,
                                                       GLsizei* length,
                                                       GLfloat* params) {
   glGetFloatvRobustANGLE(pname, bufsize, length, params);
   return error::kNoError;
 }
@@ skipping 1215 matching lines @@
     GLsizei n,
     volatile GLuint* queries) {
   return GenHelper(n, queries, &query_id_map_, [](GLsizei n, GLuint* queries) {
     glGenQueries(n, queries);
   });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteQueriesEXT(
     GLsizei n,
     const volatile GLuint* queries) {
+  std::vector<GLuint> queries_copy(queries, queries + n);
+  // If any of these queries are pending or active, remove them from the lists
+  for (GLuint query_client_id : queries_copy) {
+    GLuint query_service_id = 0;
+    if (!query_id_map_.GetServiceID(query_client_id, &query_service_id) ||
+        query_service_id == 0) {
+      continue;
+    }
+
+    QueryInfo query_info = query_info_map_[query_service_id];
+    query_info_map_.erase(query_service_id);
+
+    if (query_info.type == GL_NONE) {
+      // Query was never started
+      continue;
+    }
+
+    auto active_queries_iter = active_queries_.find(query_info.type);
+    if (active_queries_iter != active_queries_.end()) {
+      active_queries_.erase(active_queries_iter);
+    }
+
+    auto pending_iter =
+        std::find_if(pending_queries_.begin(), pending_queries_.end(),
+                     [query_service_id](const PendingQuery& pending_query) {
+                       return pending_query.service_id == query_service_id;
+                     });
+    if (pending_iter != pending_queries_.end()) {
+      pending_queries_.erase(pending_iter);
+    }
+  }
   return DeleteHelper(
-      n, queries, &query_id_map_,
+      queries_copy.size(), queries_copy.data(), &query_id_map_,
       [](GLsizei n, GLuint* queries) { glDeleteQueries(n, queries); });
 }
 
-error::Error GLES2DecoderPassthroughImpl::DoQueryCounterEXT(GLuint id,
-                                                            GLenum target) {
-  glQueryCounter(GetQueryServiceID(id, &query_id_map_), target);
+error::Error GLES2DecoderPassthroughImpl::DoQueryCounterEXT(
+    GLuint id,
+    GLenum target,
+    int32_t sync_shm_id,
+    uint32_t sync_shm_offset,
+    uint32_t submit_count) {
+  GLuint service_id = GetQueryServiceID(id, &query_id_map_);
+
+  // Flush all previous errors
+  FlushErrors();
+
+  glQueryCounter(service_id, target);
+
+  // Check if a new error was generated
+  if (FlushErrors()) {
+    return error::kNoError;
+  }
+
+  QueryInfo* query_info = &query_info_map_[service_id];
+  query_info->type = target;
+
+  PendingQuery pending_query;
+  pending_query.target = target;
+  pending_query.service_id = service_id;
+  pending_query.shm_id = sync_shm_id;
+  pending_query.shm_offset = sync_shm_offset;
+  pending_query.submit_count = submit_count;
+  pending_queries_.push_back(pending_query);
+
+  return ProcessQueries(false);
+}
+
+error::Error GLES2DecoderPassthroughImpl::DoBeginQueryEXT(
+    GLenum target,
+    GLuint id,
+    int32_t sync_shm_id,
+    uint32_t sync_shm_offset) {
+  GLuint service_id = GetQueryServiceID(id, &query_id_map_);
+  QueryInfo* query_info = &query_info_map_[service_id];
+
+  if (IsEmulatedQueryTarget(target)) {
+    if (active_queries_.find(target) != active_queries_.end()) {
+      InsertError(GL_INVALID_OPERATION, "Query already active on target.");
+      return error::kNoError;
+    }
+
+    if (id == 0) {
+      InsertError(GL_INVALID_OPERATION, "Query id is 0.");
+      return error::kNoError;
+    }
+
+    if (query_info->type != GL_NONE && query_info->type != target) {
+      InsertError(GL_INVALID_OPERATION,
+                  "Query type does not match the target.");
+      return error::kNoError;
+    }
+  } else {
+    // Flush all previous errors
+    FlushErrors();
+
+    glBeginQuery(target, service_id);
+
+    // Check if a new error was generated
+    if (FlushErrors()) {
+      return error::kNoError;
+    }
+  }
+
+  query_info->type = target;
+
+  ActiveQuery query;
+  query.service_id = service_id;
+  query.shm_id = sync_shm_id;
+  query.shm_offset = sync_shm_offset;
+  active_queries_[target] = query;
+
   return error::kNoError;
 }
 
-error::Error GLES2DecoderPassthroughImpl::DoBeginQueryEXT(GLenum target,
-                                                          GLuint id) {
-  // TODO(geofflang): Track active queries
-  glBeginQuery(target, GetQueryServiceID(id, &query_id_map_));
-  return error::kNoError;
-}
-
 error::Error GLES2DecoderPassthroughImpl::DoBeginTransformFeedback(
     GLenum primitivemode) {
   glBeginTransformFeedback(primitivemode);
   return error::kNoError;
 }
 
-error::Error GLES2DecoderPassthroughImpl::DoEndQueryEXT(GLenum target) {
-  // TODO(geofflang): Track active queries
-  glEndQuery(target);
-  return error::kNoError;
+error::Error GLES2DecoderPassthroughImpl::DoEndQueryEXT(GLenum target,
+                                                        uint32_t submit_count) {
+  if (IsEmulatedQueryTarget(target)) {
+    if (active_queries_.find(target) == active_queries_.end()) {
+      InsertError(GL_INVALID_OPERATION, "No active query on target.");
+      return error::kNoError;
+    }
+  } else {
+    // Flush all previous errors
+    FlushErrors();
+
+    glEndQuery(target);
+
+    // Check if a new error was generated
+    if (FlushErrors()) {
+      return error::kNoError;
+    }
+  }
+
+  DCHECK(active_queries_.find(target) != active_queries_.end());
+  ActiveQuery active_query = active_queries_[target];
+  active_queries_.erase(target);
+
+  PendingQuery pending_query;
+  pending_query.target = target;
+  pending_query.service_id = active_query.service_id;
+  pending_query.shm_id = active_query.shm_id;
+  pending_query.shm_offset = active_query.shm_offset;
+  pending_query.submit_count = submit_count;
+  pending_queries_.push_back(pending_query);
+
+  return ProcessQueries(false);
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoEndTransformFeedback() {
   glEndTransformFeedback();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSetDisjointValueSyncCHROMIUM(
     DisjointValueSync* sync) {
   NOTIMPLEMENTED();
@@ skipping 850 matching lines @@
 GLES2DecoderPassthroughImpl::DoUniformMatrix4fvStreamTextureMatrixCHROMIUM(
     GLint location,
     GLboolean transpose,
     const volatile GLfloat* defaultValue) {
   NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 }  // namespace gles2
 }  // namespace gpu