Add support for GL_COMMANDS_ISSUED_CHROMIUM fence like query.

gpu/command_buffer/service/gles2_cmd_decoder.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/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 2004 matching lines @@
     Destroy();
     return false;
   }
 
   CHECK_GL_ERROR();
   disallowed_features_ = disallowed_features;
 
   vertex_attrib_manager_.reset(new VertexAttribManager());
   vertex_attrib_manager_->Initialize(group_->max_vertex_attribs());
 
-  query_manager_.reset(new QueryManager());
+  query_manager_.reset(new QueryManager(this));
 
   util_.set_num_compressed_texture_formats(
       validators_->compressed_texture_format.GetValues().size());
 
   if (gfx::GetGLImplementation() != gfx::kGLImplementationEGLGLES2) {
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
@@ skipping 1117 matching lines @@
   }
   GLuint service_id = glCreateShader(type);
   if (service_id != 0) {
     CreateShaderInfo(client_id, service_id, type);
   }
   return true;
 }
 
 void GLES2DecoderImpl::DoFinish() {
   glFinish();
-  if (!query_manager_->ProcessPendingQueries(this)) {
+  if (!query_manager_->ProcessPendingQueries()) {
     current_decoder_error_ = error::kOutOfBounds;
   }
 }
 
 void GLES2DecoderImpl::DoFlush() {
   glFlush();
-  if (!query_manager_->ProcessPendingQueries(this)) {
+  if (!query_manager_->ProcessPendingQueries()) {
     current_decoder_error_ = error::kOutOfBounds;
   }
 }
 
 void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
   GLuint texture_index = texture_unit - GL_TEXTURE0;
   if (texture_index >= group_->max_texture_units()) {
     SetGLError(GL_INVALID_ENUM, "glActiveTexture: texture_unit out of range.");
     return;
   }
@@ skipping 2044 matching lines @@
     bool simulated_fixed_attribs = false;
     if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs,
                              primcount)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
       ApplyDirtyState();
       if (!instanced) {
         glDrawArrays(mode, first, count);
       } else {
         glDrawArraysInstancedANGLE(mode, first, count, primcount);
       }
-      if (!query_manager_->ProcessPendingQueries(this)) {
+      if (!query_manager_->ProcessPendingQueries()) {
         current_decoder_error_ = error::kOutOfBounds;
       }
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
@@ skipping 92 matching lines @@
     if (SimulateFixedAttribs(max_vertex_accessed, &simulated_fixed_attribs,
                              primcount)) {
       bool textures_set = SetBlackTextureForNonRenderableTextures();
       ApplyDirtyState();
       const GLvoid* indices = reinterpret_cast<const GLvoid*>(offset);
       if (!instanced) {
         glDrawElements(mode, count, type, indices);
       } else {
         glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
       }
-      if (!query_manager_->ProcessPendingQueries(this)) {
+      if (!query_manager_->ProcessPendingQueries()) {
         current_decoder_error_ = error::kOutOfBounds;
       }
       if (textures_set) {
         RestoreStateForNonRenderableTextures();
       }
       if (simulated_fixed_attribs) {
         RestoreStateForSimulatedFixedAttribs();
       }
     }
     if (simulated_attrib_0) {
@@ skipping 2572 matching lines @@
   return false;
 }
 
 bool GLES2DecoderImpl::GenQueriesEXTHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (query_manager_->GetQuery(client_ids[ii])) {
       return false;
     }
   }
-  scoped_array<GLuint> service_ids(new GLuint[n]);
-  glGenQueriesARB(n, service_ids.get());
-  for (GLsizei ii = 0; ii < n; ++ii) {
-    query_manager_->CreateQuery(client_ids[ii], service_ids[ii]);
-  }
+  // NOTE: We don't generate Query objects here. Only in BeginQueryEXT
   return true;
 }
 
 void GLES2DecoderImpl::DeleteQueriesEXTHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     QueryManager::Query* query = query_manager_->GetQuery(client_ids[ii]);
     if (query && !query->IsDeleted()) {
       if (query == current_query_) {
         current_query_ = NULL;
       }
-      GLuint service_id = query->service_id();
-      glDeleteQueriesARB(1, &service_id);
+      query->Destroy(true);
       query_manager_->RemoveQuery(client_ids[ii]);
     }
   }
 }
 
 error::Error GLES2DecoderImpl::HandleBeginQueryEXT(
     uint32 immediate_data_size, const gles2::BeginQueryEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLuint client_id = static_cast<GLuint>(c.id);
   int32 sync_shm_id = static_cast<int32>(c.sync_data_shm_id);
   uint32 sync_shm_offset = static_cast<uint32>(c.sync_data_shm_offset);
 
-  if (!feature_info_->feature_flags().occlusion_query_boolean) {
-    SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: not enabled");
-    return error::kNoError;
+  switch (target) {
+    case GL_COMMANDS_ISSUED_CHROMIUM:
+      break;
+    default:
+      if (!feature_info_->feature_flags().occlusion_query_boolean) {
+        SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: not enabled");
+        return error::kNoError;
+      }
+      break;
   }
 
   if (current_query_) {
     SetGLError(
         GL_INVALID_OPERATION, "glBeginQueryEXT: query already in progress");
     return error::kNoError;
   }
 
   if (client_id == 0) {
     SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: id is 0");
     return error::kNoError;
   }
 
   QueryManager::Query* query = query_manager_->GetQuery(client_id);
   if (!query) {
     // Checks id was made by glGenQueries
     IdAllocatorInterface* id_allocator =
         group_->GetIdAllocator(id_namespaces::kQueries);
     if (!id_allocator->InUse(client_id)) {
       SetGLError(GL_INVALID_OPERATION,
                  "glBeginQueryEXT: id not made by glGenQueriesEXT");
       return error::kNoError;
     }
-    // Makes object and assoicates with memory.
-    GLuint service_id = 0;
-    glGenQueriesARB(1, &service_id);
-    DCHECK_NE(0u, service_id);
-    query = query_manager_->CreateQuery(client_id, service_id);
+
+    query = query_manager_->CreateQuery(
+        target, client_id, sync_shm_id, sync_shm_offset);
   }
 
-  QuerySync* sync = GetSharedMemoryAs<QuerySync*>(
-      sync_shm_id, sync_shm_offset, sizeof(*sync));
-  if (!sync) {
-    DLOG(ERROR) << "Invalid shared memory referenced by query";
-    return error::kOutOfBounds;
-  }
-
-  if (!query->IsInitialized()) {
-    query->Initialize(target, sync_shm_id, sync_shm_offset);
-  } else if (query->target() != target) {
+  if (query->target() != target) {
     SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT: target does not match");
     return error::kNoError;
   } else if (query->shm_id() != sync_shm_id ||
              query->shm_offset() != sync_shm_offset) {
     DLOG(ERROR) << "Shared memory used by query not the same as before";
     return error::kInvalidArguments;
   }
 
-  query_manager_->RemovePendingQuery(query);
+  if (!query_manager_->BeginQuery(query)) {
+    return error::kOutOfBounds;
+  }
 
-  glBeginQueryARB(target, query->service_id());
   current_query_ = query;
-
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEndQueryEXT(
     uint32 immediate_data_size, const gles2::EndQueryEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 submit_count = static_cast<GLuint>(c.submit_count);
 
   if (!current_query_) {
     SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT: No active query");
     return error::kNoError;
   }
   if (current_query_->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glEndQueryEXT: target does not match active query");
     return error::kNoError;
   }
-  glEndQueryARB(target);
-  query_manager_->AddPendingQuery(current_query_, submit_count);
+
+  if (!query_manager_->EndQuery(current_query_, submit_count)) {
+    return error::kOutOfBounds;
+  }
+
   current_query_ = NULL;
-
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCreateStreamTextureCHROMIUM(
     uint32 immediate_data_size,
     const gles2::CreateStreamTextureCHROMIUM& c) {
   if (!feature_info_->feature_flags().chromium_stream_texture) {
     SetGLError(GL_INVALID_OPERATION,
                "glOpenStreamTextureCHROMIUM: "
                "not supported.");
@@ skipping 309 matching lines @@
   }
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu