Update To 11.40.268.0
[platform/framework/web/crosswalk.git] / src / ppapi / shared_impl / ppb_opengles2_shared.cc
index 534e816..32bb547 100644 (file)
@@ -1,9 +1,11 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2014 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.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
+// It's formatted by clang-format using chromium coding style:
+//    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
 #include "ppapi/shared_impl/ppb_opengles2_shared.h"
@@ -39,8 +41,10 @@ void AttachShader(PP_Resource context_id, GLuint program, GLuint shader) {
   }
 }
 
-void BindAttribLocation(
-    PP_Resource context_id, GLuint program, GLuint index, const char* name) {
+void BindAttribLocation(PP_Resource context_id,
+                        GLuint program,
+                        GLuint index,
+                        const char* name) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BindAttribLocation(program, index, name);
@@ -54,16 +58,18 @@ void BindBuffer(PP_Resource context_id, GLenum target, GLuint buffer) {
   }
 }
 
-void BindFramebuffer(
-    PP_Resource context_id, GLenum target, GLuint framebuffer) {
+void BindFramebuffer(PP_Resource context_id,
+                     GLenum target,
+                     GLuint framebuffer) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BindFramebuffer(target, framebuffer);
   }
 }
 
-void BindRenderbuffer(
-    PP_Resource context_id, GLenum target, GLuint renderbuffer) {
+void BindRenderbuffer(PP_Resource context_id,
+                      GLenum target,
+                      GLuint renderbuffer) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BindRenderbuffer(target, renderbuffer);
@@ -77,9 +83,11 @@ void BindTexture(PP_Resource context_id, GLenum target, GLuint texture) {
   }
 }
 
-void BlendColor(
-    PP_Resource context_id, GLclampf red, GLclampf green, GLclampf blue,
-    GLclampf alpha) {
+void BlendColor(PP_Resource context_id,
+                GLclampf red,
+                GLclampf green,
+                GLclampf blue,
+                GLclampf alpha) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BlendColor(red, green, blue, alpha);
@@ -93,8 +101,9 @@ void BlendEquation(PP_Resource context_id, GLenum mode) {
   }
 }
 
-void BlendEquationSeparate(
-    PP_Resource context_id, GLenum modeRGB, GLenum modeAlpha) {
+void BlendEquationSeparate(PP_Resource context_id,
+                           GLenum modeRGB,
+                           GLenum modeAlpha) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BlendEquationSeparate(modeRGB, modeAlpha);
@@ -108,27 +117,33 @@ void BlendFunc(PP_Resource context_id, GLenum sfactor, GLenum dfactor) {
   }
 }
 
-void BlendFuncSeparate(
-    PP_Resource context_id, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
-    GLenum dstAlpha) {
+void BlendFuncSeparate(PP_Resource context_id,
+                       GLenum srcRGB,
+                       GLenum dstRGB,
+                       GLenum srcAlpha,
+                       GLenum dstAlpha) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
   }
 }
 
-void BufferData(
-    PP_Resource context_id, GLenum target, GLsizeiptr size, const void* data,
-    GLenum usage) {
+void BufferData(PP_Resource context_id,
+                GLenum target,
+                GLsizeiptr size,
+                const void* data,
+                GLenum usage) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BufferData(target, size, data, usage);
   }
 }
 
-void BufferSubData(
-    PP_Resource context_id, GLenum target, GLintptr offset, GLsizeiptr size,
-    const void* data) {
+void BufferSubData(PP_Resource context_id,
+                   GLenum target,
+                   GLintptr offset,
+                   GLsizeiptr size,
+                   const void* data) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BufferSubData(target, offset, size, data);
@@ -151,9 +166,11 @@ void Clear(PP_Resource context_id, GLbitfield mask) {
   }
 }
 
-void ClearColor(
-    PP_Resource context_id, GLclampf red, GLclampf green, GLclampf blue,
-    GLclampf alpha) {
+void ClearColor(PP_Resource context_id,
+                GLclampf red,
+                GLclampf green,
+                GLclampf blue,
+                GLclampf alpha) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ClearColor(red, green, blue, alpha);
@@ -174,9 +191,11 @@ void ClearStencil(PP_Resource context_id, GLint s) {
   }
 }
 
-void ColorMask(
-    PP_Resource context_id, GLboolean red, GLboolean green, GLboolean blue,
-    GLboolean alpha) {
+void ColorMask(PP_Resource context_id,
+               GLboolean red,
+               GLboolean green,
+               GLboolean blue,
+               GLboolean alpha) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ColorMask(red, green, blue, alpha);
@@ -190,51 +209,69 @@ void CompileShader(PP_Resource context_id, GLuint shader) {
   }
 }
 
-void CompressedTexImage2D(
-    PP_Resource context_id, GLenum target, GLint level, GLenum internalformat,
-    GLsizei width, GLsizei height, GLint border, GLsizei imageSize,
-    const void* data) {
+void CompressedTexImage2D(PP_Resource context_id,
+                          GLenum target,
+                          GLint level,
+                          GLenum internalformat,
+                          GLsizei width,
+                          GLsizei height,
+                          GLint border,
+                          GLsizei imageSize,
+                          const void* data) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->CompressedTexImage2D(
-            target, level, internalformat, width, height, border, imageSize,
-            data);
+    ToGles2Impl(&enter)->CompressedTexImage2D(
+        target, level, internalformat, width, height, border, imageSize, data);
   }
 }
 
-void CompressedTexSubImage2D(
-    PP_Resource context_id, GLenum target, GLint level, GLint xoffset,
-    GLint yoffset, GLsizei width, GLsizei height, GLenum format,
-    GLsizei imageSize, const void* data) {
+void CompressedTexSubImage2D(PP_Resource context_id,
+                             GLenum target,
+                             GLint level,
+                             GLint xoffset,
+                             GLint yoffset,
+                             GLsizei width,
+                             GLsizei height,
+                             GLenum format,
+                             GLsizei imageSize,
+                             const void* data) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->CompressedTexSubImage2D(
-            target, level, xoffset, yoffset, width, height, format, imageSize,
-            data);
+    ToGles2Impl(&enter)->CompressedTexSubImage2D(target, level, xoffset,
+                                                 yoffset, width, height, format,
+                                                 imageSize, data);
   }
 }
 
-void CopyTexImage2D(
-    PP_Resource context_id, GLenum target, GLint level, GLenum internalformat,
-    GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {
+void CopyTexImage2D(PP_Resource context_id,
+                    GLenum target,
+                    GLint level,
+                    GLenum internalformat,
+                    GLint x,
+                    GLint y,
+                    GLsizei width,
+                    GLsizei height,
+                    GLint border) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->CopyTexImage2D(
-            target, level, internalformat, x, y, width, height, border);
+    ToGles2Impl(&enter)->CopyTexImage2D(target, level, internalformat, x, y,
+                                        width, height, border);
   }
 }
 
-void CopyTexSubImage2D(
-    PP_Resource context_id, GLenum target, GLint level, GLint xoffset,
-    GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
+void CopyTexSubImage2D(PP_Resource context_id,
+                       GLenum target,
+                       GLint level,
+                       GLint xoffset,
+                       GLint yoffset,
+                       GLint x,
+                       GLint y,
+                       GLsizei width,
+                       GLsizei height) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->CopyTexSubImage2D(
-            target, level, xoffset, yoffset, x, y, width, height);
+    ToGles2Impl(&enter)->CopyTexSubImage2D(target, level, xoffset, yoffset, x,
+                                           y, width, height);
   }
 }
 
@@ -270,8 +307,9 @@ void DeleteBuffers(PP_Resource context_id, GLsizei n, const GLuint* buffers) {
   }
 }
 
-void DeleteFramebuffers(
-    PP_Resource context_id, GLsizei n, const GLuint* framebuffers) {
+void DeleteFramebuffers(PP_Resource context_id,
+                        GLsizei n,
+                        const GLuint* framebuffers) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteFramebuffers(n, framebuffers);
@@ -285,8 +323,9 @@ void DeleteProgram(PP_Resource context_id, GLuint program) {
   }
 }
 
-void DeleteRenderbuffers(
-    PP_Resource context_id, GLsizei n, const GLuint* renderbuffers) {
+void DeleteRenderbuffers(PP_Resource context_id,
+                         GLsizei n,
+                         const GLuint* renderbuffers) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteRenderbuffers(n, renderbuffers);
@@ -300,8 +339,7 @@ void DeleteShader(PP_Resource context_id, GLuint shader) {
   }
 }
 
-void DeleteTextures(
-    PP_Resource context_id, GLsizei n, const GLuint* textures) {
+void DeleteTextures(PP_Resource context_id, GLsizei n, const GLuint* textures) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteTextures(n, textures);
@@ -350,17 +388,21 @@ void DisableVertexAttribArray(PP_Resource context_id, GLuint index) {
   }
 }
 
-void DrawArrays(
-    PP_Resource context_id, GLenum mode, GLint first, GLsizei count) {
+void DrawArrays(PP_Resource context_id,
+                GLenum mode,
+                GLint first,
+                GLsizei count) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DrawArrays(mode, first, count);
   }
 }
 
-void DrawElements(
-    PP_Resource context_id, GLenum mode, GLsizei count, GLenum type,
-    const void* indices) {
+void DrawElements(PP_Resource context_id,
+                  GLenum mode,
+                  GLsizei count,
+                  GLenum type,
+                  const void* indices) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DrawElements(mode, count, type, indices);
@@ -395,25 +437,28 @@ void Flush(PP_Resource context_id) {
   }
 }
 
-void FramebufferRenderbuffer(
-    PP_Resource context_id, GLenum target, GLenum attachment,
-    GLenum renderbuffertarget, GLuint renderbuffer) {
+void FramebufferRenderbuffer(PP_Resource context_id,
+                             GLenum target,
+                             GLenum attachment,
+                             GLenum renderbuffertarget,
+                             GLuint renderbuffer) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->FramebufferRenderbuffer(
-            target, attachment, renderbuffertarget, renderbuffer);
+    ToGles2Impl(&enter)->FramebufferRenderbuffer(
+        target, attachment, renderbuffertarget, renderbuffer);
   }
 }
 
-void FramebufferTexture2D(
-    PP_Resource context_id, GLenum target, GLenum attachment, GLenum textarget,
-    GLuint texture, GLint level) {
+void FramebufferTexture2D(PP_Resource context_id,
+                          GLenum target,
+                          GLenum attachment,
+                          GLenum textarget,
+                          GLuint texture,
+                          GLint level) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->FramebufferTexture2D(
-            target, attachment, textarget, texture, level);
+    ToGles2Impl(&enter)
+        ->FramebufferTexture2D(target, attachment, textarget, texture, level);
   }
 }
 
@@ -445,8 +490,9 @@ void GenFramebuffers(PP_Resource context_id, GLsizei n, GLuint* framebuffers) {
   }
 }
 
-void GenRenderbuffers(
-    PP_Resource context_id, GLsizei n, GLuint* renderbuffers) {
+void GenRenderbuffers(PP_Resource context_id,
+                      GLsizei n,
+                      GLuint* renderbuffers) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GenRenderbuffers(n, renderbuffers);
@@ -460,39 +506,50 @@ void GenTextures(PP_Resource context_id, GLsizei n, GLuint* textures) {
   }
 }
 
-void GetActiveAttrib(
-    PP_Resource context_id, GLuint program, GLuint index, GLsizei bufsize,
-    GLsizei* length, GLint* size, GLenum* type, char* name) {
+void GetActiveAttrib(PP_Resource context_id,
+                     GLuint program,
+                     GLuint index,
+                     GLsizei bufsize,
+                     GLsizei* length,
+                     GLint* size,
+                     GLenum* type,
+                     char* name) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->GetActiveAttrib(
-            program, index, bufsize, length, size, type, name);
+    ToGles2Impl(&enter)
+        ->GetActiveAttrib(program, index, bufsize, length, size, type, name);
   }
 }
 
-void GetActiveUniform(
-    PP_Resource context_id, GLuint program, GLuint index, GLsizei bufsize,
-    GLsizei* length, GLint* size, GLenum* type, char* name) {
+void GetActiveUniform(PP_Resource context_id,
+                      GLuint program,
+                      GLuint index,
+                      GLsizei bufsize,
+                      GLsizei* length,
+                      GLint* size,
+                      GLenum* type,
+                      char* name) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->GetActiveUniform(
-            program, index, bufsize, length, size, type, name);
+    ToGles2Impl(&enter)
+        ->GetActiveUniform(program, index, bufsize, length, size, type, name);
   }
 }
 
-void GetAttachedShaders(
-    PP_Resource context_id, GLuint program, GLsizei maxcount, GLsizei* count,
-    GLuint* shaders) {
+void GetAttachedShaders(PP_Resource context_id,
+                        GLuint program,
+                        GLsizei maxcount,
+                        GLsizei* count,
+                        GLuint* shaders) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetAttachedShaders(program, maxcount, count, shaders);
   }
 }
 
-GLint GetAttribLocation(
-    PP_Resource context_id, GLuint program, const char* name) {
+GLint GetAttribLocation(PP_Resource context_id,
+                        GLuint program,
+                        const char* name) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->GetAttribLocation(program, name);
@@ -508,8 +565,10 @@ void GetBooleanv(PP_Resource context_id, GLenum pname, GLboolean* params) {
   }
 }
 
-void GetBufferParameteriv(
-    PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
+void GetBufferParameteriv(PP_Resource context_id,
+                          GLenum target,
+                          GLenum pname,
+                          GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetBufferParameteriv(target, pname, params);
@@ -532,14 +591,15 @@ void GetFloatv(PP_Resource context_id, GLenum pname, GLfloat* params) {
   }
 }
 
-void GetFramebufferAttachmentParameteriv(
-    PP_Resource context_id, GLenum target, GLenum attachment, GLenum pname,
-    GLint* params) {
+void GetFramebufferAttachmentParameteriv(PP_Resource context_id,
+                                         GLenum target,
+                                         GLenum attachment,
+                                         GLenum pname,
+                                         GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->GetFramebufferAttachmentParameteriv(
-            target, attachment, pname, params);
+    ToGles2Impl(&enter)->GetFramebufferAttachmentParameteriv(target, attachment,
+                                                             pname, params);
   }
 }
 
@@ -550,62 +610,75 @@ void GetIntegerv(PP_Resource context_id, GLenum pname, GLint* params) {
   }
 }
 
-void GetProgramiv(
-    PP_Resource context_id, GLuint program, GLenum pname, GLint* params) {
+void GetProgramiv(PP_Resource context_id,
+                  GLuint program,
+                  GLenum pname,
+                  GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetProgramiv(program, pname, params);
   }
 }
 
-void GetProgramInfoLog(
-    PP_Resource context_id, GLuint program, GLsizei bufsize, GLsizei* length,
-    char* infolog) {
+void GetProgramInfoLog(PP_Resource context_id,
+                       GLuint program,
+                       GLsizei bufsize,
+                       GLsizei* length,
+                       char* infolog) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetProgramInfoLog(program, bufsize, length, infolog);
   }
 }
 
-void GetRenderbufferParameteriv(
-    PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
+void GetRenderbufferParameteriv(PP_Resource context_id,
+                                GLenum target,
+                                GLenum pname,
+                                GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetRenderbufferParameteriv(target, pname, params);
   }
 }
 
-void GetShaderiv(
-    PP_Resource context_id, GLuint shader, GLenum pname, GLint* params) {
+void GetShaderiv(PP_Resource context_id,
+                 GLuint shader,
+                 GLenum pname,
+                 GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetShaderiv(shader, pname, params);
   }
 }
 
-void GetShaderInfoLog(
-    PP_Resource context_id, GLuint shader, GLsizei bufsize, GLsizei* length,
-    char* infolog) {
+void GetShaderInfoLog(PP_Resource context_id,
+                      GLuint shader,
+                      GLsizei bufsize,
+                      GLsizei* length,
+                      char* infolog) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetShaderInfoLog(shader, bufsize, length, infolog);
   }
 }
 
-void GetShaderPrecisionFormat(
-    PP_Resource context_id, GLenum shadertype, GLenum precisiontype,
-    GLint* range, GLint* precision) {
+void GetShaderPrecisionFormat(PP_Resource context_id,
+                              GLenum shadertype,
+                              GLenum precisiontype,
+                              GLint* range,
+                              GLint* precision) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->GetShaderPrecisionFormat(
-            shadertype, precisiontype, range, precision);
+    ToGles2Impl(&enter)
+        ->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
   }
 }
 
-void GetShaderSource(
-    PP_Resource context_id, GLuint shader, GLsizei bufsize, GLsizei* length,
-    char* source) {
+void GetShaderSource(PP_Resource context_id,
+                     GLuint shader,
+                     GLsizei bufsize,
+                     GLsizei* length,
+                     char* source) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetShaderSource(shader, bufsize, length, source);
@@ -621,40 +694,49 @@ const GLubyte* GetString(PP_Resource context_id, GLenum name) {
   }
 }
 
-void GetTexParameterfv(
-    PP_Resource context_id, GLenum target, GLenum pname, GLfloat* params) {
+void GetTexParameterfv(PP_Resource context_id,
+                       GLenum target,
+                       GLenum pname,
+                       GLfloat* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetTexParameterfv(target, pname, params);
   }
 }
 
-void GetTexParameteriv(
-    PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
+void GetTexParameteriv(PP_Resource context_id,
+                       GLenum target,
+                       GLenum pname,
+                       GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetTexParameteriv(target, pname, params);
   }
 }
 
-void GetUniformfv(
-    PP_Resource context_id, GLuint program, GLint location, GLfloat* params) {
+void GetUniformfv(PP_Resource context_id,
+                  GLuint program,
+                  GLint location,
+                  GLfloat* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetUniformfv(program, location, params);
   }
 }
 
-void GetUniformiv(
-    PP_Resource context_id, GLuint program, GLint location, GLint* params) {
+void GetUniformiv(PP_Resource context_id,
+                  GLuint program,
+                  GLint location,
+                  GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetUniformiv(program, location, params);
   }
 }
 
-GLint GetUniformLocation(
-    PP_Resource context_id, GLuint program, const char* name) {
+GLint GetUniformLocation(PP_Resource context_id,
+                         GLuint program,
+                         const char* name) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->GetUniformLocation(program, name);
@@ -663,24 +745,30 @@ GLint GetUniformLocation(
   }
 }
 
-void GetVertexAttribfv(
-    PP_Resource context_id, GLuint index, GLenum pname, GLfloat* params) {
+void GetVertexAttribfv(PP_Resource context_id,
+                       GLuint index,
+                       GLenum pname,
+                       GLfloat* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetVertexAttribfv(index, pname, params);
   }
 }
 
-void GetVertexAttribiv(
-    PP_Resource context_id, GLuint index, GLenum pname, GLint* params) {
+void GetVertexAttribiv(PP_Resource context_id,
+                       GLuint index,
+                       GLenum pname,
+                       GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetVertexAttribiv(index, pname, params);
   }
 }
 
-void GetVertexAttribPointerv(
-    PP_Resource context_id, GLuint index, GLenum pname, void** pointer) {
+void GetVertexAttribPointerv(PP_Resource context_id,
+                             GLuint index,
+                             GLenum pname,
+                             void** pointer) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetVertexAttribPointerv(index, pname, pointer);
@@ -785,9 +873,14 @@ void PolygonOffset(PP_Resource context_id, GLfloat factor, GLfloat units) {
   }
 }
 
-void ReadPixels(
-    PP_Resource context_id, GLint x, GLint y, GLsizei width, GLsizei height,
-    GLenum format, GLenum type, void* pixels) {
+void ReadPixels(PP_Resource context_id,
+                GLint x,
+                GLint y,
+                GLsizei width,
+                GLsizei height,
+                GLenum format,
+                GLenum type,
+                void* pixels) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ReadPixels(x, y, width, height, format, type, pixels);
@@ -801,13 +894,15 @@ void ReleaseShaderCompiler(PP_Resource context_id) {
   }
 }
 
-void RenderbufferStorage(
-    PP_Resource context_id, GLenum target, GLenum internalformat, GLsizei width,
-    GLsizei height) {
+void RenderbufferStorage(PP_Resource context_id,
+                         GLenum target,
+                         GLenum internalformat,
+                         GLsizei width,
+                         GLsizei height) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->RenderbufferStorage(target, internalformat, width, height);
+    ToGles2Impl(&enter)
+        ->RenderbufferStorage(target, internalformat, width, height);
   }
 }
 
@@ -818,27 +913,34 @@ void SampleCoverage(PP_Resource context_id, GLclampf value, GLboolean invert) {
   }
 }
 
-void Scissor(
-    PP_Resource context_id, GLint x, GLint y, GLsizei width, GLsizei height) {
+void Scissor(PP_Resource context_id,
+             GLint x,
+             GLint y,
+             GLsizei width,
+             GLsizei height) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Scissor(x, y, width, height);
   }
 }
 
-void ShaderBinary(
-    PP_Resource context_id, GLsizei n, const GLuint* shaders,
-    GLenum binaryformat, const void* binary, GLsizei length) {
+void ShaderBinary(PP_Resource context_id,
+                  GLsizei n,
+                  const GLuint* shaders,
+                  GLenum binaryformat,
+                  const void* binary,
+                  GLsizei length) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->ShaderBinary(n, shaders, binaryformat, binary, length);
+    ToGles2Impl(&enter)->ShaderBinary(n, shaders, binaryformat, binary, length);
   }
 }
 
-void ShaderSource(
-    PP_Resource context_id, GLuint shader, GLsizei count, const char** str,
-    const GLint* length) {
+void ShaderSource(PP_Resource context_id,
+                  GLuint shader,
+                  GLsizei count,
+                  const char** str,
+                  const GLint* length) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ShaderSource(shader, count, str, length);
@@ -852,8 +954,11 @@ void StencilFunc(PP_Resource context_id, GLenum func, GLint ref, GLuint mask) {
   }
 }
 
-void StencilFuncSeparate(
-    PP_Resource context_id, GLenum face, GLenum func, GLint ref, GLuint mask) {
+void StencilFuncSeparate(PP_Resource context_id,
+                         GLenum face,
+                         GLenum func,
+                         GLint ref,
+                         GLuint mask) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->StencilFuncSeparate(face, func, ref, mask);
@@ -874,79 +979,98 @@ void StencilMaskSeparate(PP_Resource context_id, GLenum face, GLuint mask) {
   }
 }
 
-void StencilOp(
-    PP_Resource context_id, GLenum fail, GLenum zfail, GLenum zpass) {
+void StencilOp(PP_Resource context_id,
+               GLenum fail,
+               GLenum zfail,
+               GLenum zpass) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->StencilOp(fail, zfail, zpass);
   }
 }
 
-void StencilOpSeparate(
-    PP_Resource context_id, GLenum face, GLenum fail, GLenum zfail,
-    GLenum zpass) {
+void StencilOpSeparate(PP_Resource context_id,
+                       GLenum face,
+                       GLenum fail,
+                       GLenum zfail,
+                       GLenum zpass) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->StencilOpSeparate(face, fail, zfail, zpass);
   }
 }
 
-void TexImage2D(
-    PP_Resource context_id, GLenum target, GLint level, GLint internalformat,
-    GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
-    const void* pixels) {
+void TexImage2D(PP_Resource context_id,
+                GLenum target,
+                GLint level,
+                GLint internalformat,
+                GLsizei width,
+                GLsizei height,
+                GLint border,
+                GLenum format,
+                GLenum type,
+                const void* pixels) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->TexImage2D(
-            target, level, internalformat, width, height, border, format, type,
-            pixels);
+    ToGles2Impl(&enter)->TexImage2D(target, level, internalformat, width,
+                                    height, border, format, type, pixels);
   }
 }
 
-void TexParameterf(
-    PP_Resource context_id, GLenum target, GLenum pname, GLfloat param) {
+void TexParameterf(PP_Resource context_id,
+                   GLenum target,
+                   GLenum pname,
+                   GLfloat param) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->TexParameterf(target, pname, param);
   }
 }
 
-void TexParameterfv(
-    PP_Resource context_id, GLenum target, GLenum pname,
-    const GLfloat* params) {
+void TexParameterfv(PP_Resource context_id,
+                    GLenum target,
+                    GLenum pname,
+                    const GLfloat* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->TexParameterfv(target, pname, params);
   }
 }
 
-void TexParameteri(
-    PP_Resource context_id, GLenum target, GLenum pname, GLint param) {
+void TexParameteri(PP_Resource context_id,
+                   GLenum target,
+                   GLenum pname,
+                   GLint param) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->TexParameteri(target, pname, param);
   }
 }
 
-void TexParameteriv(
-    PP_Resource context_id, GLenum target, GLenum pname, const GLint* params) {
+void TexParameteriv(PP_Resource context_id,
+                    GLenum target,
+                    GLenum pname,
+                    const GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->TexParameteriv(target, pname, params);
   }
 }
 
-void TexSubImage2D(
-    PP_Resource context_id, GLenum target, GLint level, GLint xoffset,
-    GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
-    const void* pixels) {
+void TexSubImage2D(PP_Resource context_id,
+                   GLenum target,
+                   GLint level,
+                   GLint xoffset,
+                   GLint yoffset,
+                   GLsizei width,
+                   GLsizei height,
+                   GLenum format,
+                   GLenum type,
+                   const void* pixels) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->TexSubImage2D(
-            target, level, xoffset, yoffset, width, height, format, type,
-            pixels);
+    ToGles2Impl(&enter)->TexSubImage2D(target, level, xoffset, yoffset, width,
+                                       height, format, type, pixels);
   }
 }
 
@@ -957,8 +1081,10 @@ void Uniform1f(PP_Resource context_id, GLint location, GLfloat x) {
   }
 }
 
-void Uniform1fv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
+void Uniform1fv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLfloat* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform1fv(location, count, v);
@@ -972,8 +1098,10 @@ void Uniform1i(PP_Resource context_id, GLint location, GLint x) {
   }
 }
 
-void Uniform1iv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
+void Uniform1iv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLint* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform1iv(location, count, v);
@@ -987,8 +1115,10 @@ void Uniform2f(PP_Resource context_id, GLint location, GLfloat x, GLfloat y) {
   }
 }
 
-void Uniform2fv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
+void Uniform2fv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLfloat* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform2fv(location, count, v);
@@ -1002,101 +1132,129 @@ void Uniform2i(PP_Resource context_id, GLint location, GLint x, GLint y) {
   }
 }
 
-void Uniform2iv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
+void Uniform2iv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLint* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform2iv(location, count, v);
   }
 }
 
-void Uniform3f(
-    PP_Resource context_id, GLint location, GLfloat x, GLfloat y, GLfloat z) {
+void Uniform3f(PP_Resource context_id,
+               GLint location,
+               GLfloat x,
+               GLfloat y,
+               GLfloat z) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform3f(location, x, y, z);
   }
 }
 
-void Uniform3fv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
+void Uniform3fv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLfloat* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform3fv(location, count, v);
   }
 }
 
-void Uniform3i(
-    PP_Resource context_id, GLint location, GLint x, GLint y, GLint z) {
+void Uniform3i(PP_Resource context_id,
+               GLint location,
+               GLint x,
+               GLint y,
+               GLint z) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform3i(location, x, y, z);
   }
 }
 
-void Uniform3iv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
+void Uniform3iv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLint* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform3iv(location, count, v);
   }
 }
 
-void Uniform4f(
-    PP_Resource context_id, GLint location, GLfloat x, GLfloat y, GLfloat z,
-    GLfloat w) {
+void Uniform4f(PP_Resource context_id,
+               GLint location,
+               GLfloat x,
+               GLfloat y,
+               GLfloat z,
+               GLfloat w) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform4f(location, x, y, z, w);
   }
 }
 
-void Uniform4fv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLfloat* v) {
+void Uniform4fv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLfloat* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform4fv(location, count, v);
   }
 }
 
-void Uniform4i(
-    PP_Resource context_id, GLint location, GLint x, GLint y, GLint z,
-    GLint w) {
+void Uniform4i(PP_Resource context_id,
+               GLint location,
+               GLint x,
+               GLint y,
+               GLint z,
+               GLint w) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform4i(location, x, y, z, w);
   }
 }
 
-void Uniform4iv(
-    PP_Resource context_id, GLint location, GLsizei count, const GLint* v) {
+void Uniform4iv(PP_Resource context_id,
+                GLint location,
+                GLsizei count,
+                const GLint* v) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform4iv(location, count, v);
   }
 }
 
-void UniformMatrix2fv(
-    PP_Resource context_id, GLint location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void UniformMatrix2fv(PP_Resource context_id,
+                      GLint location,
+                      GLsizei count,
+                      GLboolean transpose,
+                      const GLfloat* value) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->UniformMatrix2fv(location, count, transpose, value);
   }
 }
 
-void UniformMatrix3fv(
-    PP_Resource context_id, GLint location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void UniformMatrix3fv(PP_Resource context_id,
+                      GLint location,
+                      GLsizei count,
+                      GLboolean transpose,
+                      const GLfloat* value) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->UniformMatrix3fv(location, count, transpose, value);
   }
 }
 
-void UniformMatrix4fv(
-    PP_Resource context_id, GLint location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void UniformMatrix4fv(PP_Resource context_id,
+                      GLint location,
+                      GLsizei count,
+                      GLboolean transpose,
+                      const GLfloat* value) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->UniformMatrix4fv(location, count, transpose, value);
@@ -1124,103 +1282,125 @@ void VertexAttrib1f(PP_Resource context_id, GLuint indx, GLfloat x) {
   }
 }
 
-void VertexAttrib1fv(
-    PP_Resource context_id, GLuint indx, const GLfloat* values) {
+void VertexAttrib1fv(PP_Resource context_id,
+                     GLuint indx,
+                     const GLfloat* values) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib1fv(indx, values);
   }
 }
 
-void VertexAttrib2f(
-    PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y) {
+void VertexAttrib2f(PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib2f(indx, x, y);
   }
 }
 
-void VertexAttrib2fv(
-    PP_Resource context_id, GLuint indx, const GLfloat* values) {
+void VertexAttrib2fv(PP_Resource context_id,
+                     GLuint indx,
+                     const GLfloat* values) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib2fv(indx, values);
   }
 }
 
-void VertexAttrib3f(
-    PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
+void VertexAttrib3f(PP_Resource context_id,
+                    GLuint indx,
+                    GLfloat x,
+                    GLfloat y,
+                    GLfloat z) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib3f(indx, x, y, z);
   }
 }
 
-void VertexAttrib3fv(
-    PP_Resource context_id, GLuint indx, const GLfloat* values) {
+void VertexAttrib3fv(PP_Resource context_id,
+                     GLuint indx,
+                     const GLfloat* values) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib3fv(indx, values);
   }
 }
 
-void VertexAttrib4f(
-    PP_Resource context_id, GLuint indx, GLfloat x, GLfloat y, GLfloat z,
-    GLfloat w) {
+void VertexAttrib4f(PP_Resource context_id,
+                    GLuint indx,
+                    GLfloat x,
+                    GLfloat y,
+                    GLfloat z,
+                    GLfloat w) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib4f(indx, x, y, z, w);
   }
 }
 
-void VertexAttrib4fv(
-    PP_Resource context_id, GLuint indx, const GLfloat* values) {
+void VertexAttrib4fv(PP_Resource context_id,
+                     GLuint indx,
+                     const GLfloat* values) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib4fv(indx, values);
   }
 }
 
-void VertexAttribPointer(
-    PP_Resource context_id, GLuint indx, GLint size, GLenum type,
-    GLboolean normalized, GLsizei stride, const void* ptr) {
+void VertexAttribPointer(PP_Resource context_id,
+                         GLuint indx,
+                         GLint size,
+                         GLenum type,
+                         GLboolean normalized,
+                         GLsizei stride,
+                         const void* ptr) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->VertexAttribPointer(
-            indx, size, type, normalized, stride, ptr);
+    ToGles2Impl(&enter)
+        ->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
   }
 }
 
-void Viewport(
-    PP_Resource context_id, GLint x, GLint y, GLsizei width, GLsizei height) {
+void Viewport(PP_Resource context_id,
+              GLint x,
+              GLint y,
+              GLsizei width,
+              GLsizei height) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Viewport(x, y, width, height);
   }
 }
 
-void BlitFramebufferEXT(
-    PP_Resource context_id, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-    GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
-    GLenum filter) {
+void BlitFramebufferEXT(PP_Resource context_id,
+                        GLint srcX0,
+                        GLint srcY0,
+                        GLint srcX1,
+                        GLint srcY1,
+                        GLint dstX0,
+                        GLint dstY0,
+                        GLint dstX1,
+                        GLint dstY1,
+                        GLbitfield mask,
+                        GLenum filter) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->BlitFramebufferEXT(
-            srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
-            filter);
+    ToGles2Impl(&enter)->BlitFramebufferCHROMIUM(
+        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   }
 }
 
-void RenderbufferStorageMultisampleEXT(
-    PP_Resource context_id, GLenum target, GLsizei samples,
-    GLenum internalformat, GLsizei width, GLsizei height) {
+void RenderbufferStorageMultisampleEXT(PP_Resource context_id,
+                                       GLenum target,
+                                       GLsizei samples,
+                                       GLenum internalformat,
+                                       GLsizei width,
+                                       GLsizei height) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->RenderbufferStorageMultisampleEXT(
-            target, samples, internalformat, width, height);
+    ToGles2Impl(&enter)->RenderbufferStorageMultisampleCHROMIUM(
+        target, samples, internalformat, width, height);
   }
 }
 
@@ -1231,8 +1411,9 @@ void GenQueriesEXT(PP_Resource context_id, GLsizei n, GLuint* queries) {
   }
 }
 
-void DeleteQueriesEXT(
-    PP_Resource context_id, GLsizei n, const GLuint* queries) {
+void DeleteQueriesEXT(PP_Resource context_id,
+                      GLsizei n,
+                      const GLuint* queries) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteQueriesEXT(n, queries);
@@ -1262,22 +1443,58 @@ void EndQueryEXT(PP_Resource context_id, GLenum target) {
   }
 }
 
-void GetQueryivEXT(
-    PP_Resource context_id, GLenum target, GLenum pname, GLint* params) {
+void GetQueryivEXT(PP_Resource context_id,
+                   GLenum target,
+                   GLenum pname,
+                   GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetQueryivEXT(target, pname, params);
   }
 }
 
-void GetQueryObjectuivEXT(
-    PP_Resource context_id, GLuint id, GLenum pname, GLuint* params) {
+void GetQueryObjectuivEXT(PP_Resource context_id,
+                          GLuint id,
+                          GLenum pname,
+                          GLuint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetQueryObjectuivEXT(id, pname, params);
   }
 }
 
+void GenVertexArraysOES(PP_Resource context_id, GLsizei n, GLuint* arrays) {
+  Enter3D enter(context_id, true);
+  if (enter.succeeded()) {
+    ToGles2Impl(&enter)->GenVertexArraysOES(n, arrays);
+  }
+}
+
+void DeleteVertexArraysOES(PP_Resource context_id,
+                           GLsizei n,
+                           const GLuint* arrays) {
+  Enter3D enter(context_id, true);
+  if (enter.succeeded()) {
+    ToGles2Impl(&enter)->DeleteVertexArraysOES(n, arrays);
+  }
+}
+
+GLboolean IsVertexArrayOES(PP_Resource context_id, GLuint array) {
+  Enter3D enter(context_id, true);
+  if (enter.succeeded()) {
+    return ToGles2Impl(&enter)->IsVertexArrayOES(array);
+  } else {
+    return GL_FALSE;
+  }
+}
+
+void BindVertexArrayOES(PP_Resource context_id, GLuint array) {
+  Enter3D enter(context_id, true);
+  if (enter.succeeded()) {
+    ToGles2Impl(&enter)->BindVertexArrayOES(array);
+  }
+}
+
 GLboolean EnableFeatureCHROMIUM(PP_Resource context_id, const char* feature) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
@@ -1287,13 +1504,15 @@ GLboolean EnableFeatureCHROMIUM(PP_Resource context_id, const char* feature) {
   }
 }
 
-void* MapBufferSubDataCHROMIUM(
-    PP_Resource context_id, GLuint target, GLintptr offset, GLsizeiptr size,
-    GLenum access) {
+void* MapBufferSubDataCHROMIUM(PP_Resource context_id,
+                               GLuint target,
+                               GLintptr offset,
+                               GLsizeiptr size,
+                               GLenum access) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    return ToGles2Impl(
-        &enter)->MapBufferSubDataCHROMIUM(target, offset, size, access);
+    return ToGles2Impl(&enter)
+        ->MapBufferSubDataCHROMIUM(target, offset, size, access);
   } else {
     return NULL;
   }
@@ -1306,16 +1525,20 @@ void UnmapBufferSubDataCHROMIUM(PP_Resource context_id, const void* mem) {
   }
 }
 
-void* MapTexSubImage2DCHROMIUM(
-    PP_Resource context_id, GLenum target, GLint level, GLint xoffset,
-    GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
-    GLenum access) {
+void* MapTexSubImage2DCHROMIUM(PP_Resource context_id,
+                               GLenum target,
+                               GLint level,
+                               GLint xoffset,
+                               GLint yoffset,
+                               GLsizei width,
+                               GLsizei height,
+                               GLenum format,
+                               GLenum type,
+                               GLenum access) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    return ToGles2Impl(
-        &enter)->MapTexSubImage2DCHROMIUM(
-            target, level, xoffset, yoffset, width, height, format, type,
-            access);
+    return ToGles2Impl(&enter)->MapTexSubImage2DCHROMIUM(
+        target, level, xoffset, yoffset, width, height, format, type, access);
   } else {
     return NULL;
   }
@@ -1328,228 +1551,253 @@ void UnmapTexSubImage2DCHROMIUM(PP_Resource context_id, const void* mem) {
   }
 }
 
-void DrawArraysInstancedANGLE(
-    PP_Resource context_id, GLenum mode, GLint first, GLsizei count,
-    GLsizei primcount) {
+void DrawArraysInstancedANGLE(PP_Resource context_id,
+                              GLenum mode,
+                              GLint first,
+                              GLsizei count,
+                              GLsizei primcount) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->DrawArraysInstancedANGLE(mode, first, count, primcount);
+    ToGles2Impl(&enter)
+        ->DrawArraysInstancedANGLE(mode, first, count, primcount);
   }
 }
 
-void DrawElementsInstancedANGLE(
-    PP_Resource context_id, GLenum mode, GLsizei count, GLenum type,
-    const void* indices, GLsizei primcount) {
+void DrawElementsInstancedANGLE(PP_Resource context_id,
+                                GLenum mode,
+                                GLsizei count,
+                                GLenum type,
+                                const void* indices,
+                                GLsizei primcount) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
-    ToGles2Impl(
-        &enter)->DrawElementsInstancedANGLE(
-            mode, count, type, indices, primcount);
+    ToGles2Impl(&enter)
+        ->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
   }
 }
 
-void VertexAttribDivisorANGLE(
-    PP_Resource context_id, GLuint index, GLuint divisor) {
+void VertexAttribDivisorANGLE(PP_Resource context_id,
+                              GLuint index,
+                              GLuint divisor) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttribDivisorANGLE(index, divisor);
   }
 }
 
+void DrawBuffersEXT(PP_Resource context_id, GLsizei count, const GLenum* bufs) {
+  Enter3D enter(context_id, true);
+  if (enter.succeeded()) {
+    ToGles2Impl(&enter)->DrawBuffersEXT(count, bufs);
+  }
+}
+
 }  // namespace
 const PPB_OpenGLES2* PPB_OpenGLES2_Shared::GetInterface() {
   static const struct PPB_OpenGLES2 ppb_opengles2 = {
-    &ActiveTexture,
-    &AttachShader,
-    &BindAttribLocation,
-    &BindBuffer,
-    &BindFramebuffer,
-    &BindRenderbuffer,
-    &BindTexture,
-    &BlendColor,
-    &BlendEquation,
-    &BlendEquationSeparate,
-    &BlendFunc,
-    &BlendFuncSeparate,
-    &BufferData,
-    &BufferSubData,
-    &CheckFramebufferStatus,
-    &Clear,
-    &ClearColor,
-    &ClearDepthf,
-    &ClearStencil,
-    &ColorMask,
-    &CompileShader,
-    &CompressedTexImage2D,
-    &CompressedTexSubImage2D,
-    &CopyTexImage2D,
-    &CopyTexSubImage2D,
-    &CreateProgram,
-    &CreateShader,
-    &CullFace,
-    &DeleteBuffers,
-    &DeleteFramebuffers,
-    &DeleteProgram,
-    &DeleteRenderbuffers,
-    &DeleteShader,
-    &DeleteTextures,
-    &DepthFunc,
-    &DepthMask,
-    &DepthRangef,
-    &DetachShader,
-    &Disable,
-    &DisableVertexAttribArray,
-    &DrawArrays,
-    &DrawElements,
-    &Enable,
-    &EnableVertexAttribArray,
-    &Finish,
-    &Flush,
-    &FramebufferRenderbuffer,
-    &FramebufferTexture2D,
-    &FrontFace,
-    &GenBuffers,
-    &GenerateMipmap,
-    &GenFramebuffers,
-    &GenRenderbuffers,
-    &GenTextures,
-    &GetActiveAttrib,
-    &GetActiveUniform,
-    &GetAttachedShaders,
-    &GetAttribLocation,
-    &GetBooleanv,
-    &GetBufferParameteriv,
-    &GetError,
-    &GetFloatv,
-    &GetFramebufferAttachmentParameteriv,
-    &GetIntegerv,
-    &GetProgramiv,
-    &GetProgramInfoLog,
-    &GetRenderbufferParameteriv,
-    &GetShaderiv,
-    &GetShaderInfoLog,
-    &GetShaderPrecisionFormat,
-    &GetShaderSource,
-    &GetString,
-    &GetTexParameterfv,
-    &GetTexParameteriv,
-    &GetUniformfv,
-    &GetUniformiv,
-    &GetUniformLocation,
-    &GetVertexAttribfv,
-    &GetVertexAttribiv,
-    &GetVertexAttribPointerv,
-    &Hint,
-    &IsBuffer,
-    &IsEnabled,
-    &IsFramebuffer,
-    &IsProgram,
-    &IsRenderbuffer,
-    &IsShader,
-    &IsTexture,
-    &LineWidth,
-    &LinkProgram,
-    &PixelStorei,
-    &PolygonOffset,
-    &ReadPixels,
-    &ReleaseShaderCompiler,
-    &RenderbufferStorage,
-    &SampleCoverage,
-    &Scissor,
-    &ShaderBinary,
-    &ShaderSource,
-    &StencilFunc,
-    &StencilFuncSeparate,
-    &StencilMask,
-    &StencilMaskSeparate,
-    &StencilOp,
-    &StencilOpSeparate,
-    &TexImage2D,
-    &TexParameterf,
-    &TexParameterfv,
-    &TexParameteri,
-    &TexParameteriv,
-    &TexSubImage2D,
-    &Uniform1f,
-    &Uniform1fv,
-    &Uniform1i,
-    &Uniform1iv,
-    &Uniform2f,
-    &Uniform2fv,
-    &Uniform2i,
-    &Uniform2iv,
-    &Uniform3f,
-    &Uniform3fv,
-    &Uniform3i,
-    &Uniform3iv,
-    &Uniform4f,
-    &Uniform4fv,
-    &Uniform4i,
-    &Uniform4iv,
-    &UniformMatrix2fv,
-    &UniformMatrix3fv,
-    &UniformMatrix4fv,
-    &UseProgram,
-    &ValidateProgram,
-    &VertexAttrib1f,
-    &VertexAttrib1fv,
-    &VertexAttrib2f,
-    &VertexAttrib2fv,
-    &VertexAttrib3f,
-    &VertexAttrib3fv,
-    &VertexAttrib4f,
-    &VertexAttrib4fv,
-    &VertexAttribPointer,
-    &Viewport
-  };
+      &ActiveTexture,
+      &AttachShader,
+      &BindAttribLocation,
+      &BindBuffer,
+      &BindFramebuffer,
+      &BindRenderbuffer,
+      &BindTexture,
+      &BlendColor,
+      &BlendEquation,
+      &BlendEquationSeparate,
+      &BlendFunc,
+      &BlendFuncSeparate,
+      &BufferData,
+      &BufferSubData,
+      &CheckFramebufferStatus,
+      &Clear,
+      &ClearColor,
+      &ClearDepthf,
+      &ClearStencil,
+      &ColorMask,
+      &CompileShader,
+      &CompressedTexImage2D,
+      &CompressedTexSubImage2D,
+      &CopyTexImage2D,
+      &CopyTexSubImage2D,
+      &CreateProgram,
+      &CreateShader,
+      &CullFace,
+      &DeleteBuffers,
+      &DeleteFramebuffers,
+      &DeleteProgram,
+      &DeleteRenderbuffers,
+      &DeleteShader,
+      &DeleteTextures,
+      &DepthFunc,
+      &DepthMask,
+      &DepthRangef,
+      &DetachShader,
+      &Disable,
+      &DisableVertexAttribArray,
+      &DrawArrays,
+      &DrawElements,
+      &Enable,
+      &EnableVertexAttribArray,
+      &Finish,
+      &Flush,
+      &FramebufferRenderbuffer,
+      &FramebufferTexture2D,
+      &FrontFace,
+      &GenBuffers,
+      &GenerateMipmap,
+      &GenFramebuffers,
+      &GenRenderbuffers,
+      &GenTextures,
+      &GetActiveAttrib,
+      &GetActiveUniform,
+      &GetAttachedShaders,
+      &GetAttribLocation,
+      &GetBooleanv,
+      &GetBufferParameteriv,
+      &GetError,
+      &GetFloatv,
+      &GetFramebufferAttachmentParameteriv,
+      &GetIntegerv,
+      &GetProgramiv,
+      &GetProgramInfoLog,
+      &GetRenderbufferParameteriv,
+      &GetShaderiv,
+      &GetShaderInfoLog,
+      &GetShaderPrecisionFormat,
+      &GetShaderSource,
+      &GetString,
+      &GetTexParameterfv,
+      &GetTexParameteriv,
+      &GetUniformfv,
+      &GetUniformiv,
+      &GetUniformLocation,
+      &GetVertexAttribfv,
+      &GetVertexAttribiv,
+      &GetVertexAttribPointerv,
+      &Hint,
+      &IsBuffer,
+      &IsEnabled,
+      &IsFramebuffer,
+      &IsProgram,
+      &IsRenderbuffer,
+      &IsShader,
+      &IsTexture,
+      &LineWidth,
+      &LinkProgram,
+      &PixelStorei,
+      &PolygonOffset,
+      &ReadPixels,
+      &ReleaseShaderCompiler,
+      &RenderbufferStorage,
+      &SampleCoverage,
+      &Scissor,
+      &ShaderBinary,
+      &ShaderSource,
+      &StencilFunc,
+      &StencilFuncSeparate,
+      &StencilMask,
+      &StencilMaskSeparate,
+      &StencilOp,
+      &StencilOpSeparate,
+      &TexImage2D,
+      &TexParameterf,
+      &TexParameterfv,
+      &TexParameteri,
+      &TexParameteriv,
+      &TexSubImage2D,
+      &Uniform1f,
+      &Uniform1fv,
+      &Uniform1i,
+      &Uniform1iv,
+      &Uniform2f,
+      &Uniform2fv,
+      &Uniform2i,
+      &Uniform2iv,
+      &Uniform3f,
+      &Uniform3fv,
+      &Uniform3i,
+      &Uniform3iv,
+      &Uniform4f,
+      &Uniform4fv,
+      &Uniform4i,
+      &Uniform4iv,
+      &UniformMatrix2fv,
+      &UniformMatrix3fv,
+      &UniformMatrix4fv,
+      &UseProgram,
+      &ValidateProgram,
+      &VertexAttrib1f,
+      &VertexAttrib1fv,
+      &VertexAttrib2f,
+      &VertexAttrib2fv,
+      &VertexAttrib3f,
+      &VertexAttrib3fv,
+      &VertexAttrib4f,
+      &VertexAttrib4fv,
+      &VertexAttribPointer,
+      &Viewport};
   return &ppb_opengles2;
 }
-const PPB_OpenGLES2InstancedArrays* PPB_OpenGLES2_Shared::GetInstancedArraysInterface() {  // NOLINT
+const PPB_OpenGLES2InstancedArrays*
+PPB_OpenGLES2_Shared::GetInstancedArraysInterface() {
   static const struct PPB_OpenGLES2InstancedArrays ppb_opengles2 = {
-    &DrawArraysInstancedANGLE,
-    &DrawElementsInstancedANGLE,
-    &VertexAttribDivisorANGLE
-  };
+      &DrawArraysInstancedANGLE,
+      &DrawElementsInstancedANGLE,
+      &VertexAttribDivisorANGLE};
   return &ppb_opengles2;
 }
-const PPB_OpenGLES2FramebufferBlit* PPB_OpenGLES2_Shared::GetFramebufferBlitInterface() {  // NOLINT
+const PPB_OpenGLES2FramebufferBlit*
+PPB_OpenGLES2_Shared::GetFramebufferBlitInterface() {
   static const struct PPB_OpenGLES2FramebufferBlit ppb_opengles2 = {
-    &BlitFramebufferEXT
-  };
+      &BlitFramebufferEXT};
   return &ppb_opengles2;
 }
-const PPB_OpenGLES2FramebufferMultisample* PPB_OpenGLES2_Shared::GetFramebufferMultisampleInterface() {  // NOLINT
+const PPB_OpenGLES2FramebufferMultisample*
+PPB_OpenGLES2_Shared::GetFramebufferMultisampleInterface() {
   static const struct PPB_OpenGLES2FramebufferMultisample ppb_opengles2 = {
-    &RenderbufferStorageMultisampleEXT
-  };
+      &RenderbufferStorageMultisampleEXT};
   return &ppb_opengles2;
 }
-const PPB_OpenGLES2ChromiumEnableFeature* PPB_OpenGLES2_Shared::GetChromiumEnableFeatureInterface() {  // NOLINT
+const PPB_OpenGLES2ChromiumEnableFeature*
+PPB_OpenGLES2_Shared::GetChromiumEnableFeatureInterface() {
   static const struct PPB_OpenGLES2ChromiumEnableFeature ppb_opengles2 = {
-    &EnableFeatureCHROMIUM
-  };
+      &EnableFeatureCHROMIUM};
   return &ppb_opengles2;
 }
-const PPB_OpenGLES2ChromiumMapSub* PPB_OpenGLES2_Shared::GetChromiumMapSubInterface() {  // NOLINT
+const PPB_OpenGLES2ChromiumMapSub*
+PPB_OpenGLES2_Shared::GetChromiumMapSubInterface() {
   static const struct PPB_OpenGLES2ChromiumMapSub ppb_opengles2 = {
-    &MapBufferSubDataCHROMIUM,
-    &UnmapBufferSubDataCHROMIUM,
-    &MapTexSubImage2DCHROMIUM,
-    &UnmapTexSubImage2DCHROMIUM
-  };
+      &MapBufferSubDataCHROMIUM,
+      &UnmapBufferSubDataCHROMIUM,
+      &MapTexSubImage2DCHROMIUM,
+      &UnmapTexSubImage2DCHROMIUM};
   return &ppb_opengles2;
 }
 const PPB_OpenGLES2Query* PPB_OpenGLES2_Shared::GetQueryInterface() {
   static const struct PPB_OpenGLES2Query ppb_opengles2 = {
-    &GenQueriesEXT,
-    &DeleteQueriesEXT,
-    &IsQueryEXT,
-    &BeginQueryEXT,
-    &EndQueryEXT,
-    &GetQueryivEXT,
-    &GetQueryObjectuivEXT
-  };
+      &GenQueriesEXT,
+      &DeleteQueriesEXT,
+      &IsQueryEXT,
+      &BeginQueryEXT,
+      &EndQueryEXT,
+      &GetQueryivEXT,
+      &GetQueryObjectuivEXT};
+  return &ppb_opengles2;
+}
+const PPB_OpenGLES2VertexArrayObject*
+PPB_OpenGLES2_Shared::GetVertexArrayObjectInterface() {
+  static const struct PPB_OpenGLES2VertexArrayObject ppb_opengles2 = {
+      &GenVertexArraysOES,
+      &DeleteVertexArraysOES,
+      &IsVertexArrayOES,
+      &BindVertexArrayOES};
+  return &ppb_opengles2;
+}
+const PPB_OpenGLES2DrawBuffers_Dev*
+PPB_OpenGLES2_Shared::GetDrawBuffersInterface() {
+  static const struct PPB_OpenGLES2DrawBuffers_Dev ppb_opengles2 = {
+      &DrawBuffersEXT};
   return &ppb_opengles2;
 }
 }  // namespace ppapi