Add basic GL functionality to 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 {
 
+namespace {
+
+template <typename ClientType, typename ServiceType, typename GenFunction>
+error::Error GenHelper(GLsizei n,
+                       const volatile ClientType* client_ids,
+                       ClientServiceMap<ClientType, ServiceType>* id_map,
+                       GenFunction gen_function) {
+  std::vector<ServiceType> service_ids(n, 0);
+  gen_function(n, service_ids.data());
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    ClientType client_id = client_ids[ii];
+    if (id_map->GetServiceID(client_ids[ii], nullptr)) {

[piman, 2016/09/13 01:07:32]

use client_id instead of client_ids[ii], to avoid a double-read.

[Geoff Lang, 2016/09/13 17:49:57]

Done.

+      return error::kInvalidArguments;

[piman, 2016/09/13 01:07:32]

Should we delete the service_ids created on l.20?
Should we clean up the mappings that were created in previous iterations of the
loop?

[Geoff Lang, 2016/09/13 17:49:57]

I grouped the error check in with the ID binding to avoid copying the whole list
of client ids but it looks like it only complicates things.  Updated to make a
copy, perform the error check and then gen the service ids.

+    }
+    id_map->SetIDMapping(client_id, service_ids[ii]);
+  }
+
+  return error::kNoError;
+}
+
+template <typename ClientType, typename ServiceType, typename GenFunction>
+error::Error CreateHelper(ClientType client_id,
+                          ClientServiceMap<ClientType, ServiceType>* id_map,
+                          GenFunction create_function) {
+  if (id_map->GetServiceID(client_id, nullptr)) {
+    return error::kInvalidArguments;
+  }
+  ServiceType service_id = create_function();
+  id_map->SetIDMapping(client_id, service_id);
+  return error::kNoError;
+}
+
+template <typename ClientType, typename ServiceType, typename DeleteFunction>
+error::Error DeleteHelper(GLsizei n,
+                          const volatile ClientType* client_ids,
+                          ClientServiceMap<ClientType, ServiceType>* id_map,
+                          DeleteFunction delete_function) {
+  std::vector<ServiceType> service_ids(n, 0);
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    ClientType client_id = client_ids[ii];
+    service_ids[ii] = id_map->GetServiceIDOrReserve(client_id);
+    id_map->RemoveClientID(client_id);
+  }
+
+  delete_function(n, service_ids.data());
+
+  return error::kNoError;
+}
+
+template <typename ClientType, typename ServiceType, typename DeleteFunction>
+error::Error DeleteHelper(ClientType client_id,
+                          ClientServiceMap<ClientType, ServiceType>* id_map,
+                          DeleteFunction delete_function) {
+  delete_function(id_map->GetServiceIDOrReserve(client_id));
+  id_map->RemoveClientID(client_id);
+  return error::kNoError;
+}
+
+template <typename T>
+void InsertValueIntoBuffer(std::vector<uint8_t>* data,
+                           const T& value,
+                           size_t offset) {
+  DCHECK_LE(offset + sizeof(T), data->size());
+  memcpy(data->data() + offset, &value, sizeof(T));
+}
+
+template <typename T>
+void AppendValueToBuffer(std::vector<uint8_t>* data, const T& value) {
+  size_t old_size = data->size();
+  data->resize(old_size + sizeof(T));
+  memcpy(data->data() + old_size, &value, sizeof(T));
+}
+
+void AppendStringToBuffer(std::vector<uint8_t>* data,
+                          const char* str,
+                          size_t len) {
+  size_t old_size = data->size();
+  data->resize(old_size + len);
+  memcpy(data->data() + old_size, str, len);
+}
+
+}  // anonymous namespace
+
 // Implementations of commands
 error::Error GLES2DecoderPassthroughImpl::DoActiveTexture(GLenum texture) {
+  glActiveTexture(texture);
+  active_texture_unit_ = static_cast<size_t>(texture) - GL_TEXTURE0;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoAttachShader(GLuint program,
                                                          GLuint shader) {
+  glAttachShader(resources_->program_id_map.GetServiceIDOrReserve(program),

[piman, 2016/09/13 01:07:32]

Here and other places, I'm not sure about the GetServiceIDOrReserve pattern. I
assume this expects to generate the proper error in ANGLE
(GL_INVALID_OPERATION/GL_INVALID_VALUE) if the client_id is invalid, because of
the made up service id (assuming we don't collide with driver-generated service
ids), but we'll still add tracking info in the map, and then a further attempt
to generate that particular client id will result in a kInvalidArguments
(therefore, lost context), whereas it is expected to succeed. For example:

glCreateProgram();  // clients picks 1. Adds CreateProgram(1) command. Returns 1
glAttachShader(1, 2);  // Adds AttachShader(1, 2) command. Getting ahead of
ourselves here, should raise GL_INVALID_OPERATION
glCreateShader(GL_VERTEX_SHADER);  // client picks 2. Adds
CreateShader(GL_VERTEX_SHADER, 2). Should return 2. However this will cause
kInvalidArguments in DoCreateShader

[Geoff Lang, 2016/09/13 17:49:57]

Good point.  You're right that the goal is to have ANGLE generate all the errors
for invalid IDs passed in but it looks like I need some extra logic to track
when an ID was reserved and have the ability to update it to a real value later.

I ended up keeping two separate lists of ID mappings in ClientServiceMap. 
GetServiceID will never return a reserved ID, they will only be returned when
calling GetServiceIDOrReserve.  When an ID is gen'd it will overwrite the
reserved ID when SetIDMapping is called.

Going to add some testing to verify the behaviour.

+                 resources_->shader_id_map.GetServiceIDOrReserve(shader));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindAttribLocation(
     GLuint program,
     GLuint index,
     const char* name) {
+  glBindAttribLocation(
+      resources_->program_id_map.GetServiceIDOrReserve(program), index, name);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindBuffer(GLenum target,
                                                        GLuint buffer) {
+  glBindBuffer(target, resources_->buffer_id_map.GetServiceIDOrReserve(buffer));

[piman, 2016/09/13 01:07:32]

Note, here in particular (and other glBind*), we expect to fail
(GL_INVALID_OPERATION) if the context was created with bind_generates_resource =
false.

[Geoff Lang, 2016/09/13 17:49:57]

Going to add an extension to ANGLE to generate errors when binding would
generate a resource, filed http://anglebug.com/1518

   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindBufferBase(GLenum target,
                                                            GLuint index,
                                                            GLuint buffer) {
+  glBindBufferBase(target, index,
+                   resources_->buffer_id_map.GetServiceIDOrReserve(buffer));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindBufferRange(GLenum target,
                                                             GLuint index,
                                                             GLuint buffer,
                                                             GLintptr offset,
                                                             GLsizeiptr size) {
+  glBindBufferRange(target, index,
+                    resources_->buffer_id_map.GetServiceIDOrReserve(buffer),
+                    offset, size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindFramebuffer(
     GLenum target,
     GLuint framebuffer) {
+  glBindFramebufferEXT(target,
+                       framebuffer_id_map_.GetServiceIDOrReserve(framebuffer));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindRenderbuffer(
     GLenum target,
     GLuint renderbuffer) {
+  glBindRenderbufferEXT(
+      target,
+      resources_->renderbuffer_id_map.GetServiceIDOrReserve(renderbuffer));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindSampler(GLuint unit,
                                                         GLuint sampler) {
+  glBindSampler(unit,
+                resources_->sampler_id_map.GetServiceIDOrReserve(sampler));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindTexture(GLenum target,
                                                         GLuint texture) {
+  glBindTexture(target,
+                resources_->texture_id_map.GetServiceIDOrReserve(texture));
+  if (target == GL_TEXTURE_2D &&
+      active_texture_unit_ < bound_textures_.size()) {
+    bound_textures_[active_texture_unit_] = texture;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindTransformFeedback(
     GLenum target,
     GLuint transformfeedback) {
+  glBindTransformFeedback(
+      target,
+      transform_feedback_id_map_.GetServiceIDOrReserve(transformfeedback));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlendColor(GLclampf red,
                                                        GLclampf green,
                                                        GLclampf blue,
                                                        GLclampf alpha) {
+  glBlendColor(red, green, blue, alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlendEquation(GLenum mode) {
+  glBlendEquation(mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlendEquationSeparate(
     GLenum modeRGB,
     GLenum modeAlpha) {
+  glBlendEquationSeparate(modeRGB, modeAlpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlendFunc(GLenum sfactor,
                                                       GLenum dfactor) {
+  glBlendFunc(sfactor, dfactor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlendFuncSeparate(GLenum srcRGB,
                                                               GLenum dstRGB,
                                                               GLenum srcAlpha,
                                                               GLenum dstAlpha) {
+  glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBufferData(GLenum target,
                                                        GLsizeiptr size,
                                                        const void* data,
                                                        GLenum usage) {
+  glBufferData(target, size, data, usage);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBufferSubData(GLenum target,
                                                           GLintptr offset,
                                                           GLsizeiptr size,
                                                           const void* data) {
+  glBufferSubData(target, offset, size, data);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCheckFramebufferStatus(
     GLenum target,
     uint32_t* result) {
+  *result = glCheckFramebufferStatusEXT(target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClear(GLbitfield mask) {
+  glClear(mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearBufferfi(GLenum buffer,
                                                           GLint drawbuffers,
                                                           GLfloat depth,
                                                           GLint stencil) {
+  glClearBufferfi(buffer, drawbuffers, depth, stencil);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearBufferfv(
     GLenum buffer,
     GLint drawbuffers,
     const volatile GLfloat* value) {
+  glClearBufferfv(buffer, drawbuffers, const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearBufferiv(
     GLenum buffer,
     GLint drawbuffers,
     const volatile GLint* value) {
+  glClearBufferiv(buffer, drawbuffers, const_cast<const GLint*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearBufferuiv(
     GLenum buffer,
     GLint drawbuffers,
     const volatile GLuint* value) {
+  glClearBufferuiv(buffer, drawbuffers, const_cast<const GLuint*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearColor(GLclampf red,
                                                        GLclampf green,
                                                        GLclampf blue,
                                                        GLclampf alpha) {
+  glClearColor(red, green, blue, alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearDepthf(GLclampf depth) {
+  glClearDepthf(depth);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClearStencil(GLint s) {
+  glClearStencil(s);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoClientWaitSync(GLuint sync,
                                                            GLbitfield flags,
                                                            GLuint64 timeout,
                                                            GLenum* result) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoColorMask(GLboolean red,
                                                       GLboolean green,
                                                       GLboolean blue,
                                                       GLboolean alpha) {
+  glColorMask(red, green, blue, alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCompileShader(GLuint shader) {
+  glCompileShader(resources_->shader_id_map.GetServiceIDOrReserve(shader));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCompressedTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLint border,
     GLsizei imageSize,
     const void* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCompressedTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLsizei width,
     GLsizei height,
     GLenum format,
     GLsizei imageSize,
     const void* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCompressedTexImage3D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLint border,
     GLsizei imageSize,
     const void* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCompressedTexSubImage3D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
     GLsizei imageSize,
     const void* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCopyBufferSubData(
     GLenum readtarget,
     GLenum writetarget,
     GLintptr readoffset,
     GLintptr writeoffset,
     GLsizeiptr size) {
+  glCopyBufferSubData(readtarget, writetarget, readoffset, writeoffset, size);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCopyTexImage2D(
     GLenum target,
     GLint level,
     GLenum internalformat,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLint border) {
+  glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCopyTexSubImage2D(GLenum target,
                                                               GLint level,
                                                               GLint xoffset,
                                                               GLint yoffset,
                                                               GLint x,
                                                               GLint y,
                                                               GLsizei width,
                                                               GLsizei height) {
+  glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCopyTexSubImage3D(GLenum target,
                                                               GLint level,
                                                               GLint xoffset,
                                                               GLint yoffset,
                                                               GLint zoffset,
                                                               GLint x,
                                                               GLint y,
                                                               GLsizei width,
                                                               GLsizei height) {
+  glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
+                      height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCreateProgram(GLuint client_id) {
-  return error::kNoError;
+  return CreateHelper(client_id, &resources_->program_id_map,
+                      []() { return glCreateProgram(); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCreateShader(GLenum type,
                                                          GLuint client_id) {
-  return error::kNoError;
+  return CreateHelper(client_id, &resources_->shader_id_map,
+                      [type]() { return glCreateShader(type); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCullFace(GLenum mode) {
+  glCullFace(mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteBuffers(
     GLsizei n,
     const volatile GLuint* buffers) {
-  return error::kNoError;
+  return DeleteHelper(
+      n, buffers, &resources_->buffer_id_map,
+      [](GLsizei n, GLuint* buffers) { glDeleteBuffersARB(n, buffers); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteFramebuffers(
     GLsizei n,
     const volatile GLuint* framebuffers) {
-  return error::kNoError;
+  return DeleteHelper(n, framebuffers, &framebuffer_id_map_,
+                      [](GLsizei n, GLuint* framebuffers) {
+                        glDeleteFramebuffersEXT(n, framebuffers);
+                      });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteProgram(GLuint program) {
-  return error::kNoError;
+  return DeleteHelper(program, &resources_->program_id_map,
+                      [](GLuint program) { glDeleteProgram(program); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteRenderbuffers(
     GLsizei n,
     const volatile GLuint* renderbuffers) {
-  return error::kNoError;
+  return DeleteHelper(n, renderbuffers, &resources_->renderbuffer_id_map,
+                      [](GLsizei n, GLuint* renderbuffers) {
+                        glDeleteRenderbuffersEXT(n, renderbuffers);
+                      });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteSamplers(
     GLsizei n,
     const volatile GLuint* samplers) {
-  return error::kNoError;
+  return DeleteHelper(
+      n, samplers, &resources_->sampler_id_map,
+      [](GLsizei n, GLuint* samplers) { glDeleteSamplers(n, samplers); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteSync(GLuint sync) {
-  return error::kNoError;
+  return DeleteHelper(sync, &resources_->sync_id_map, [](uintptr_t sync) {
+    glDeleteSync(reinterpret_cast<GLsync>(sync));
+  });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteShader(GLuint shader) {
-  return error::kNoError;
+  return DeleteHelper(shader, &resources_->shader_id_map,
+                      [](GLuint shader) { glDeleteShader(shader); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteTextures(
     GLsizei n,
     const volatile GLuint* textures) {
-  return error::kNoError;
+  // Textures that are currently associated with a mailbox are stored in the
+  // texture_object_map_ and are deleted automatically when they are
+  // unreferenced.  Only delete textures that are not in this map.
+  std::vector<GLuint> non_mailbox_client_ids;
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    GLuint client_id = textures[ii];
+    auto texture_object_iter = resources_->texture_object_map.find(client_id);
+    if (texture_object_iter == resources_->texture_object_map.end()) {
+      // Delete with DeleteHelper
+      non_mailbox_client_ids.push_back(client_id);
+    } else {
+      // Deleted when unreferenced
+      resources_->texture_id_map.RemoveClientID(client_id);
+      resources_->texture_object_map.erase(client_id);
+    }
+  }
+  return DeleteHelper(
+      non_mailbox_client_ids.size(), non_mailbox_client_ids.data(),
+      &resources_->texture_id_map,
+      [](GLsizei n, GLuint* textures) { glDeleteTextures(n, textures); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteTransformFeedbacks(
     GLsizei n,
     const volatile GLuint* ids) {
-  return error::kNoError;
+  return DeleteHelper(n, ids, &transform_feedback_id_map_,
+                      [](GLsizei n, GLuint* transform_feedbacks) {
+                        glDeleteTransformFeedbacks(n, transform_feedbacks);
+                      });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDepthFunc(GLenum func) {
+  glDepthFunc(func);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDepthMask(GLboolean flag) {
+  glDepthMask(flag);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDepthRangef(GLclampf zNear,
                                                         GLclampf zFar) {
+  glDepthRangef(zNear, zFar);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDetachShader(GLuint program,
                                                          GLuint shader) {
+  glDetachShader(resources_->program_id_map.GetServiceIDOrReserve(program),
+                 resources_->shader_id_map.GetServiceIDOrReserve(shader));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDisable(GLenum cap) {
+  glDisable(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDisableVertexAttribArray(
     GLuint index) {
+  glDisableVertexAttribArray(index);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDrawArrays(GLenum mode,
                                                        GLint first,
                                                        GLsizei count) {
+  glDrawArrays(mode, first, count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDrawElements(GLenum mode,
                                                          GLsizei count,
                                                          GLenum type,
                                                          const void* indices) {
+  glDrawElements(mode, count, type, indices);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoEnable(GLenum cap) {
+  glEnable(cap);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoEnableVertexAttribArray(
     GLuint index) {
+  glEnableVertexAttribArray(index);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFenceSync(GLenum condition,
                                                       GLbitfield flags,
                                                       GLuint client_id) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFinish() {
+  glFinish();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFlush() {
+  glFlush();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFramebufferRenderbuffer(
     GLenum target,
     GLenum attachment,
     GLenum renderbuffertarget,
     GLuint renderbuffer) {
+  // TODO(geofflang): Handle this case in ANGLE by adding a WebGL validation
+  // mode.
+  if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
+    glFramebufferRenderbufferEXT(
+        target, GL_DEPTH_ATTACHMENT, renderbuffertarget,
+        resources_->renderbuffer_id_map.GetServiceIDOrReserve(renderbuffer));
+    glFramebufferRenderbufferEXT(
+        target, GL_STENCIL_ATTACHMENT, renderbuffertarget,
+        resources_->renderbuffer_id_map.GetServiceIDOrReserve(renderbuffer));
+  } else {
+    glFramebufferRenderbufferEXT(
+        target, attachment, renderbuffertarget,
+        resources_->renderbuffer_id_map.GetServiceIDOrReserve(renderbuffer));
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFramebufferTexture2D(
     GLenum target,
     GLenum attachment,
     GLenum textarget,
     GLuint texture,
     GLint level) {
+  glFramebufferTexture2DEXT(
+      target, attachment, textarget,
+      resources_->texture_id_map.GetServiceIDOrReserve(texture), level);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFramebufferTextureLayer(
     GLenum target,
     GLenum attachment,
     GLuint texture,
     GLint level,
     GLint layer) {
+  glFramebufferTextureLayer(
+      target, attachment,
+      resources_->texture_id_map.GetServiceIDOrReserve(texture), level, layer);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFrontFace(GLenum mode) {
+  glFrontFace(mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenBuffers(
     GLsizei n,
     volatile GLuint* buffers) {
-  return error::kNoError;
+  return GenHelper(
+      n, buffers, &resources_->buffer_id_map,
+      [](GLsizei n, GLuint* buffers) { glGenBuffersARB(n, buffers); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenerateMipmap(GLenum target) {
+  glGenerateMipmapEXT(target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenFramebuffers(
     GLsizei n,
     volatile GLuint* framebuffers) {
-  return error::kNoError;
+  return GenHelper(n, framebuffers, &framebuffer_id_map_,
+                   [](GLsizei n, GLuint* framebuffers) {
+                     glGenFramebuffersEXT(n, framebuffers);
+                   });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenRenderbuffers(
     GLsizei n,
     volatile GLuint* renderbuffers) {
-  return error::kNoError;
+  return GenHelper(n, renderbuffers, &resources_->renderbuffer_id_map,
+                   [](GLsizei n, GLuint* renderbuffers) {
+                     glGenRenderbuffersEXT(n, renderbuffers);
+                   });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenSamplers(
     GLsizei n,
     volatile GLuint* samplers) {
-  return error::kNoError;
+  return GenHelper(
+      n, samplers, &resources_->sampler_id_map,
+      [](GLsizei n, GLuint* samplers) { glGenSamplers(n, samplers); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenTextures(
     GLsizei n,
     volatile GLuint* textures) {
-  return error::kNoError;
+  return GenHelper(
+      n, textures, &resources_->texture_id_map,
+      [](GLsizei n, GLuint* textures) { glGenTextures(n, textures); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenTransformFeedbacks(
     GLsizei n,
     volatile GLuint* ids) {
-  return error::kNoError;
+  return GenHelper(n, ids, &transform_feedback_id_map_,
+                   [](GLsizei n, GLuint* transform_feedbacks) {
+                     glGenTransformFeedbacks(n, transform_feedbacks);
+                   });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveAttrib(GLuint program,
                                                             GLuint index,
                                                             GLint* size,
                                                             GLenum* type,
                                                             std::string* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveUniform(
     GLuint program,
     GLuint index,
     GLint* size,
     GLenum* type,
     std::string* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveUniformBlockiv(
     GLuint program,
     GLuint index,
     GLenum pname,
     GLsizei bufSize,
     GLsizei* length,
     GLint* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveUniformBlockName(
     GLuint program,
     GLuint index,
     std::string* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetActiveUniformsiv(
     GLuint program,
     GLsizei count,
     const GLuint* indices,
     GLenum pname,
     GLsizei bufSize,
     GLsizei* length,
     GLint* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetAttachedShaders(
     GLuint program,
     GLsizei maxcount,
     GLsizei* count,
     GLuint* shaders) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetAttribLocation(GLuint program,
                                                               const char* name,
                                                               GLint* result) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetBooleanv(GLenum pname,
                                                         GLsizei bufsize,
                                                         GLsizei* length,
                                                         GLboolean* params) {
+  // TODO(geofflang): new-style getter
+  glGetBooleanv(pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetBufferParameteri64v(
     GLenum target,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint64* params) {
+  NOTIMPLEMENTED();
+  // TODO(geofflang): new-style getter
+  // TODO(geofflang): missing glGetBufferParameteri64v?
+  // glGetBufferParameteri64v(target, pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetBufferParameteriv(
     GLenum target,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetBufferParameteriv(target, pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetError(uint32_t* result) {
+  *result = glGetError();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetFloatv(GLenum pname,
                                                       GLsizei bufsize,
                                                       GLsizei* length,
                                                       GLfloat* params) {
+  // TODO(geofflang): new-style getter
+  glGetFloatv(pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetFragDataLocation(
     GLuint program,
     const char* name,
     GLint* result) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target,
     GLenum attachment,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetInteger64v(GLenum pname,
                                                           GLsizei bufsize,
                                                           GLsizei* length,
                                                           GLint64* params) {
+  // TODO(geofflang): new-style getter
+  glGetInteger64v(pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetIntegeri_v(GLenum pname,
                                                           GLuint index,
                                                           GLsizei bufsize,
                                                           GLsizei* length,
                                                           GLint* data) {
+  // TODO(geofflang): new-style getter
+  glGetIntegeri_v(pname, index, data);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetInteger64i_v(GLenum pname,
                                                             GLuint index,
                                                             GLsizei bufsize,
                                                             GLsizei* length,
                                                             GLint64* data) {
+  // TODO(geofflang): new-style getter
+  glGetInteger64i_v(pname, index, data);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetIntegerv(GLenum pname,
                                                         GLsizei bufsize,
                                                         GLsizei* length,
                                                         GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetIntegerv(pname, params);
+  *length = 1;
+  // HACK: WebGL initialization requires this query
+  if (pname == GL_MAX_VIEWPORT_DIMS) {
+    *length = 2;
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetInternalformativ(GLenum target,
                                                                 GLenum format,
                                                                 GLenum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei* length,
                                                                 GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetInternalformativ(target, format, pname, bufSize, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetProgramiv(GLuint program,
                                                          GLenum pname,
                                                          GLsizei bufsize,
                                                          GLsizei* length,
                                                          GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetProgramiv(resources_->program_id_map.GetServiceIDOrReserve(program),
+                 pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetProgramInfoLog(
     GLuint program,
     std::string* infolog) {
+  GLint info_log_len = 0;
+  glGetProgramiv(resources_->program_id_map.GetServiceIDOrReserve(program),
+                 GL_INFO_LOG_LENGTH, &info_log_len);
+
+  std::vector<char> buffer(info_log_len, 0);
+  glGetProgramInfoLog(resources_->program_id_map.GetServiceIDOrReserve(program),
+                      info_log_len, nullptr, buffer.data());
+  *infolog = std::string(buffer.data());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetRenderbufferParameteriv(
     GLenum target,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetSamplerParameterfv(
     GLuint sampler,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLfloat* params) {
+  // TODO(geofflang): new-style getter
+  glGetSamplerParameterfv(
+      resources_->sampler_id_map.GetServiceIDOrReserve(sampler), pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetSamplerParameteriv(
     GLuint sampler,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLint* params) {
+  NOTIMPLEMENTED();
+  // TODO(geofflang): new-style getter
+  // glGetRenderbufferParameterivEXT(target, pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderiv(GLuint shader,
                                                         GLenum pname,
                                                         GLsizei bufsize,
                                                         GLsizei* length,
                                                         GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetShaderiv(resources_->shader_id_map.GetServiceIDOrReserve(shader), pname,
+                params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderInfoLog(
     GLuint shader,
     std::string* infolog) {
+  GLuint service_id = resources_->shader_id_map.GetServiceIDOrReserve(shader);
+  GLint info_log_len = 0;
+  glGetShaderiv(service_id, GL_INFO_LOG_LENGTH, &info_log_len);
+  std::vector<char> buffer(info_log_len, 0);
+  glGetShaderInfoLog(service_id, info_log_len, nullptr, buffer.data());
+  *infolog = std::string(buffer.data());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderPrecisionFormat(
     GLenum shadertype,
     GLenum precisiontype,
     GLint* range,
     GLint* precision) {
+  glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetShaderSource(
     GLuint shader,
     std::string* source) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetString(GLenum name,
                                                       const char** result) {
+  // TODO(geofflang): Append additional CHROMIUM extension strings?
+  *result = reinterpret_cast<const char*>(glGetString(name));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetSynciv(GLuint sync,
                                                       GLenum pname,
                                                       GLsizei bufsize,
                                                       GLsizei* length,
                                                       GLint* values) {
+  glGetSynciv(reinterpret_cast<GLsync>(
+                  resources_->sync_id_map.GetServiceIDOrReserve(sync)),
+              pname, bufsize, length, values);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetTexParameterfv(GLenum target,
                                                               GLenum pname,
                                                               GLsizei bufsize,
                                                               GLsizei* length,
                                                               GLfloat* params) {
+  // TODO(geofflang): new-style getter
+  glGetTexParameterfv(target, pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetTexParameteriv(GLenum target,
                                                               GLenum pname,
                                                               GLsizei bufsize,
                                                               GLsizei* length,
                                                               GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetTexParameteriv(target, pname, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetTransformFeedbackVarying(
     GLuint program,
     GLuint index,
     GLsizei* size,
     GLenum* type,
     std::string* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformBlockIndex(
     GLuint program,
     const char* name,
     GLint* index) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformfv(GLuint program,
                                                          GLint location,
                                                          GLsizei bufsize,
                                                          GLsizei* length,
                                                          GLfloat* params) {
+  // TODO(geofflang): new-style getter
+  glGetUniformfv(resources_->program_id_map.GetServiceIDOrReserve(program),
+                 location, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformiv(GLuint program,
                                                          GLint location,
                                                          GLsizei bufsize,
                                                          GLsizei* length,
                                                          GLint* params) {
+  // TODO(geofflang): new-style getter
+  glGetUniformiv(resources_->program_id_map.GetServiceIDOrReserve(program),
+                 location, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformuiv(GLuint program,
                                                           GLint location,
                                                           GLsizei bufsize,
                                                           GLsizei* length,
                                                           GLuint* params) {
+  // TODO(geofflang): new-style getter
+  glGetUniformuiv(resources_->program_id_map.GetServiceIDOrReserve(program),
+                  location, params);
+  *length = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformIndices(
     GLuint program,
     GLsizei count,
     const char* const* names,
     GLsizei bufSize,
     GLsizei* length,
     GLuint* indices) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformLocation(
     GLuint program,
     const char* name,
     GLint* location) {
+  *location = glGetUniformLocation(
+      resources_->program_id_map.GetServiceIDOrReserve(program), name);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetVertexAttribfv(GLuint index,
                                                               GLenum pname,
                                                               GLsizei bufsize,
                                                               GLsizei* length,
                                                               GLfloat* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetVertexAttribiv(GLuint index,
                                                               GLenum pname,
                                                               GLsizei bufsize,
                                                               GLsizei* length,
                                                               GLint* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetVertexAttribIiv(GLuint index,
                                                                GLenum pname,
                                                                GLsizei bufsize,
                                                                GLsizei* length,
                                                                GLint* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetVertexAttribIuiv(
     GLuint index,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLuint* params) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetVertexAttribPointerv(
     GLuint index,
     GLenum pname,
     GLsizei bufsize,
     GLsizei* length,
     GLuint* pointer) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoHint(GLenum target, GLenum mode) {
+  glHint(target, mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoInvalidateFramebuffer(
     GLenum target,
     GLsizei count,
     const volatile GLenum* attachments) {
+  std::vector<GLenum> attachments_copy(attachments, attachments + count);
+  glInvalidateFramebuffer(target, count, attachments_copy.data());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoInvalidateSubFramebuffer(
     GLenum target,
     GLsizei count,
     const volatile GLenum* attachments,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height) {
+  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(resources_->buffer_id_map.GetServiceIDOrReserve(buffer));
   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(
+      framebuffer_id_map_.GetServiceIDOrReserve(framebuffer));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsProgram(GLuint program,
                                                       uint32_t* result) {
+  *result =
+      glIsProgram(resources_->program_id_map.GetServiceIDOrReserve(program));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsRenderbuffer(GLuint renderbuffer,
                                                            uint32_t* result) {
+  NOTIMPLEMENTED();
+  *result = glIsRenderbufferEXT(
+      resources_->buffer_id_map.GetServiceIDOrReserve(renderbuffer));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsSampler(GLuint sampler,
                                                       uint32_t* result) {
+  *result =
+      glIsSampler(resources_->sampler_id_map.GetServiceIDOrReserve(sampler));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsShader(GLuint shader,
                                                      uint32_t* result) {
+  *result = glIsShader(resources_->shader_id_map.GetServiceIDOrReserve(shader));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsSync(GLuint sync,
                                                    uint32_t* result) {
+  *result = glIsSync(reinterpret_cast<GLsync>(
+      resources_->sync_id_map.GetServiceIDOrReserve(sync)));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsTexture(GLuint texture,
                                                       uint32_t* result) {
+  *result =
+      glIsTexture(resources_->texture_id_map.GetServiceIDOrReserve(texture));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsTransformFeedback(
     GLuint transformfeedback,
     uint32_t* result) {
+  *result = glIsTransformFeedback(
+      transform_feedback_id_map_.GetServiceIDOrReserve(transformfeedback));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoLineWidth(GLfloat width) {
+  glLineWidth(width);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoLinkProgram(GLuint program) {
+  glLinkProgram(resources_->program_id_map.GetServiceIDOrReserve(program));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPauseTransformFeedback() {
+  glPauseTransformFeedback();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPixelStorei(GLenum pname,
                                                         GLint param) {
+  glPixelStorei(pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPolygonOffset(GLfloat factor,
                                                           GLfloat units) {
+  glPolygonOffset(factor, units);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoReadBuffer(GLenum src) {
+  glReadBuffer(src);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoReadPixels(GLint x,
                                                        GLint y,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLenum format,
                                                        GLenum type,
                                                        GLsizei bufsize,
                                                        GLsizei* length,
                                                        void* pixels) {
+  glReadPixels(x, y, width, height, format, type, pixels);

[piman, 2016/09/13 01:07:32]

We need to validate the length against bufsize before doing this, otherwise this
would lead to an out-of-bounds write.

+
+  // HACK: Calculate the length here without taking into account the unpack
+  // parameters.
+  // Move into an ANGLE extension.
+  size_t componentCount = 4;
+  switch (format) {
+    case GL_RGBA:
+      componentCount = 4;
+      break;
+    case GL_RGB:
+      componentCount = 3;
+      break;
+    case GL_RG:
+      componentCount = 2;
+      break;
+    case GL_RED:
+      componentCount = 1;
+      break;
+  }
+  *length = width * height * componentCount * 4;
+
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoReleaseShaderCompiler() {
+  glReleaseShaderCompiler();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoRenderbufferStorage(
     GLenum target,
     GLenum internalformat,
     GLsizei width,
     GLsizei height) {
+  glRenderbufferStorageEXT(target, internalformat, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoResumeTransformFeedback() {
+  glResumeTransformFeedback();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSampleCoverage(GLclampf value,
                                                            GLboolean invert) {
+  glSampleCoverage(value, invert);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSamplerParameterf(GLuint sampler,
                                                               GLenum pname,
                                                               GLfloat param) {
+  glSamplerParameterf(resources_->sampler_id_map.GetServiceIDOrReserve(sampler),
+                      pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSamplerParameterfv(
     GLuint sampler,
     GLenum pname,
     const volatile GLfloat* params) {
+  // TODO(geofflang): new-style setter, needs to make only one copy
+  glSamplerParameterfv(
+      resources_->sampler_id_map.GetServiceIDOrReserve(sampler), pname,
+      const_cast<const GLfloat*>(params));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSamplerParameteri(GLuint sampler,
                                                               GLenum pname,
                                                               GLint param) {
+  glSamplerParameteri(resources_->sampler_id_map.GetServiceIDOrReserve(sampler),
+                      pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSamplerParameteriv(
     GLuint sampler,
     GLenum pname,
     const volatile GLint* params) {
+  // TODO(geofflang): new-style setter, needs to make only one copy
+  glSamplerParameteriv(
+      resources_->sampler_id_map.GetServiceIDOrReserve(sampler), pname,
+      const_cast<const GLint*>(params));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoScissor(GLint x,
                                                     GLint y,
                                                     GLsizei width,
                                                     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();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoShaderSource(GLuint shader,
                                                          GLsizei count,
                                                          const char** string,
                                                          const GLint* length) {
+  glShaderSource(resources_->shader_id_map.GetServiceIDOrReserve(shader), count,
+                 string, length);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilFunc(GLenum func,
                                                         GLint ref,
                                                         GLuint mask) {
+  glStencilFunc(func, ref, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilFuncSeparate(GLenum face,
                                                                 GLenum func,
                                                                 GLint ref,
                                                                 GLuint mask) {
+  glStencilFuncSeparate(face, func, ref, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilMask(GLuint mask) {
+  glStencilMask(mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilMaskSeparate(GLenum face,
                                                                 GLuint mask) {
+  glStencilMaskSeparate(face, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilOp(GLenum fail,
                                                       GLenum zfail,
                                                       GLenum zpass) {
+  glStencilOp(fail, zfail, zpass);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilOpSeparate(GLenum face,
                                                               GLenum fail,
                                                               GLenum zfail,
                                                               GLenum zpass) {
+  glStencilOpSeparate(face, fail, zfail, zpass);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexImage2D(GLenum target,
                                                        GLint level,
                                                        GLint internalformat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLint border,
                                                        GLenum format,
                                                        GLenum type,
                                                        GLsizei imagesize,
                                                        const void* pixels) {
+  // TODO(geofflang): validate using imagesize
+  glTexImage2D(target, level, internalformat, width, height, border, format,
+               type, pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexImage3D(GLenum target,
                                                        GLint level,
                                                        GLint internalformat,
                                                        GLsizei width,
                                                        GLsizei height,
                                                        GLsizei depth,
                                                        GLint border,
                                                        GLenum format,
                                                        GLenum type,
                                                        GLsizei imagesize,
                                                        const void* pixels) {
+  // TODO(geofflang): validate using imagesize
+  glTexImage3D(target, level, internalformat, width, height, depth, border,
+               format, type, pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexParameterf(GLenum target,
                                                           GLenum pname,
                                                           GLfloat param) {
+  glTexParameterf(target, pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexParameterfv(
     GLenum target,
     GLenum pname,
     const volatile GLfloat* params) {
+  // TODO(geofflang): new-style setter, needs to make only one copy
+  glTexParameterfv(target, pname, const_cast<const GLfloat*>(params));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexParameteri(GLenum target,
                                                           GLenum pname,
                                                           GLint param) {
   glTexParameteri(target, pname, param);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexParameteriv(
     GLenum target,
     GLenum pname,
     const volatile GLint* params) {
+  // TODO(geofflang): new-style setter, needs to make only one copy
+  glTexParameteriv(target, pname, const_cast<const GLint*>(params));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexStorage3D(GLenum target,
                                                          GLsizei levels,
                                                          GLenum internalFormat,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth) {
+  glTexStorage3D(target, levels, internalFormat, width, height, depth);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexSubImage2D(GLenum target,
                                                           GLint level,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLenum format,
                                                           GLenum type,
                                                           GLsizei imagesize,
                                                           const void* pixels) {
+  // TODO(geofflang): validate using imagesize
+  glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
+                  pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexSubImage3D(GLenum target,
                                                           GLint level,
                                                           GLint xoffset,
                                                           GLint yoffset,
                                                           GLint zoffset,
                                                           GLsizei width,
                                                           GLsizei height,
                                                           GLsizei depth,
                                                           GLenum format,
                                                           GLenum type,
                                                           GLsizei imagesize,
                                                           const void* pixels) {
+  // TODO(geofflang): validate using imagesize
+  glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
+                  depth, format, type, pixels);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTransformFeedbackVaryings(
     GLuint program,
     GLsizei count,
     const char** varyings,
     GLenum buffermode) {
+  glTransformFeedbackVaryings(
+      resources_->program_id_map.GetServiceIDOrReserve(program), count,
+      varyings, buffermode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform1f(GLint location,
                                                       GLfloat x) {
+  glUniform1f(location, x);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform1fv(
     GLint location,
     GLsizei count,
     const volatile GLfloat* v) {
+  glUniform1fv(location, count, const_cast<const GLfloat*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform1i(GLint location, GLint x) {
+  glUniform1i(location, x);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform1iv(
     GLint location,
     GLsizei count,
     const volatile GLint* v) {
+  glUniform1iv(location, count, const_cast<const GLint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform1ui(GLint location,
                                                        GLuint x) {
+  glUniform1ui(location, x);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform1uiv(
     GLint location,
     GLsizei count,
     const volatile GLuint* v) {
+  glUniform1uiv(location, count, const_cast<const GLuint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform2f(GLint location,
                                                       GLfloat x,
                                                       GLfloat y) {
+  glUniform2f(location, x, y);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform2fv(
     GLint location,
     GLsizei count,
     const volatile GLfloat* v) {
+  glUniform2fv(location, count, const_cast<const GLfloat*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform2i(GLint location,
                                                       GLint x,
                                                       GLint y) {
+  glUniform2i(location, x, y);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform2iv(
     GLint location,
     GLsizei count,
     const volatile GLint* v) {
+  glUniform2iv(location, count, const_cast<const GLint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform2ui(GLint location,
                                                        GLuint x,
                                                        GLuint y) {
+  glUniform2ui(location, x, y);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform2uiv(
     GLint location,
     GLsizei count,
     const volatile GLuint* v) {
+  glUniform2uiv(location, count, const_cast<const GLuint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform3f(GLint location,
                                                       GLfloat x,
                                                       GLfloat y,
                                                       GLfloat z) {
+  glUniform3f(location, x, y, z);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform3fv(
     GLint location,
     GLsizei count,
     const volatile GLfloat* v) {
+  glUniform3fv(location, count, const_cast<const GLfloat*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform3i(GLint location,
                                                       GLint x,
                                                       GLint y,
                                                       GLint z) {
+  glUniform3i(location, x, y, z);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform3iv(
     GLint location,
     GLsizei count,
     const volatile GLint* v) {
+  glUniform3iv(location, count, const_cast<const GLint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform3ui(GLint location,
                                                        GLuint x,
                                                        GLuint y,
                                                        GLuint z) {
+  glUniform3ui(location, x, y, z);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform3uiv(
     GLint location,
     GLsizei count,
     const volatile GLuint* v) {
+  glUniform3uiv(location, count, const_cast<const GLuint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform4f(GLint location,
                                                       GLfloat x,
                                                       GLfloat y,
                                                       GLfloat z,
                                                       GLfloat w) {
+  glUniform4f(location, x, y, z, w);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform4fv(
     GLint location,
     GLsizei count,
     const volatile GLfloat* v) {
+  glUniform4fv(location, count, const_cast<const GLfloat*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform4i(GLint location,
                                                       GLint x,
                                                       GLint y,
                                                       GLint z,
                                                       GLint w) {
+  glUniform4i(location, x, y, z, w);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform4iv(
     GLint location,
     GLsizei count,
     const volatile GLint* v) {
+  glUniform4iv(location, count, const_cast<const GLint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform4ui(GLint location,
                                                        GLuint x,
                                                        GLuint y,
                                                        GLuint z,
                                                        GLuint w) {
+  glUniform4ui(location, x, y, z, w);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniform4uiv(
     GLint location,
     GLsizei count,
     const volatile GLuint* v) {
+  glUniform4uiv(location, count, const_cast<const GLuint*>(v));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformBlockBinding(
     GLuint program,
     GLuint index,
     GLuint binding) {
+  glUniformBlockBinding(
+      resources_->program_id_map.GetServiceIDOrReserve(program), index,
+      binding);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix2fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix2fv(location, count, transpose,
+                     const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix2x3fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix2x3fv(location, count, transpose,
+                       const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix2x4fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix2x4fv(location, count, transpose,
+                       const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix3fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix3fv(location, count, transpose,
+                     const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix3x2fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix3x2fv(location, count, transpose,
+                       const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix3x4fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix3x4fv(location, count, transpose,
+                       const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix4fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix4fv(location, count, transpose,
+                     const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix4x2fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix4x2fv(location, count, transpose,
+                       const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUniformMatrix4x3fv(
     GLint location,
     GLsizei count,
     GLboolean transpose,
     const volatile GLfloat* value) {
+  glUniformMatrix4x3fv(location, count, transpose,
+                       const_cast<const GLfloat*>(value));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUseProgram(GLuint program) {
+  glUseProgram(resources_->program_id_map.GetServiceIDOrReserve(program));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoValidateProgram(GLuint program) {
+  glValidateProgram(resources_->program_id_map.GetServiceIDOrReserve(program));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib1f(GLuint indx,
                                                            GLfloat x) {
+  glVertexAttrib1f(indx, x);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib1fv(
     GLuint indx,
     const volatile GLfloat* values) {
+  glVertexAttrib1fv(indx, const_cast<const GLfloat*>(values));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib2f(GLuint indx,
                                                            GLfloat x,
                                                            GLfloat y) {
+  glVertexAttrib2f(indx, x, y);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib2fv(
     GLuint indx,
     const volatile GLfloat* values) {
+  glVertexAttrib2fv(indx, const_cast<const GLfloat*>(values));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib3f(GLuint indx,
                                                            GLfloat x,
                                                            GLfloat y,
                                                            GLfloat z) {
+  glVertexAttrib3f(indx, x, y, z);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib3fv(
     GLuint indx,
     const volatile GLfloat* values) {
+  glVertexAttrib3fv(indx, const_cast<const GLfloat*>(values));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib4f(GLuint indx,
                                                            GLfloat x,
                                                            GLfloat y,
                                                            GLfloat z,
                                                            GLfloat w) {
+  glVertexAttrib4f(indx, x, y, z, w);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttrib4fv(
     GLuint indx,
     const volatile GLfloat* values) {
+  glVertexAttrib4fv(indx, const_cast<const GLfloat*>(values));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribI4i(GLuint indx,
                                                             GLint x,
                                                             GLint y,
                                                             GLint z,
                                                             GLint w) {
+  glVertexAttribI4i(indx, x, y, z, w);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribI4iv(
     GLuint indx,
     const volatile GLint* values) {
+  glVertexAttribI4iv(indx, const_cast<const GLint*>(values));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribI4ui(GLuint indx,
                                                              GLuint x,
                                                              GLuint y,
                                                              GLuint z,
                                                              GLuint w) {
+  glVertexAttribI4ui(indx, x, y, z, w);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribI4uiv(
     GLuint indx,
     const volatile GLuint* values) {
+  glVertexAttribI4uiv(indx, const_cast<const GLuint*>(values));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribIPointer(
     GLuint indx,
     GLint size,
     GLenum type,
     GLsizei stride,
     const void* ptr) {
+  glVertexAttribIPointer(indx, size, type, stride, ptr);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribPointer(
     GLuint indx,
     GLint size,
     GLenum type,
     GLboolean normalized,
     GLsizei stride,
     const void* ptr) {
+  glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoViewport(GLint x,
                                                      GLint y,
                                                      GLsizei width,
                                                      GLsizei height) {
+  glViewport(x, y, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoWaitSync(GLuint sync,
                                                      GLbitfield flags,
                                                      GLuint64 timeout) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlitFramebufferCHROMIUM(
     GLint srcX0,
     GLint srcY0,
     GLint srcX1,
     GLint srcY1,
     GLint dstX0,
     GLint dstY0,
     GLint dstX1,
     GLint dstY1,
     GLbitfield mask,
     GLenum filter) {
+  glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
+                         mask, filter);
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::DoRenderbufferStorageMultisampleCHROMIUM(
     GLenum target,
     GLsizei samples,
     GLenum internalformat,
     GLsizei width,
     GLsizei height) {
+  glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width,
+                                        height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoRenderbufferStorageMultisampleEXT(
     GLenum target,
     GLsizei samples,
     GLenum internalformat,
     GLsizei width,
     GLsizei height) {
+  glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width,
+                                        height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFramebufferTexture2DMultisampleEXT(
     GLenum target,
     GLenum attachment,
     GLenum textarget,
     GLuint texture,
     GLint level,
     GLsizei samples) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTexStorage2DEXT(
     GLenum target,
     GLsizei levels,
     GLenum internalFormat,
     GLsizei width,
     GLsizei height) {
   glTexStorage2DEXT(target, levels, internalFormat, width, height);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenQueriesEXT(
     GLsizei n,
     volatile GLuint* queries) {
-  return error::kNoError;
+  return GenHelper(n, queries, &query_id_map_, [](GLsizei n, GLuint* queries) {
+    glGenQueries(n, queries);
+  });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteQueriesEXT(
     GLsizei n,
     const volatile GLuint* queries) {
-  return error::kNoError;
+  return DeleteHelper(
+      n, queries, &query_id_map_,
+      [](GLsizei n, GLuint* queries) { glDeleteQueries(n, queries); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoQueryCounterEXT(GLuint id,
                                                             GLenum target) {
+  glQueryCounter(query_id_map_.GetServiceIDOrReserve(id), target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBeginQueryEXT(GLenum target,
                                                           GLuint id) {
+  // TODO(geofflang): Track active queries
+  glBeginQuery(target, query_id_map_.GetServiceIDOrReserve(id));
   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::DoEndTransformFeedback() {
+  glEndTransformFeedback();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSetDisjointValueSyncCHROMIUM(
     DisjointValueSync* sync) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoInsertEventMarkerEXT(
     GLsizei length,
     const char* marker) {
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPushGroupMarkerEXT(
     GLsizei length,
     const char* marker) {
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPopGroupMarkerEXT() {
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenVertexArraysOES(
     GLsizei n,
     volatile GLuint* arrays) {
-  return error::kNoError;
+  return GenHelper(
+      n, arrays, &vertex_array_id_map_,
+      [](GLsizei n, GLuint* arrays) { glGenVertexArraysOES(n, arrays); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeleteVertexArraysOES(
     GLsizei n,
     const volatile GLuint* arrays) {
-  return error::kNoError;
+  return DeleteHelper(
+      n, arrays, &vertex_array_id_map_,
+      [](GLsizei n, GLuint* arrays) { glDeleteVertexArraysOES(n, arrays); });
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsVertexArrayOES(GLuint array,
                                                              uint32_t* result) {
+  *result =
+      glIsVertexArrayOES(vertex_array_id_map_.GetServiceIDOrReserve(array));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindVertexArrayOES(GLuint array) {
+  glBindVertexArrayOES(vertex_array_id_map_.GetServiceIDOrReserve(array));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSwapBuffers() {
+  gfx::SwapResult result = surface_->SwapBuffers();
+  if (result == gfx::SwapResult::SWAP_FAILED) {
+    LOG(ERROR) << "Context lost because SwapBuffers failed.";
+  }
+  // TODO(geofflang): force the context loss?
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetMaxValueInBufferCHROMIUM(
     GLuint buffer_id,
     GLsizei count,
     GLenum type,
     GLuint offset,
     uint32_t* result) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoEnableFeatureCHROMIUM(
     const char* feature) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoMapBufferRange(GLenum target,
                                                            GLintptr offset,
                                                            GLsizeiptr size,
                                                            GLbitfield access,
                                                            void** ptr) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoUnmapBuffer(GLenum target) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoResizeCHROMIUM(GLuint width,
                                                            GLuint height,
                                                            GLfloat scale_factor,
                                                            GLboolean alpha) {
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetRequestableExtensionsCHROMIUM(
     const char** extensions) {
+  *extensions = "";
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoRequestExtensionCHROMIUM(
     const char* extension) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetProgramInfoCHROMIUM(
     GLuint program,
     std::vector<uint8_t>* data) {
+  GLuint service_program = 0;
+  if (!resources_->program_id_map.GetServiceID(program, &service_program)) {
+    return error::kNoError;
+  }
+
+  GLint num_attributes = 0;
+  glGetProgramiv(service_program, GL_ACTIVE_ATTRIBUTES, &num_attributes);
+
+  GLint num_uniforms = 0;
+  glGetProgramiv(service_program, GL_ACTIVE_UNIFORMS, &num_uniforms);
+
+  data->resize(sizeof(ProgramInfoHeader) +
+                   ((num_attributes + num_uniforms) * sizeof(ProgramInput)),
+               0);
+
+  GLint link_status = 0;
+  glGetProgramiv(service_program, GL_LINK_STATUS, &link_status);
+
+  ProgramInfoHeader header;
+  header.link_status = link_status;
+  header.num_attribs = num_attributes;
+  header.num_uniforms = num_uniforms;
+  InsertValueIntoBuffer(data, header, 0);
+
+  GLint active_attribute_max_length = 0;
+  glGetProgramiv(service_program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH,
+                 &active_attribute_max_length);
+
+  std::vector<char> attrib_name_buf(active_attribute_max_length, 0);
+  for (GLint attrib_index = 0; attrib_index < num_attributes; attrib_index++) {
+    GLsizei length = 0;
+    GLint size = 0;
+    GLenum type = GL_NONE;
+    glGetActiveAttrib(service_program, attrib_index, attrib_name_buf.size(),
+                      &length, &size, &type, attrib_name_buf.data());
+
+    ProgramInput input;
+    input.size = size;
+    input.type = type;
+
+    int32_t location =
+        glGetAttribLocation(service_program, attrib_name_buf.data());
+    input.location_offset = data->size();
+    AppendValueToBuffer(data, location);
+
+    input.name_offset = data->size();
+    input.name_length = length;
+    AppendStringToBuffer(data, attrib_name_buf.data(), length);
+
+    InsertValueIntoBuffer(
+        data, input,
+        sizeof(ProgramInfoHeader) + (attrib_index * sizeof(ProgramInput)));
+  }
+
+  GLint active_uniform_max_length = 0;
+  glGetProgramiv(service_program, GL_ACTIVE_UNIFORM_MAX_LENGTH,
+                 &active_uniform_max_length);
+
+  std::vector<char> uniform_name_buf(active_uniform_max_length, 0);
+  for (GLint uniform_index = 0; uniform_index < num_uniforms; uniform_index++) {
+    GLsizei length = 0;
+    GLint size = 0;
+    GLenum type = GL_NONE;
+    glGetActiveUniform(service_program, uniform_index, uniform_name_buf.size(),
+                       &length, &size, &type, uniform_name_buf.data());
+
+    ProgramInput input;
+    input.size = size;
+    input.type = type;
+
+    input.location_offset = data->size();
+    int32_t base_location =
+        glGetUniformLocation(service_program, uniform_name_buf.data());
+    AppendValueToBuffer(data, base_location);
+
+    GLSLArrayName parsed_service_name(uniform_name_buf.data());
+    if (size > 1 || parsed_service_name.IsArrayName()) {
+      for (GLint location_index = 1; location_index < size; location_index++) {
+        std::string array_element_name = parsed_service_name.base_name() + "[" +
+                                         base::IntToString(location_index) +
+                                         "]";
+        int32_t element_location =
+            glGetUniformLocation(service_program, array_element_name.c_str());
+        AppendValueToBuffer(data, element_location);
+      }
+    }
+
+    input.name_offset = data->size();
+    input.name_length = length;
+    AppendStringToBuffer(data, uniform_name_buf.data(), length);
+
+    InsertValueIntoBuffer(data, input, sizeof(ProgramInfoHeader) +
+                                           ((num_attributes + uniform_index) *
+                                            sizeof(ProgramInput)));
+  }
+
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformBlocksCHROMIUM(
     GLuint program,
     std::vector<uint8_t>* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::DoGetTransformFeedbackVaryingsCHROMIUM(
     GLuint program,
     std::vector<uint8_t>* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetUniformsES3CHROMIUM(
     GLuint program,
     std::vector<uint8_t>* data) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetTranslatedShaderSourceANGLE(
     GLuint shader,
     std::string* source) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPostSubBufferCHROMIUM(
     GLint x,
     GLint y,
     GLint width,
     GLint height) {
+  gfx::SwapResult result = surface_->PostSubBuffer(x, y, width, height);
+  if (result == gfx::SwapResult::SWAP_FAILED) {
+    LOG(ERROR) << "Context lost because PostSubBuffer failed.";
+  }
+  // TODO(geofflang): force the context loss?
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCopyTextureCHROMIUM(
     GLenum source_id,
     GLenum dest_id,
     GLint internalformat,
     GLenum dest_type,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
+  glCopyTextureCHROMIUM(
+      resources_->texture_id_map.GetServiceIDOrReserve(source_id),
+      resources_->texture_id_map.GetServiceIDOrReserve(dest_id), internalformat,
+      dest_type, unpack_flip_y, unpack_premultiply_alpha,
+      unpack_unmultiply_alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCopySubTextureCHROMIUM(
     GLenum source_id,
     GLenum dest_id,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
+  glCopySubTextureCHROMIUM(
+      resources_->texture_id_map.GetServiceIDOrReserve(source_id),
+      resources_->texture_id_map.GetServiceIDOrReserve(dest_id), xoffset,
+      yoffset, x, y, width, height, unpack_flip_y, unpack_premultiply_alpha,
+      unpack_unmultiply_alpha);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCompressedCopyTextureCHROMIUM(
     GLenum source_id,
     GLenum dest_id) {
+  glCompressedCopyTextureCHROMIUM(
+      resources_->texture_id_map.GetServiceIDOrReserve(source_id),
+      resources_->texture_id_map.GetServiceIDOrReserve(dest_id));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDrawArraysInstancedANGLE(
     GLenum mode,
     GLint first,
     GLsizei count,
     GLsizei primcount) {
+  glDrawArraysInstancedANGLE(mode, first, count, primcount);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDrawElementsInstancedANGLE(
     GLenum mode,
     GLsizei count,
     GLenum type,
     const void* indices,
     GLsizei primcount) {
+  glDrawElementsInstancedANGLE(mode, count, type, indices, primcount);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoVertexAttribDivisorANGLE(
     GLuint index,
     GLuint divisor) {
+  glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoProduceTextureCHROMIUM(
     GLenum target,
     const volatile GLbyte* mailbox) {
+  // TODO(geofflang): validation
+
+  GLuint texture = bound_textures_[active_texture_unit_];
+  TexturePassthrough* texture_passthrough = nullptr;

[piman, 2016/09/13 01:07:32]

nit: scoped_refptr<TexturePassthrough>

[Geoff Lang, 2016/09/13 17:49:57]

Done.

+
+  auto texture_object_iter = resources_->texture_object_map.find(texture);
+  if (texture_object_iter != resources_->texture_object_map.end()) {
+    texture_passthrough = texture_object_iter->second.get();
+  } else {
+    GLuint service_id =
+        resources_->texture_id_map.GetServiceIDOrReserve(texture);
+    texture_passthrough = new TexturePassthrough(service_id);
+    resources_->texture_object_map.insert(
+        std::make_pair(texture, texture_passthrough));
+  }
+
+  const Mailbox& mb = Mailbox::FromVolatile(
+      *reinterpret_cast<const volatile Mailbox*>(mailbox));
+  mailbox_manager_->ProduceTexture(mb, texture_passthrough);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoProduceTextureDirectCHROMIUM(
-    GLuint texture,
+    GLuint texture_client_id,
     GLenum target,
     const volatile GLbyte* mailbox) {
+  // TODO(geofflang): validation
+
+  TexturePassthrough* texture = nullptr;

[piman, 2016/09/13 01:07:32]

nit: scoped_refptr<TexturePassthrough>

[Geoff Lang, 2016/09/13 17:49:57]

Done.

+  auto texture_object_iter =
+      resources_->texture_object_map.find(texture_client_id);
+  if (texture_object_iter != resources_->texture_object_map.end()) {
+    texture = texture_object_iter->second.get();
+  } else {
+    GLuint service_id =
+        resources_->texture_id_map.GetServiceIDOrReserve(texture_client_id);
+    texture = new TexturePassthrough(service_id);
+    resources_->texture_object_map.insert(
+        std::make_pair(texture_client_id, texture));
+  }
+
+  const Mailbox& mb = Mailbox::FromVolatile(
+      *reinterpret_cast<const volatile Mailbox*>(mailbox));
+  mailbox_manager_->ProduceTexture(mb, texture);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoConsumeTextureCHROMIUM(
     GLenum target,
     const volatile GLbyte* mailbox) {
+  // TODO(geofflang): validation
+
+  const Mailbox& mb = Mailbox::FromVolatile(
+      *reinterpret_cast<const volatile Mailbox*>(mailbox));
+  TexturePassthrough* texture = static_cast<TexturePassthrough*>(
+      group_->mailbox_manager()->ConsumeTexture(mb));
+  if (texture == nullptr) {
+    // TODO(geofflang): error, missing mailbox
+    return error::kNoError;
+  }
+
+  GLuint client_id = bound_textures_[active_texture_unit_];
+  resources_->texture_id_map.SetIDMapping(client_id, texture->service_id());
+  resources_->texture_object_map.erase(client_id);
+  resources_->texture_object_map.insert(std::make_pair(client_id, texture));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCreateAndConsumeTextureINTERNAL(
     GLenum target,
-    GLuint texture,
+    GLuint texture_client_id,
     const volatile GLbyte* mailbox) {
+  // TODO(geofflang): validation
+
+  if (resources_->texture_id_map.GetServiceID(texture_client_id, nullptr)) {
+    return error::kInvalidArguments;
+  }
+  const Mailbox& mb = Mailbox::FromVolatile(
+      *reinterpret_cast<const volatile Mailbox*>(mailbox));
+  TexturePassthrough* texture = static_cast<TexturePassthrough*>(
+      group_->mailbox_manager()->ConsumeTexture(mb));
+  if (texture == nullptr) {
+    // TODO(geofflang): error, missing mailbox
+    return error::kNoError;
+  }
+
+  resources_->texture_id_map.SetIDMapping(texture_client_id,
+                                          texture->service_id());
+  resources_->texture_object_map.erase(texture_client_id);
+  resources_->texture_object_map.insert(
+      std::make_pair(texture_client_id, texture));
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindUniformLocationCHROMIUM(
     GLuint program,
     GLint location,
     const char* name) {
+  glBindUniformLocationCHROMIUM(
+      resources_->program_id_map.GetServiceIDOrReserve(program), location,
+      name);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindTexImage2DCHROMIUM(
     GLenum target,
     GLint imageId) {
+  // TODO(geofflang): error handling
+  gl::GLImage* image = image_manager_->LookupImage(imageId);
+  if (!image->BindTexImage(target)) {
+    image->CopyTexImage(target);
+  }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoReleaseTexImage2DCHROMIUM(
     GLenum target,
     GLint imageId) {
+  // TODO(geofflang): error handling
+  gl::GLImage* image = image_manager_->LookupImage(imageId);
+  image->ReleaseTexImage(target);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTraceBeginCHROMIUM(
     const char* category_name,
     const char* trace_name) {
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoTraceEndCHROMIUM() {
+  // NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDiscardFramebufferEXT(
     GLenum target,
     GLsizei count,
     const volatile GLenum* attachments) {
+  std::vector<GLenum> attachments_copy(attachments, attachments + count);
+  glDiscardFramebufferEXT(target, count, attachments_copy.data());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoLoseContextCHROMIUM(GLenum current,
                                                                 GLenum other) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDescheduleUntilFinishedCHROMIUM() {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoInsertFenceSyncCHROMIUM(
     GLuint64 release_count) {
+  if (!fence_sync_release_callback_.is_null())
+    fence_sync_release_callback_.Run(release_count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoWaitSyncTokenCHROMIUM(
     CommandBufferNamespace namespace_id,
     CommandBufferId command_buffer_id,
     GLuint64 release_count) {
-  return error::kNoError;
+  if (wait_fence_sync_callback_.is_null()) {
+    return error::kNoError;
+  }
+  return wait_fence_sync_callback_.Run(namespace_id, command_buffer_id,
+                                       release_count)
+             ? error::kNoError
+             : error::kDeferCommandUntilLater;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDrawBuffersEXT(
     GLsizei count,
     const volatile GLenum* bufs) {
+  std::vector<GLenum> bufs_copy(bufs, bufs + count);
+  glDrawBuffersARB(count, bufs_copy.data());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDiscardBackbufferCHROMIUM() {
+  // CHECK(false) << "UNIMPLEMENTED";

[piman, 2016/09/13 01:07:32]

nit: remove commented code

[Geoff Lang, 2016/09/13 17:49:57]

Done.

   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoScheduleOverlayPlaneCHROMIUM(
     GLint plane_z_order,
     GLenum plane_transform,
     GLuint overlay_texture_id,
     GLint bounds_x,
     GLint bounds_y,
     GLint bounds_width,
     GLint bounds_height,
     GLfloat uv_x,
     GLfloat uv_y,
     GLfloat uv_width,
     GLfloat uv_height) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoScheduleCALayerSharedStateCHROMIUM(
     GLfloat opacity,
     GLboolean is_clipped,
     const GLfloat* clip_rect,
     GLint sorting_context_id,
     const GLfloat* transform) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoScheduleCALayerCHROMIUM(
     GLuint contents_texture_id,
     const GLfloat* contents_rect,
     GLuint background_color,
     GLuint edge_aa_mask,
     const GLfloat* bounds_rect) {
+  CHECK(false) << "UNIMPLEMENTED";

[piman, 2016/09/13 01:07:32]

nit: (here and below) just use NOTIMPLEMENTED() - no need to abort.

[Geoff Lang, 2016/09/13 17:49:57]

Done.

   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoScheduleCALayerInUseQueryCHROMIUM(
     GLuint n,
     const volatile GLuint* textures) {
+  CHECK(false) << "UNIMPLEMENTED";
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCommitOverlayPlanesCHROMIUM() {
+  CHECK(false) << "UNIMPLEMENTED";
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoSwapInterval(GLint interval) {
+  context_->SetSwapInterval(interval);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoFlushDriverCachesCHROMIUM() {
+  // NOTIMPLEMENTED();

[piman, 2016/09/13 01:07:32]

nit: remove commented code.

[Geoff Lang, 2016/09/13 17:49:57]

Done.

   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoMatrixLoadfCHROMIUM(
     GLenum matrixMode,
     const volatile GLfloat* m) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoMatrixLoadIdentityCHROMIUM(
     GLenum matrixMode) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGenPathsCHROMIUM(GLuint path,
                                                              GLsizei range) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoDeletePathsCHROMIUM(GLuint path,
                                                                 GLsizei range) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoIsPathCHROMIUM(GLuint path,
                                                            uint32_t* result) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPathCommandsCHROMIUM(
     GLuint path,
     GLsizei numCommands,
     const GLubyte* commands,
     GLsizei numCoords,
     GLenum coordType,
     const GLvoid* coords,
     GLsizei coords_bufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPathParameterfCHROMIUM(
     GLuint path,
     GLenum pname,
     GLfloat value) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPathParameteriCHROMIUM(
     GLuint path,
     GLenum pname,
     GLint value) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoPathStencilFuncCHROMIUM(
     GLenum func,
     GLint ref,
     GLuint mask) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilFillPathCHROMIUM(
     GLuint path,
     GLenum fillMode,
     GLuint mask) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilStrokePathCHROMIUM(
     GLuint path,
     GLint reference,
     GLuint mask) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCoverFillPathCHROMIUM(
     GLuint path,
     GLenum coverMode) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCoverStrokePathCHROMIUM(
     GLuint path,
     GLenum coverMode) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilThenCoverFillPathCHROMIUM(
     GLuint path,
     GLenum fillMode,
     GLuint mask,
     GLenum coverMode) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilThenCoverStrokePathCHROMIUM(
     GLuint path,
     GLint reference,
     GLuint mask,
     GLenum coverMode) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilFillPathInstancedCHROMIUM(
     GLsizei numPaths,
     GLenum pathNameType,
     const GLvoid* paths,
     GLsizei pathsBufsize,
     GLuint pathBase,
     GLenum fillMode,
     GLuint mask,
     GLenum transformType,
     const GLfloat* transformValues,
     GLsizei transformValuesBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoStencilStrokePathInstancedCHROMIUM(
     GLsizei numPaths,
     GLenum pathNameType,
     const GLvoid* paths,
     GLsizei pathsBufsize,
     GLuint pathBase,
     GLint reference,
     GLuint mask,
     GLenum transformType,
     const GLfloat* transformValues,
     GLsizei transformValuesBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCoverFillPathInstancedCHROMIUM(
     GLsizei numPaths,
     GLenum pathNameType,
     const GLvoid* paths,
     GLsizei pathsBufsize,
     GLuint pathBase,
     GLenum coverMode,
     GLenum transformType,
     const GLfloat* transformValues,
     GLsizei transformValuesBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCoverStrokePathInstancedCHROMIUM(
     GLsizei numPaths,
     GLenum pathNameType,
     const GLvoid* paths,
     GLsizei pathsBufsize,
     GLuint pathBase,
     GLenum coverMode,
     GLenum transformType,
     const GLfloat* transformValues,
     GLsizei transformValuesBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::DoStencilThenCoverFillPathInstancedCHROMIUM(
     GLsizei numPaths,
     GLenum pathNameType,
     const GLvoid* paths,
     GLsizei pathsBufsize,
     GLuint pathBase,
     GLenum fillMode,
     GLuint mask,
     GLenum coverMode,
     GLenum transformType,
     const GLfloat* transformValues,
     GLsizei transformValuesBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::DoStencilThenCoverStrokePathInstancedCHROMIUM(
     GLsizei numPaths,
     GLenum pathNameType,
     const GLvoid* paths,
     GLsizei pathsBufsize,
     GLuint pathBase,
     GLint reference,
     GLuint mask,
     GLenum coverMode,
     GLenum transformType,
     const GLfloat* transformValues,
     GLsizei transformValuesBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindFragmentInputLocationCHROMIUM(
     GLuint program,
     GLint location,
     const char* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoProgramPathFragmentInputGenCHROMIUM(
     GLuint program,
     GLint location,
     GLenum genMode,
     GLint components,
     const GLfloat* coeffs,
     GLsizei coeffsBufsize) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoCoverageModulationCHROMIUM(
     GLenum components) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBlendBarrierKHR() {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::DoApplyScreenSpaceAntialiasingCHROMIUM() {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindFragDataLocationIndexedEXT(
     GLuint program,
     GLuint colorNumber,
     GLuint index,
     const char* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoBindFragDataLocationEXT(
     GLuint program,
     GLuint colorNumber,
     const char* name) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderPassthroughImpl::DoGetFragDataIndexEXT(
     GLuint program,
     const char* name,
     GLint* index) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderPassthroughImpl::DoUniformMatrix4fvStreamTextureMatrixCHROMIUM(
     GLint location,
     GLboolean transpose,
     const volatile GLfloat* defaultValue) {
+  NOTIMPLEMENTED();
   return error::kNoError;
 }
 
 }  // namespace gles2
 }  // namespace gpu