Workaround Linux AMD driver bug where TEXTURE_MAX_ANISOTROPY init value is incorrect.

ppapi/shared_impl/ppb_opengles2_shared.cc

 // Copyright (c) 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
 // DO NOT EDIT!
 
 #include "ppapi/shared_impl/ppb_opengles2_shared.h"

[bajones, 2014/03/04 00:47:15]

Does this file contain anything other than style tweaks? If so I couldn't find
it. (Style changes are fine, I just don't want to miss functionality changes in
my review.)

[Zhenyao Mo, 2014/03/04 01:59:31]

I didn't touch this file at all.  It's all auto-generated.

 
 #include "base/logging.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
 #include "ppapi/thunk/enter.h"
 
 namespace ppapi {
 
 namespace {
 
@@ skipping 12 matching lines @@
   }
 }
 
 void AttachShader(PP_Resource context_id, GLuint program, GLuint shader) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->AttachShader(program, 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);
   }
 }
 
 void BindBuffer(PP_Resource context_id, GLenum target, GLuint buffer) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BindBuffer(target, 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);
   }
 }
 
 void BindTexture(PP_Resource context_id, GLenum target, GLuint texture) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BindTexture(target, 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);
   }
 }
 
 void BlendEquation(PP_Resource context_id, GLenum mode) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BlendEquation(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);
   }
 }
 
 void BlendFunc(PP_Resource context_id, GLenum sfactor, GLenum dfactor) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BlendFunc(sfactor, 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,

[yzshen1, 2014/03/04 05:51:15]

Please note that the old code conforms to Chromium style while the new code
doesn't.

[Zhenyao Mo, 2014/03/04 15:58:08]

Which part?  The new code also conforms I think.

+    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);
   }
 }
 
 GLenum CheckFramebufferStatus(PP_Resource context_id, GLenum target) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->CheckFramebufferStatus(target);
   } else {
     return 0;
   }
 }
 
 void Clear(PP_Resource context_id, GLbitfield mask) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Clear(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);
   }
 }
 
 void ClearDepthf(PP_Resource context_id, GLclampf depth) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ClearDepthf(depth);
   }
 }
 
 void ClearStencil(PP_Resource context_id, GLint s) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ClearStencil(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);
   }
 }
 
 void CompileShader(PP_Resource context_id, GLuint shader) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->CompileShader(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);
   }
 }
 
 GLuint CreateProgram(PP_Resource context_id) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->CreateProgram();
   } else {
     return 0;
   }
@@ skipping 15 matching lines @@
   }
 }
 
 void DeleteBuffers(PP_Resource context_id, GLsizei n, const GLuint* buffers) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteBuffers(n, 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);
   }
 }
 
 void DeleteProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteProgram(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);
   }
 }
 
 void DeleteShader(PP_Resource context_id, GLuint shader) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DeleteShader(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);
   }
 }
 
 void DepthFunc(PP_Resource context_id, GLenum func) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DepthFunc(func);
@@ skipping 28 matching lines @@
   }
 }
 
 void DisableVertexAttribArray(PP_Resource context_id, GLuint index) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->DisableVertexAttribArray(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);
   }
 }
 
 void Enable(PP_Resource context_id, GLenum cap) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Enable(cap);
@@ skipping 14 matching lines @@
   }
 }
 
 void Flush(PP_Resource context_id) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Flush();
   }
 }
 
-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);
   }
 }
 
 void FrontFace(PP_Resource context_id, GLenum mode) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->FrontFace(mode);
   }
 }
 
@@ skipping 11 matching lines @@
   }
 }
 
 void GenFramebuffers(PP_Resource context_id, GLsizei n, GLuint* framebuffers) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GenFramebuffers(n, 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);
   }
 }
 
 void GenTextures(PP_Resource context_id, GLsizei n, GLuint* textures) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GenTextures(n, 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);
   } else {
     return -1;
   }
 }
 
 void GetBooleanv(PP_Resource context_id, GLenum pname, GLboolean* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetBooleanv(pname, 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);
   }
 }
 
 GLenum GetError(PP_Resource context_id) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->GetError();
   } else {
     return 0;
   }
 }
 
 void GetFloatv(PP_Resource context_id, GLenum pname, GLfloat* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetFloatv(pname, 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);
   }
 }
 
 void GetIntegerv(PP_Resource context_id, GLenum pname, GLint* params) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GetIntegerv(pname, 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);
   }
 }
 
 const GLubyte* GetString(PP_Resource context_id, GLenum name) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->GetString(name);
   } else {
     return NULL;
   }
 }
 
-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);
   } else {
     return -1;
   }
 }
 
-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);
   }
 }
 
 void Hint(PP_Resource context_id, GLenum target, GLenum mode) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Hint(target, mode);
@@ skipping 84 matching lines @@
   }
 }
 
 void PolygonOffset(PP_Resource context_id, GLfloat factor, GLfloat units) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->PolygonOffset(factor, 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);
   }
 }
 
 void ReleaseShaderCompiler(PP_Resource context_id) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ReleaseShaderCompiler();
   }
 }
 
-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);
   }
 }
 
 void SampleCoverage(PP_Resource context_id, GLclampf value, GLboolean invert) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->SampleCoverage(value, 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);
   }
 }
 
 void StencilFunc(PP_Resource context_id, GLenum func, GLint ref, GLuint mask) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->StencilFunc(func, ref, 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);
   }
 }
 
 void StencilMask(PP_Resource context_id, GLuint mask) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->StencilMask(mask);
   }
 }
 
 void StencilMaskSeparate(PP_Resource context_id, GLenum face, GLuint mask) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->StencilMaskSeparate(face, 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);
   }
 }
 
 void Uniform1f(PP_Resource context_id, GLint location, GLfloat x) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform1f(location, 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);
   }
 }
 
 void Uniform1i(PP_Resource context_id, GLint location, GLint x) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform1i(location, 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);
   }
 }
 
 void Uniform2f(PP_Resource context_id, GLint location, GLfloat x, GLfloat y) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform2f(location, x, 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);
   }
 }
 
 void Uniform2i(PP_Resource context_id, GLint location, GLint x, GLint y) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->Uniform2i(location, x, 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);
   }
 }
 
 void UseProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->UseProgram(program);
   }
 }
 
 void ValidateProgram(PP_Resource context_id, GLuint program) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->ValidateProgram(program);
   }
 }
 
 void VertexAttrib1f(PP_Resource context_id, GLuint indx, GLfloat x) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->VertexAttrib1f(indx, 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)->BlitFramebufferCHROMIUM(
-        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)->RenderbufferStorageMultisampleCHROMIUM(
-        target, samples, internalformat, width, height);
+    ToGles2Impl(
+        &enter)->RenderbufferStorageMultisampleCHROMIUM(
+            target, samples, internalformat, width, height);
   }
 }
 
 void GenQueriesEXT(PP_Resource context_id, GLsizei n, GLuint* queries) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->GenQueriesEXT(n, 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);
   }
 }
 
 GLboolean IsQueryEXT(PP_Resource context_id, GLuint id) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->IsQueryEXT(id);
   } else {
     return GL_FALSE;
   }
 }
 
 void BeginQueryEXT(PP_Resource context_id, GLenum target, GLuint id) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->BeginQueryEXT(target, id);
   }
 }
 
 void EndQueryEXT(PP_Resource context_id, GLenum target) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->EndQueryEXT(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);
   }
 }
 
 GLboolean EnableFeatureCHROMIUM(PP_Resource context_id, const char* feature) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     return ToGles2Impl(&enter)->EnableFeatureCHROMIUM(feature);
   } else {
     return GL_FALSE;
   }
 }
 
-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;
   }
 }
 
 void UnmapBufferSubDataCHROMIUM(PP_Resource context_id, const void* mem) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->UnmapBufferSubDataCHROMIUM(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;
   }
 }
 
 void UnmapTexSubImage2DCHROMIUM(PP_Resource context_id, const void* mem) {
   Enter3D enter(context_id, true);
   if (enter.succeeded()) {
     ToGles2Impl(&enter)->UnmapTexSubImage2DCHROMIUM(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);
   }
 }
 
 }  // 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,

[Zhenyao Mo, 2014/03/04 16:13:16]

Ah, this should be 4-space instead of 2.

I'll leave this file out of this CL then.  Fixing the generated code style
should be in a separate followup CL from this one. Not sure how this gets in
previously though.  This file should never be manually edited.

+    &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() {  // NOLINT
   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() {  // NOLINT
   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() {  // NOLINT
   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() {  // NOLINT
   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() {  // NOLINT
   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;
 }
 }  // namespace ppapi