Implement most of the remaining entry points in the passthrough cmd decoder.

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"
 #include "ui/gl/gl_version_info.h"
 
 namespace gpu {
@@ skipping 997 matching lines @@
     GLint* params) {
   glGetActiveUniformBlockivRobustANGLE(GetProgramServiceID(program, resources_),
                                        index, pname, bufSize, length, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveUniformBlockName(
     GLuint program,
     GLuint index,
     std::string* name) {
-  NOTIMPLEMENTED();
+  FlushErrors();
+
+  GLuint program_service_id = GetProgramServiceID(program, resources_);
+  GLint max_name_length = 0;
+  glGetProgramiv(program_service_id, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH,
+                 &max_name_length);
+
+  if (FlushErrors()) {
+    return error::kNoError;
+  }
+
+  std::vector<GLchar> buffer(max_name_length, 0);
+  GLsizei length = 0;
+  glGetActiveUniformBlockName(program_service_id, index, max_name_length,
+                              &length, buffer.data());
+  DCHECK(length <= max_name_length);
+  *name = length > 0 ? std::string(buffer.data(), length) : std::string();
+
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveUniformsiv(
     GLuint program,
     GLsizei count,
     const GLuint* indices,
     GLenum pname,
-    GLsizei bufSize,
-    GLsizei* length,
     GLint* params) {
-  NOTIMPLEMENTED();
+  glGetActiveUniformsiv(GetProgramServiceID(program, resources_), count,
+                        indices, pname, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetAttachedShaders(
     GLuint program,
     GLsizei maxcount,
     GLsizei* count,
     GLuint* shaders) {
-  NOTIMPLEMENTED();
+  glGetAttachedShaders(GetProgramServiceID(program, resources_), maxcount,
+                       count, shaders);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetAttribLocation(GLuint program,
                                                               const char* name,
                                                               GLint* result) {
   *result = glGetAttribLocation(GetProgramServiceID(program, resources_), name);
   return error::kNoError;
 }
 
@@ skipping 157 matching lines @@
                                                          GLsizei* length,
                                                          GLint* params) {
   glGetProgramivRobustANGLE(GetProgramServiceID(program, resources_), pname,
                             bufsize, length, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetProgramInfoLog(
     GLuint program,
     std::string* infolog) {
+  FlushErrors();
   GLint info_log_len = 0;
   glGetProgramiv(GetProgramServiceID(program, resources_), GL_INFO_LOG_LENGTH,
                  &info_log_len);
 
+  if (FlushErrors()) {
+    return error::kNoError;
+  }
+
   std::vector<char> buffer(info_log_len, 0);
+  GLsizei length = 0;
   glGetProgramInfoLog(GetProgramServiceID(program, resources_), info_log_len,
-                      nullptr, buffer.data());
-  *infolog = info_log_len > 0 ? std::string(buffer.data()) : std::string();
+                      &length, buffer.data());
+  DCHECK(length <= info_log_len);
+  *infolog = length > 0 ? std::string(buffer.data(), length) : std::string();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetRenderbufferParameteriv(
     GLenum target,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint* params) {
   glGetRenderbufferParameterivRobustANGLE(target, pname, bufsize, length,
@@ skipping 28 matching lines @@
                                                         GLsizei* length,
                                                         GLint* params) {
   glGetShaderivRobustANGLE(GetShaderServiceID(shader, resources_), pname,
                            bufsize, length, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderInfoLog(
     GLuint shader,
     std::string* infolog) {
+  FlushErrors();
+
   GLuint service_id = GetShaderServiceID(shader, resources_);
   GLint info_log_len = 0;
   glGetShaderiv(service_id, GL_INFO_LOG_LENGTH, &info_log_len);
+  if (FlushErrors()) {
+    return error::kNoError;
+  }
+
   std::vector<char> buffer(info_log_len, 0);
-  glGetShaderInfoLog(service_id, info_log_len, nullptr, buffer.data());
-  *infolog = info_log_len > 0 ? std::string(buffer.data()) : std::string();
+  GLsizei length = 0;
+  glGetShaderInfoLog(service_id, info_log_len, &length, buffer.data());
+  DCHECK(length <= info_log_len);
+  *infolog = length > 0 ? std::string(buffer.data(), length) : std::string();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderPrecisionFormat(
     GLenum shadertype,
     GLenum precisiontype,
     GLint* range,
     GLint* precision,
     int32_t* success) {
   FlushErrors();
   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
   *success = FlushErrors() ? 0 : 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderSource(
     GLuint shader,
     std::string* source) {
-  NOTIMPLEMENTED();
+  FlushErrors();
+
+  GLuint shader_service_id = GetShaderServiceID(shader, resources_);
+  GLint shader_source_length = 0;
+  glGetShaderiv(shader_service_id, GL_SHADER_SOURCE_LENGTH,
+                &shader_source_length);
+  if (FlushErrors()) {
+    return error::kNoError;
+  }
+
+  std::vector<char> buffer(shader_source_length, 0);
+  GLsizei length = 0;
+  glGetShaderSource(shader_service_id, shader_source_length, &length,
+                    buffer.data());
+  DCHECK(length <= shader_source_length);
+  *source = shader_source_length > 0 ? std::string(buffer.data(), length)
+                                     : std::string();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetString(GLenum name,
                                                       const char** result) {
   switch (name) {
     case GL_VERSION:
       *result = GetServiceVersionString(feature_info_.get());
       break;
     case GL_SHADING_LANGUAGE_VERSION:
@@ skipping 61 matching lines @@
                                 size, type, name_buffer.data());
   *name = std::string(name_buffer.data());
   *success = FlushErrors() ? 0 : 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformBlockIndex(
     GLuint program,
     const char* name,
     GLint* index) {
-  NOTIMPLEMENTED();
+  *index =
+      glGetUniformBlockIndex(GetProgramServiceID(program, resources_), name);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformfv(GLuint program,
                                                          GLint location,
                                                          GLsizei bufsize,
                                                          GLsizei* length,
                                                          GLfloat* params) {
   // GetUniform*RobustANGLE entry points expect bufsize in bytes like the entry
   // points in GL_EXT_robustness
@@ skipping 24 matching lines @@
   glGetUniformuivRobustANGLE(GetProgramServiceID(program, resources_), location,
                              bufsize * sizeof(*params), length, params);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformIndices(
     GLuint program,
     GLsizei count,
     const char* const* names,
     GLsizei bufSize,
-    GLsizei* length,
     GLuint* indices) {
-  NOTIMPLEMENTED();
+  glGetUniformIndices(GetProgramServiceID(program, resources_), count, names,
+                      indices);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformLocation(
     GLuint program,
     const char* name,
     GLint* location) {
   *location =
       glGetUniformLocation(GetProgramServiceID(program, resources_), name);
   return error::kNoError;
@@ skipping 91 matching lines @@
     return error::kNoError;
   }
   std::vector<GLenum> attachments_copy(attachments, attachments + count);
   glInvalidateSubFramebuffer(target, count, attachments_copy.data(), x, y,
                              width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsBuffer(GLuint buffer,
                                                      uint32_t* result) {
-  NOTIMPLEMENTED();
   *result = glIsBuffer(GetBufferServiceID(buffer, resources_, false));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsEnabled(GLenum cap,
                                                       uint32_t* result) {
   *result = glIsEnabled(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsFramebuffer(GLuint framebuffer,
                                                           uint32_t* result) {
   *result = glIsFramebufferEXT(
       GetFramebufferServiceID(framebuffer, &framebuffer_id_map_, false));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsProgram(GLuint program,
                                                       uint32_t* result) {
   *result = glIsProgram(GetProgramServiceID(program, resources_));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsRenderbuffer(GLuint renderbuffer,
                                                            uint32_t* result) {
-  NOTIMPLEMENTED();
   *result = glIsRenderbufferEXT(
       GetRenderbufferServiceID(renderbuffer, resources_, false));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsSampler(GLuint sampler,
                                                       uint32_t* result) {
   *result = glIsSampler(GetSamplerServiceID(sampler, resources_));
   return error::kNoError;
 }
@@ skipping 140 matching lines @@
                                                     GLsizei height) {
   glScissor(x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoShaderBinary(GLsizei n,
                                                          const GLuint* shaders,
                                                          GLenum binaryformat,
                                                          const void* binary,
                                                          GLsizei length) {
-  NOTIMPLEMENTED();
+  std::vector<GLuint> service_shaders(n, 0);
+  for (GLsizei i = 0; i < n; i++) {
+    service_shaders[i] = GetShaderServiceID(shaders[i], resources_);
+  }
+  glShaderBinary(n, service_shaders.data(), binaryformat, binary, length);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoShaderSource(GLuint shader,
                                                          GLsizei count,
                                                          const char** string,
                                                          const GLint* length) {
   glShaderSource(GetShaderServiceID(shader, resources_), count, string, length);
   return error::kNoError;
 }
@@ skipping 637 matching lines @@
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFramebufferTexture2DMultisampleEXT(
     GLenum target,
     GLenum attachment,
     GLenum textarget,
     GLuint texture,
     GLint level,
     GLsizei samples) {
-  NOTIMPLEMENTED();
+  glFramebufferTexture2DMultisampleEXT(
+      target, attachment, textarget,
+      GetTextureServiceID(texture, resources_, false), level, samples);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexStorage2DEXT(
     GLenum target,
     GLsizei levels,
     GLenum internalFormat,
     GLsizei width,
     GLsizei height) {
   glTexStorage2DEXT(target, levels, internalFormat, width, height);
@@ skipping 1514 matching lines @@
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSetEnableDCLayersCHROMIUM(
     GLboolean enable) {
   NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 }  // namespace gles2
 }  // namespace gpu