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"
 
@@ skipping 521 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;
+  }
+
+  auto get_binding_client_id = [this](

[piman, 2016/11/17 21:08:52]

nit: this could be a regular template member function, doesn't need to be a
lambda, I think.

[Geoff Lang, 2016/11/17 22:01:15]

Done, added a helper.

+      const ClientServiceMap<GLuint, GLuint>* map, T service_id, T* result) {
+    GLuint client_id = 0;
+    if (!map->GetClientID(static_cast<GLuint>(service_id), &client_id)) {
+      return false;
+    }
+    *result = static_cast<T>(client_id);
+    return true;
+  };
+
+  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 (!get_binding_client_id(&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 (!get_binding_client_id(&resources_->buffer_id_map, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_RENDERBUFFER_BINDING:
+      if (!get_binding_client_id(&resources_->renderbuffer_id_map, *params,
+                                 params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_SAMPLER_BINDING:
+      if (!get_binding_client_id(&resources_->sampler_id_map, *params,
+                                 params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_ACTIVE_PROGRAM:
+      if (!get_binding_client_id(&resources_->program_id_map, *params,
+                                 params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_FRAMEBUFFER_BINDING:
+    case GL_READ_FRAMEBUFFER_BINDING:
+      if (!get_binding_client_id(&framebuffer_id_map_, *params, params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_TRANSFORM_FEEDBACK_BINDING:
+      if (!get_binding_client_id(&transform_feedback_id_map_, *params,
+                                 params)) {
+        return error::kInvalidArguments;
+      }
+      break;
+
+    case GL_VERTEX_ARRAY_BINDING:
+      if (!get_binding_client_id(&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: {
+          GLuint client_id = 0;
+          if (!resources_->texture_id_map.GetClientID(*params, &client_id)) {
+            return error::kInvalidArguments;
+          }
+          *params = static_cast<GLint>(client_id);
+        } break;
+
+        case GL_RENDERBUFFER: {
+          GLuint client_id = 0;
+          if (!resources_->renderbuffer_id_map.GetClientID(*params,
+                                                           &client_id)) {
+            return error::kInvalidArguments;
+          }
+          *params = static_cast<GLint>(client_id);
+        } 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