Patch the results of queries that return object IDs in the passthrough cmd decoder.

gpu/command_buffer/service/gles2_cmd_decoder_passthrough.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 "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace gpu {
 namespace gles2 {
 
 namespace {
 template <typename ClientType, typename ServiceType, typename DeleteFunction>
 void DeleteServiceObjects(ClientServiceMap<ClientType, ServiceType>* id_map,
                           bool have_context,
                           DeleteFunction delete_function) {
   if (have_context) {
     for (auto client_service_id_pair : *id_map) {
       delete_function(client_service_id_pair.second);
     }
   }
 
   id_map->Clear();
 }
 
+template <typename ClientType, typename ServiceType, typename ResultType>
+bool GetClientID(const ClientServiceMap<ClientType, ServiceType>* map,
+                 ResultType service_id,
+                 ResultType* result) {
+  ClientType client_id = 0;
+  if (!map->GetClientID(static_cast<ServiceType>(service_id), &client_id)) {
+    return false;
+  }
+  *result = static_cast<ResultType>(client_id);
+  return true;
+};
+
 }  // anonymous namespace
 
 PassthroughResources::PassthroughResources() {}
 
 PassthroughResources::~PassthroughResources() {}
 
 void PassthroughResources::Destroy(bool have_context) {
   DeleteServiceObjects(&texture_id_map, have_context,
                        [](GLuint texture) { glDeleteTextures(1, &texture); });
   DeleteServiceObjects(&buffer_id_map, have_context,
@@ skipping 494 matching lines @@
 
 const gpu::gles2::ContextState* GLES2DecoderPassthroughImpl::GetContextState() {
   return nullptr;
 }
 
 scoped_refptr<ShaderTranslatorInterface>
 GLES2DecoderPassthroughImpl::GetTranslator(GLenum type) {
   return nullptr;
 }
 
+void* GLES2DecoderPassthroughImpl::GetScratchMemory(size_t size) {
+  if (scratch_memory_.size() < size) {
+    scratch_memory_.resize(size, 0);
+  }
+  return scratch_memory_.data();
+}
+
+template <typename T>
+error::Error GLES2DecoderPassthroughImpl::PatchGetNumericResults(GLenum pname,
+                                                                 GLsizei length,
+                                                                 T* params) {
+  // Likely a gl error if no parameters were returned
+  if (length < 1) {
+    return error::kNoError;
+  }
+
+  switch (pname) {
+    case GL_NUM_EXTENSIONS:
+      *params = *params + static_cast<T>(emulated_extensions_.size());
+      break;
+
+    case GL_TEXTURE_BINDING_2D:
+    case GL_TEXTURE_BINDING_CUBE_MAP:
+    case GL_TEXTURE_BINDING_2D_ARRAY:
+    case GL_TEXTURE_BINDING_3D:
+      if (!GetClientID(&resources_->texture_id_map, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_ARRAY_BUFFER_BINDING:
+    case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+    case GL_PIXEL_PACK_BUFFER_BINDING:
+    case GL_PIXEL_UNPACK_BUFFER_BINDING:
+    case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
+    case GL_COPY_READ_BUFFER_BINDING:
+    case GL_COPY_WRITE_BUFFER_BINDING:
+    case GL_UNIFORM_BUFFER_BINDING:
+      if (!GetClientID(&resources_->buffer_id_map, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_RENDERBUFFER_BINDING:
+      if (!GetClientID(&resources_->renderbuffer_id_map, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_SAMPLER_BINDING:
+      if (!GetClientID(&resources_->sampler_id_map, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_ACTIVE_PROGRAM:
+      if (!GetClientID(&resources_->program_id_map, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_FRAMEBUFFER_BINDING:
+    case GL_READ_FRAMEBUFFER_BINDING:
+      if (!GetClientID(&framebuffer_id_map_, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_TRANSFORM_FEEDBACK_BINDING:
+      if (!GetClientID(&transform_feedback_id_map_, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_VERTEX_ARRAY_BINDING:
+      if (!GetClientID(&vertex_array_id_map_, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  return error::kNoError;
+}
+
+// Instantiate templated functions
+#define INSTANTIATE_PATCH_NUMERIC_RESULTS(type)                              \
+  template error::Error GLES2DecoderPassthroughImpl::PatchGetNumericResults( \
+      GLenum, GLsizei, type*)
+INSTANTIATE_PATCH_NUMERIC_RESULTS(GLint);
+INSTANTIATE_PATCH_NUMERIC_RESULTS(GLint64);
+INSTANTIATE_PATCH_NUMERIC_RESULTS(GLfloat);
+INSTANTIATE_PATCH_NUMERIC_RESULTS(GLboolean);
+#undef INSTANTIATE_PATCH_NUMERIC_RESULTS
+
+error::Error
+GLES2DecoderPassthroughImpl::PatchGetFramebufferAttachmentParameter(
+    GLenum target,
+    GLenum attachment,
+    GLenum pname,
+    GLsizei length,
+    GLint* params) {
+  // Likely a gl error if no parameters were returned
+  if (length < 1) {
+    return error::kNoError;
+  }
+
+  switch (pname) {
+    // If the attached object name was requested, it needs to be converted back
+    // to a client id.
+    case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME: {
+      GLint object_type = GL_NONE;
+      glGetFramebufferAttachmentParameterivEXT(
+          target, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE,
+          &object_type);
+
+      switch (object_type) {
+        case GL_TEXTURE:
+          if (!GetClientID(&resources_->texture_id_map, *params, params)) {
+            return error::kInvalidArguments;
+          }
+          break;
+
+        case GL_RENDERBUFFER:
+          if (!GetClientID(&resources_->renderbuffer_id_map, *params, params)) {
+            return error::kInvalidArguments;
+          }
+          break;
+
+        case GL_NONE:
+          // Default framebuffer, don't transform the result
+          break;
+
+        default:
+          NOTREACHED();
+          break;
+      }
+    } break;
+
+    default:
+      break;
+  }
+
+  return error::kNoError;
+}
+
 void GLES2DecoderPassthroughImpl::BuildExtensionsString() {
   std::ostringstream combined_string_stream;
   combined_string_stream << reinterpret_cast<const char*>(
                                 glGetString(GL_EXTENSIONS))
                          << " ";
   std::copy(emulated_extensions_.begin(), emulated_extensions_.end(),
             std::ostream_iterator<std::string>(combined_string_stream, " "));
   extension_string_ = combined_string_stream.str();
 }
 
 #define GLES2_CMD_OP(name)                                               \
   {                                                                      \
       &GLES2DecoderPassthroughImpl::Handle##name, cmds::name::kArgFlags, \
       cmds::name::cmd_flags,                                             \
       sizeof(cmds::name) / sizeof(CommandBufferEntry) - 1,               \
   }, /* NOLINT */
 
 const GLES2DecoderPassthroughImpl::CommandInfo
     GLES2DecoderPassthroughImpl::command_info[] = {
         GLES2_COMMAND_LIST(GLES2_CMD_OP)};
 
 #undef GLES2_CMD_OP
 
 }  // namespace gles2
 }  // namespace gpu