Home | History | Annotate | Download | only in client
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 // This file is auto-generated from
      6 // gpu/command_buffer/build_gles2_cmd_buffer.py
      7 // It's formatted by clang-format using chromium coding style:
      8 //    clang-format -i -style=chromium filename
      9 // DO NOT EDIT!
     10 
     11 // This file is included by gles2_trace_implementation.cc
     12 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_
     13 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_
     14 
     15 void GLES2TraceImplementation::ActiveTexture(GLenum texture) {
     16   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ActiveTexture");
     17   gl_->ActiveTexture(texture);
     18 }
     19 
     20 void GLES2TraceImplementation::AttachShader(GLuint program, GLuint shader) {
     21   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::AttachShader");
     22   gl_->AttachShader(program, shader);
     23 }
     24 
     25 void GLES2TraceImplementation::BindAttribLocation(GLuint program,
     26                                                   GLuint index,
     27                                                   const char* name) {
     28   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindAttribLocation");
     29   gl_->BindAttribLocation(program, index, name);
     30 }
     31 
     32 void GLES2TraceImplementation::BindBuffer(GLenum target, GLuint buffer) {
     33   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindBuffer");
     34   gl_->BindBuffer(target, buffer);
     35 }
     36 
     37 void GLES2TraceImplementation::BindFramebuffer(GLenum target,
     38                                                GLuint framebuffer) {
     39   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindFramebuffer");
     40   gl_->BindFramebuffer(target, framebuffer);
     41 }
     42 
     43 void GLES2TraceImplementation::BindRenderbuffer(GLenum target,
     44                                                 GLuint renderbuffer) {
     45   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindRenderbuffer");
     46   gl_->BindRenderbuffer(target, renderbuffer);
     47 }
     48 
     49 void GLES2TraceImplementation::BindTexture(GLenum target, GLuint texture) {
     50   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindTexture");
     51   gl_->BindTexture(target, texture);
     52 }
     53 
     54 void GLES2TraceImplementation::BlendColor(GLclampf red,
     55                                           GLclampf green,
     56                                           GLclampf blue,
     57                                           GLclampf alpha) {
     58   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendColor");
     59   gl_->BlendColor(red, green, blue, alpha);
     60 }
     61 
     62 void GLES2TraceImplementation::BlendEquation(GLenum mode) {
     63   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendEquation");
     64   gl_->BlendEquation(mode);
     65 }
     66 
     67 void GLES2TraceImplementation::BlendEquationSeparate(GLenum modeRGB,
     68                                                      GLenum modeAlpha) {
     69   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendEquationSeparate");
     70   gl_->BlendEquationSeparate(modeRGB, modeAlpha);
     71 }
     72 
     73 void GLES2TraceImplementation::BlendFunc(GLenum sfactor, GLenum dfactor) {
     74   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendFunc");
     75   gl_->BlendFunc(sfactor, dfactor);
     76 }
     77 
     78 void GLES2TraceImplementation::BlendFuncSeparate(GLenum srcRGB,
     79                                                  GLenum dstRGB,
     80                                                  GLenum srcAlpha,
     81                                                  GLenum dstAlpha) {
     82   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendFuncSeparate");
     83   gl_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
     84 }
     85 
     86 void GLES2TraceImplementation::BufferData(GLenum target,
     87                                           GLsizeiptr size,
     88                                           const void* data,
     89                                           GLenum usage) {
     90   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BufferData");
     91   gl_->BufferData(target, size, data, usage);
     92 }
     93 
     94 void GLES2TraceImplementation::BufferSubData(GLenum target,
     95                                              GLintptr offset,
     96                                              GLsizeiptr size,
     97                                              const void* data) {
     98   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BufferSubData");
     99   gl_->BufferSubData(target, offset, size, data);
    100 }
    101 
    102 GLenum GLES2TraceImplementation::CheckFramebufferStatus(GLenum target) {
    103   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CheckFramebufferStatus");
    104   return gl_->CheckFramebufferStatus(target);
    105 }
    106 
    107 void GLES2TraceImplementation::Clear(GLbitfield mask) {
    108   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Clear");
    109   gl_->Clear(mask);
    110 }
    111 
    112 void GLES2TraceImplementation::ClearColor(GLclampf red,
    113                                           GLclampf green,
    114                                           GLclampf blue,
    115                                           GLclampf alpha) {
    116   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearColor");
    117   gl_->ClearColor(red, green, blue, alpha);
    118 }
    119 
    120 void GLES2TraceImplementation::ClearDepthf(GLclampf depth) {
    121   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearDepthf");
    122   gl_->ClearDepthf(depth);
    123 }
    124 
    125 void GLES2TraceImplementation::ClearStencil(GLint s) {
    126   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearStencil");
    127   gl_->ClearStencil(s);
    128 }
    129 
    130 void GLES2TraceImplementation::ColorMask(GLboolean red,
    131                                          GLboolean green,
    132                                          GLboolean blue,
    133                                          GLboolean alpha) {
    134   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ColorMask");
    135   gl_->ColorMask(red, green, blue, alpha);
    136 }
    137 
    138 void GLES2TraceImplementation::CompileShader(GLuint shader) {
    139   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompileShader");
    140   gl_->CompileShader(shader);
    141 }
    142 
    143 void GLES2TraceImplementation::CompressedTexImage2D(GLenum target,
    144                                                     GLint level,
    145                                                     GLenum internalformat,
    146                                                     GLsizei width,
    147                                                     GLsizei height,
    148                                                     GLint border,
    149                                                     GLsizei imageSize,
    150                                                     const void* data) {
    151   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompressedTexImage2D");
    152   gl_->CompressedTexImage2D(
    153       target, level, internalformat, width, height, border, imageSize, data);
    154 }
    155 
    156 void GLES2TraceImplementation::CompressedTexSubImage2D(GLenum target,
    157                                                        GLint level,
    158                                                        GLint xoffset,
    159                                                        GLint yoffset,
    160                                                        GLsizei width,
    161                                                        GLsizei height,
    162                                                        GLenum format,
    163                                                        GLsizei imageSize,
    164                                                        const void* data) {
    165   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompressedTexSubImage2D");
    166   gl_->CompressedTexSubImage2D(
    167       target, level, xoffset, yoffset, width, height, format, imageSize, data);
    168 }
    169 
    170 void GLES2TraceImplementation::CopyTexImage2D(GLenum target,
    171                                               GLint level,
    172                                               GLenum internalformat,
    173                                               GLint x,
    174                                               GLint y,
    175                                               GLsizei width,
    176                                               GLsizei height,
    177                                               GLint border) {
    178   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTexImage2D");
    179   gl_->CopyTexImage2D(
    180       target, level, internalformat, x, y, width, height, border);
    181 }
    182 
    183 void GLES2TraceImplementation::CopyTexSubImage2D(GLenum target,
    184                                                  GLint level,
    185                                                  GLint xoffset,
    186                                                  GLint yoffset,
    187                                                  GLint x,
    188                                                  GLint y,
    189                                                  GLsizei width,
    190                                                  GLsizei height) {
    191   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTexSubImage2D");
    192   gl_->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
    193 }
    194 
    195 GLuint GLES2TraceImplementation::CreateProgram() {
    196   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateProgram");
    197   return gl_->CreateProgram();
    198 }
    199 
    200 GLuint GLES2TraceImplementation::CreateShader(GLenum type) {
    201   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateShader");
    202   return gl_->CreateShader(type);
    203 }
    204 
    205 void GLES2TraceImplementation::CullFace(GLenum mode) {
    206   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CullFace");
    207   gl_->CullFace(mode);
    208 }
    209 
    210 void GLES2TraceImplementation::DeleteBuffers(GLsizei n, const GLuint* buffers) {
    211   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteBuffers");
    212   gl_->DeleteBuffers(n, buffers);
    213 }
    214 
    215 void GLES2TraceImplementation::DeleteFramebuffers(GLsizei n,
    216                                                   const GLuint* framebuffers) {
    217   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteFramebuffers");
    218   gl_->DeleteFramebuffers(n, framebuffers);
    219 }
    220 
    221 void GLES2TraceImplementation::DeleteProgram(GLuint program) {
    222   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteProgram");
    223   gl_->DeleteProgram(program);
    224 }
    225 
    226 void GLES2TraceImplementation::DeleteRenderbuffers(
    227     GLsizei n,
    228     const GLuint* renderbuffers) {
    229   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteRenderbuffers");
    230   gl_->DeleteRenderbuffers(n, renderbuffers);
    231 }
    232 
    233 void GLES2TraceImplementation::DeleteShader(GLuint shader) {
    234   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteShader");
    235   gl_->DeleteShader(shader);
    236 }
    237 
    238 void GLES2TraceImplementation::DeleteTextures(GLsizei n,
    239                                               const GLuint* textures) {
    240   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteTextures");
    241   gl_->DeleteTextures(n, textures);
    242 }
    243 
    244 void GLES2TraceImplementation::DepthFunc(GLenum func) {
    245   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DepthFunc");
    246   gl_->DepthFunc(func);
    247 }
    248 
    249 void GLES2TraceImplementation::DepthMask(GLboolean flag) {
    250   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DepthMask");
    251   gl_->DepthMask(flag);
    252 }
    253 
    254 void GLES2TraceImplementation::DepthRangef(GLclampf zNear, GLclampf zFar) {
    255   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DepthRangef");
    256   gl_->DepthRangef(zNear, zFar);
    257 }
    258 
    259 void GLES2TraceImplementation::DetachShader(GLuint program, GLuint shader) {
    260   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DetachShader");
    261   gl_->DetachShader(program, shader);
    262 }
    263 
    264 void GLES2TraceImplementation::Disable(GLenum cap) {
    265   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Disable");
    266   gl_->Disable(cap);
    267 }
    268 
    269 void GLES2TraceImplementation::DisableVertexAttribArray(GLuint index) {
    270   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DisableVertexAttribArray");
    271   gl_->DisableVertexAttribArray(index);
    272 }
    273 
    274 void GLES2TraceImplementation::DrawArrays(GLenum mode,
    275                                           GLint first,
    276                                           GLsizei count) {
    277   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawArrays");
    278   gl_->DrawArrays(mode, first, count);
    279 }
    280 
    281 void GLES2TraceImplementation::DrawElements(GLenum mode,
    282                                             GLsizei count,
    283                                             GLenum type,
    284                                             const void* indices) {
    285   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawElements");
    286   gl_->DrawElements(mode, count, type, indices);
    287 }
    288 
    289 void GLES2TraceImplementation::Enable(GLenum cap) {
    290   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Enable");
    291   gl_->Enable(cap);
    292 }
    293 
    294 void GLES2TraceImplementation::EnableVertexAttribArray(GLuint index) {
    295   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EnableVertexAttribArray");
    296   gl_->EnableVertexAttribArray(index);
    297 }
    298 
    299 void GLES2TraceImplementation::Finish() {
    300   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Finish");
    301   gl_->Finish();
    302 }
    303 
    304 void GLES2TraceImplementation::Flush() {
    305   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Flush");
    306   gl_->Flush();
    307 }
    308 
    309 void GLES2TraceImplementation::FramebufferRenderbuffer(
    310     GLenum target,
    311     GLenum attachment,
    312     GLenum renderbuffertarget,
    313     GLuint renderbuffer) {
    314   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FramebufferRenderbuffer");
    315   gl_->FramebufferRenderbuffer(
    316       target, attachment, renderbuffertarget, renderbuffer);
    317 }
    318 
    319 void GLES2TraceImplementation::FramebufferTexture2D(GLenum target,
    320                                                     GLenum attachment,
    321                                                     GLenum textarget,
    322                                                     GLuint texture,
    323                                                     GLint level) {
    324   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FramebufferTexture2D");
    325   gl_->FramebufferTexture2D(target, attachment, textarget, texture, level);
    326 }
    327 
    328 void GLES2TraceImplementation::FrontFace(GLenum mode) {
    329   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FrontFace");
    330   gl_->FrontFace(mode);
    331 }
    332 
    333 void GLES2TraceImplementation::GenBuffers(GLsizei n, GLuint* buffers) {
    334   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenBuffers");
    335   gl_->GenBuffers(n, buffers);
    336 }
    337 
    338 void GLES2TraceImplementation::GenerateMipmap(GLenum target) {
    339   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenerateMipmap");
    340   gl_->GenerateMipmap(target);
    341 }
    342 
    343 void GLES2TraceImplementation::GenFramebuffers(GLsizei n,
    344                                                GLuint* framebuffers) {
    345   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenFramebuffers");
    346   gl_->GenFramebuffers(n, framebuffers);
    347 }
    348 
    349 void GLES2TraceImplementation::GenRenderbuffers(GLsizei n,
    350                                                 GLuint* renderbuffers) {
    351   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenRenderbuffers");
    352   gl_->GenRenderbuffers(n, renderbuffers);
    353 }
    354 
    355 void GLES2TraceImplementation::GenTextures(GLsizei n, GLuint* textures) {
    356   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenTextures");
    357   gl_->GenTextures(n, textures);
    358 }
    359 
    360 void GLES2TraceImplementation::GetActiveAttrib(GLuint program,
    361                                                GLuint index,
    362                                                GLsizei bufsize,
    363                                                GLsizei* length,
    364                                                GLint* size,
    365                                                GLenum* type,
    366                                                char* name) {
    367   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveAttrib");
    368   gl_->GetActiveAttrib(program, index, bufsize, length, size, type, name);
    369 }
    370 
    371 void GLES2TraceImplementation::GetActiveUniform(GLuint program,
    372                                                 GLuint index,
    373                                                 GLsizei bufsize,
    374                                                 GLsizei* length,
    375                                                 GLint* size,
    376                                                 GLenum* type,
    377                                                 char* name) {
    378   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveUniform");
    379   gl_->GetActiveUniform(program, index, bufsize, length, size, type, name);
    380 }
    381 
    382 void GLES2TraceImplementation::GetAttachedShaders(GLuint program,
    383                                                   GLsizei maxcount,
    384                                                   GLsizei* count,
    385                                                   GLuint* shaders) {
    386   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetAttachedShaders");
    387   gl_->GetAttachedShaders(program, maxcount, count, shaders);
    388 }
    389 
    390 GLint GLES2TraceImplementation::GetAttribLocation(GLuint program,
    391                                                   const char* name) {
    392   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetAttribLocation");
    393   return gl_->GetAttribLocation(program, name);
    394 }
    395 
    396 void GLES2TraceImplementation::GetBooleanv(GLenum pname, GLboolean* params) {
    397   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetBooleanv");
    398   gl_->GetBooleanv(pname, params);
    399 }
    400 
    401 void GLES2TraceImplementation::GetBufferParameteriv(GLenum target,
    402                                                     GLenum pname,
    403                                                     GLint* params) {
    404   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetBufferParameteriv");
    405   gl_->GetBufferParameteriv(target, pname, params);
    406 }
    407 
    408 GLenum GLES2TraceImplementation::GetError() {
    409   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetError");
    410   return gl_->GetError();
    411 }
    412 
    413 void GLES2TraceImplementation::GetFloatv(GLenum pname, GLfloat* params) {
    414   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetFloatv");
    415   gl_->GetFloatv(pname, params);
    416 }
    417 
    418 void GLES2TraceImplementation::GetFramebufferAttachmentParameteriv(
    419     GLenum target,
    420     GLenum attachment,
    421     GLenum pname,
    422     GLint* params) {
    423   TRACE_EVENT_BINARY_EFFICIENT0(
    424       "gpu", "GLES2Trace::GetFramebufferAttachmentParameteriv");
    425   gl_->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
    426 }
    427 
    428 void GLES2TraceImplementation::GetIntegerv(GLenum pname, GLint* params) {
    429   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetIntegerv");
    430   gl_->GetIntegerv(pname, params);
    431 }
    432 
    433 void GLES2TraceImplementation::GetProgramiv(GLuint program,
    434                                             GLenum pname,
    435                                             GLint* params) {
    436   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramiv");
    437   gl_->GetProgramiv(program, pname, params);
    438 }
    439 
    440 void GLES2TraceImplementation::GetProgramInfoLog(GLuint program,
    441                                                  GLsizei bufsize,
    442                                                  GLsizei* length,
    443                                                  char* infolog) {
    444   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramInfoLog");
    445   gl_->GetProgramInfoLog(program, bufsize, length, infolog);
    446 }
    447 
    448 void GLES2TraceImplementation::GetRenderbufferParameteriv(GLenum target,
    449                                                           GLenum pname,
    450                                                           GLint* params) {
    451   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
    452                                 "GLES2Trace::GetRenderbufferParameteriv");
    453   gl_->GetRenderbufferParameteriv(target, pname, params);
    454 }
    455 
    456 void GLES2TraceImplementation::GetShaderiv(GLuint shader,
    457                                            GLenum pname,
    458                                            GLint* params) {
    459   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderiv");
    460   gl_->GetShaderiv(shader, pname, params);
    461 }
    462 
    463 void GLES2TraceImplementation::GetShaderInfoLog(GLuint shader,
    464                                                 GLsizei bufsize,
    465                                                 GLsizei* length,
    466                                                 char* infolog) {
    467   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderInfoLog");
    468   gl_->GetShaderInfoLog(shader, bufsize, length, infolog);
    469 }
    470 
    471 void GLES2TraceImplementation::GetShaderPrecisionFormat(GLenum shadertype,
    472                                                         GLenum precisiontype,
    473                                                         GLint* range,
    474                                                         GLint* precision) {
    475   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderPrecisionFormat");
    476   gl_->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
    477 }
    478 
    479 void GLES2TraceImplementation::GetShaderSource(GLuint shader,
    480                                                GLsizei bufsize,
    481                                                GLsizei* length,
    482                                                char* source) {
    483   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderSource");
    484   gl_->GetShaderSource(shader, bufsize, length, source);
    485 }
    486 
    487 const GLubyte* GLES2TraceImplementation::GetString(GLenum name) {
    488   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetString");
    489   return gl_->GetString(name);
    490 }
    491 
    492 void GLES2TraceImplementation::GetTexParameterfv(GLenum target,
    493                                                  GLenum pname,
    494                                                  GLfloat* params) {
    495   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetTexParameterfv");
    496   gl_->GetTexParameterfv(target, pname, params);
    497 }
    498 
    499 void GLES2TraceImplementation::GetTexParameteriv(GLenum target,
    500                                                  GLenum pname,
    501                                                  GLint* params) {
    502   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetTexParameteriv");
    503   gl_->GetTexParameteriv(target, pname, params);
    504 }
    505 
    506 void GLES2TraceImplementation::GetUniformfv(GLuint program,
    507                                             GLint location,
    508                                             GLfloat* params) {
    509   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformfv");
    510   gl_->GetUniformfv(program, location, params);
    511 }
    512 
    513 void GLES2TraceImplementation::GetUniformiv(GLuint program,
    514                                             GLint location,
    515                                             GLint* params) {
    516   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformiv");
    517   gl_->GetUniformiv(program, location, params);
    518 }
    519 
    520 GLint GLES2TraceImplementation::GetUniformLocation(GLuint program,
    521                                                    const char* name) {
    522   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformLocation");
    523   return gl_->GetUniformLocation(program, name);
    524 }
    525 
    526 void GLES2TraceImplementation::GetVertexAttribfv(GLuint index,
    527                                                  GLenum pname,
    528                                                  GLfloat* params) {
    529   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribfv");
    530   gl_->GetVertexAttribfv(index, pname, params);
    531 }
    532 
    533 void GLES2TraceImplementation::GetVertexAttribiv(GLuint index,
    534                                                  GLenum pname,
    535                                                  GLint* params) {
    536   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribiv");
    537   gl_->GetVertexAttribiv(index, pname, params);
    538 }
    539 
    540 void GLES2TraceImplementation::GetVertexAttribPointerv(GLuint index,
    541                                                        GLenum pname,
    542                                                        void** pointer) {
    543   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribPointerv");
    544   gl_->GetVertexAttribPointerv(index, pname, pointer);
    545 }
    546 
    547 void GLES2TraceImplementation::Hint(GLenum target, GLenum mode) {
    548   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Hint");
    549   gl_->Hint(target, mode);
    550 }
    551 
    552 GLboolean GLES2TraceImplementation::IsBuffer(GLuint buffer) {
    553   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsBuffer");
    554   return gl_->IsBuffer(buffer);
    555 }
    556 
    557 GLboolean GLES2TraceImplementation::IsEnabled(GLenum cap) {
    558   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsEnabled");
    559   return gl_->IsEnabled(cap);
    560 }
    561 
    562 GLboolean GLES2TraceImplementation::IsFramebuffer(GLuint framebuffer) {
    563   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsFramebuffer");
    564   return gl_->IsFramebuffer(framebuffer);
    565 }
    566 
    567 GLboolean GLES2TraceImplementation::IsProgram(GLuint program) {
    568   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsProgram");
    569   return gl_->IsProgram(program);
    570 }
    571 
    572 GLboolean GLES2TraceImplementation::IsRenderbuffer(GLuint renderbuffer) {
    573   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsRenderbuffer");
    574   return gl_->IsRenderbuffer(renderbuffer);
    575 }
    576 
    577 GLboolean GLES2TraceImplementation::IsShader(GLuint shader) {
    578   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsShader");
    579   return gl_->IsShader(shader);
    580 }
    581 
    582 GLboolean GLES2TraceImplementation::IsTexture(GLuint texture) {
    583   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsTexture");
    584   return gl_->IsTexture(texture);
    585 }
    586 
    587 void GLES2TraceImplementation::LineWidth(GLfloat width) {
    588   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LineWidth");
    589   gl_->LineWidth(width);
    590 }
    591 
    592 void GLES2TraceImplementation::LinkProgram(GLuint program) {
    593   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LinkProgram");
    594   gl_->LinkProgram(program);
    595 }
    596 
    597 void GLES2TraceImplementation::PixelStorei(GLenum pname, GLint param) {
    598   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PixelStorei");
    599   gl_->PixelStorei(pname, param);
    600 }
    601 
    602 void GLES2TraceImplementation::PolygonOffset(GLfloat factor, GLfloat units) {
    603   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PolygonOffset");
    604   gl_->PolygonOffset(factor, units);
    605 }
    606 
    607 void GLES2TraceImplementation::ReadPixels(GLint x,
    608                                           GLint y,
    609                                           GLsizei width,
    610                                           GLsizei height,
    611                                           GLenum format,
    612                                           GLenum type,
    613                                           void* pixels) {
    614   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReadPixels");
    615   gl_->ReadPixels(x, y, width, height, format, type, pixels);
    616 }
    617 
    618 void GLES2TraceImplementation::ReleaseShaderCompiler() {
    619   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReleaseShaderCompiler");
    620   gl_->ReleaseShaderCompiler();
    621 }
    622 
    623 void GLES2TraceImplementation::RenderbufferStorage(GLenum target,
    624                                                    GLenum internalformat,
    625                                                    GLsizei width,
    626                                                    GLsizei height) {
    627   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::RenderbufferStorage");
    628   gl_->RenderbufferStorage(target, internalformat, width, height);
    629 }
    630 
    631 void GLES2TraceImplementation::SampleCoverage(GLclampf value,
    632                                               GLboolean invert) {
    633   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SampleCoverage");
    634   gl_->SampleCoverage(value, invert);
    635 }
    636 
    637 void GLES2TraceImplementation::Scissor(GLint x,
    638                                        GLint y,
    639                                        GLsizei width,
    640                                        GLsizei height) {
    641   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Scissor");
    642   gl_->Scissor(x, y, width, height);
    643 }
    644 
    645 void GLES2TraceImplementation::ShaderBinary(GLsizei n,
    646                                             const GLuint* shaders,
    647                                             GLenum binaryformat,
    648                                             const void* binary,
    649                                             GLsizei length) {
    650   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShaderBinary");
    651   gl_->ShaderBinary(n, shaders, binaryformat, binary, length);
    652 }
    653 
    654 void GLES2TraceImplementation::ShaderSource(GLuint shader,
    655                                             GLsizei count,
    656                                             const GLchar* const* str,
    657                                             const GLint* length) {
    658   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShaderSource");
    659   gl_->ShaderSource(shader, count, str, length);
    660 }
    661 
    662 void GLES2TraceImplementation::ShallowFinishCHROMIUM() {
    663   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShallowFinishCHROMIUM");
    664   gl_->ShallowFinishCHROMIUM();
    665 }
    666 
    667 void GLES2TraceImplementation::ShallowFlushCHROMIUM() {
    668   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShallowFlushCHROMIUM");
    669   gl_->ShallowFlushCHROMIUM();
    670 }
    671 
    672 void GLES2TraceImplementation::StencilFunc(GLenum func,
    673                                            GLint ref,
    674                                            GLuint mask) {
    675   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilFunc");
    676   gl_->StencilFunc(func, ref, mask);
    677 }
    678 
    679 void GLES2TraceImplementation::StencilFuncSeparate(GLenum face,
    680                                                    GLenum func,
    681                                                    GLint ref,
    682                                                    GLuint mask) {
    683   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilFuncSeparate");
    684   gl_->StencilFuncSeparate(face, func, ref, mask);
    685 }
    686 
    687 void GLES2TraceImplementation::StencilMask(GLuint mask) {
    688   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilMask");
    689   gl_->StencilMask(mask);
    690 }
    691 
    692 void GLES2TraceImplementation::StencilMaskSeparate(GLenum face, GLuint mask) {
    693   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilMaskSeparate");
    694   gl_->StencilMaskSeparate(face, mask);
    695 }
    696 
    697 void GLES2TraceImplementation::StencilOp(GLenum fail,
    698                                          GLenum zfail,
    699                                          GLenum zpass) {
    700   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilOp");
    701   gl_->StencilOp(fail, zfail, zpass);
    702 }
    703 
    704 void GLES2TraceImplementation::StencilOpSeparate(GLenum face,
    705                                                  GLenum fail,
    706                                                  GLenum zfail,
    707                                                  GLenum zpass) {
    708   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilOpSeparate");
    709   gl_->StencilOpSeparate(face, fail, zfail, zpass);
    710 }
    711 
    712 void GLES2TraceImplementation::TexImage2D(GLenum target,
    713                                           GLint level,
    714                                           GLint internalformat,
    715                                           GLsizei width,
    716                                           GLsizei height,
    717                                           GLint border,
    718                                           GLenum format,
    719                                           GLenum type,
    720                                           const void* pixels) {
    721   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexImage2D");
    722   gl_->TexImage2D(target,
    723                   level,
    724                   internalformat,
    725                   width,
    726                   height,
    727                   border,
    728                   format,
    729                   type,
    730                   pixels);
    731 }
    732 
    733 void GLES2TraceImplementation::TexParameterf(GLenum target,
    734                                              GLenum pname,
    735                                              GLfloat param) {
    736   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameterf");
    737   gl_->TexParameterf(target, pname, param);
    738 }
    739 
    740 void GLES2TraceImplementation::TexParameterfv(GLenum target,
    741                                               GLenum pname,
    742                                               const GLfloat* params) {
    743   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameterfv");
    744   gl_->TexParameterfv(target, pname, params);
    745 }
    746 
    747 void GLES2TraceImplementation::TexParameteri(GLenum target,
    748                                              GLenum pname,
    749                                              GLint param) {
    750   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameteri");
    751   gl_->TexParameteri(target, pname, param);
    752 }
    753 
    754 void GLES2TraceImplementation::TexParameteriv(GLenum target,
    755                                               GLenum pname,
    756                                               const GLint* params) {
    757   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameteriv");
    758   gl_->TexParameteriv(target, pname, params);
    759 }
    760 
    761 void GLES2TraceImplementation::TexSubImage2D(GLenum target,
    762                                              GLint level,
    763                                              GLint xoffset,
    764                                              GLint yoffset,
    765                                              GLsizei width,
    766                                              GLsizei height,
    767                                              GLenum format,
    768                                              GLenum type,
    769                                              const void* pixels) {
    770   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexSubImage2D");
    771   gl_->TexSubImage2D(
    772       target, level, xoffset, yoffset, width, height, format, type, pixels);
    773 }
    774 
    775 void GLES2TraceImplementation::Uniform1f(GLint location, GLfloat x) {
    776   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1f");
    777   gl_->Uniform1f(location, x);
    778 }
    779 
    780 void GLES2TraceImplementation::Uniform1fv(GLint location,
    781                                           GLsizei count,
    782                                           const GLfloat* v) {
    783   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1fv");
    784   gl_->Uniform1fv(location, count, v);
    785 }
    786 
    787 void GLES2TraceImplementation::Uniform1i(GLint location, GLint x) {
    788   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1i");
    789   gl_->Uniform1i(location, x);
    790 }
    791 
    792 void GLES2TraceImplementation::Uniform1iv(GLint location,
    793                                           GLsizei count,
    794                                           const GLint* v) {
    795   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1iv");
    796   gl_->Uniform1iv(location, count, v);
    797 }
    798 
    799 void GLES2TraceImplementation::Uniform2f(GLint location, GLfloat x, GLfloat y) {
    800   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2f");
    801   gl_->Uniform2f(location, x, y);
    802 }
    803 
    804 void GLES2TraceImplementation::Uniform2fv(GLint location,
    805                                           GLsizei count,
    806                                           const GLfloat* v) {
    807   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2fv");
    808   gl_->Uniform2fv(location, count, v);
    809 }
    810 
    811 void GLES2TraceImplementation::Uniform2i(GLint location, GLint x, GLint y) {
    812   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2i");
    813   gl_->Uniform2i(location, x, y);
    814 }
    815 
    816 void GLES2TraceImplementation::Uniform2iv(GLint location,
    817                                           GLsizei count,
    818                                           const GLint* v) {
    819   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2iv");
    820   gl_->Uniform2iv(location, count, v);
    821 }
    822 
    823 void GLES2TraceImplementation::Uniform3f(GLint location,
    824                                          GLfloat x,
    825                                          GLfloat y,
    826                                          GLfloat z) {
    827   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3f");
    828   gl_->Uniform3f(location, x, y, z);
    829 }
    830 
    831 void GLES2TraceImplementation::Uniform3fv(GLint location,
    832                                           GLsizei count,
    833                                           const GLfloat* v) {
    834   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3fv");
    835   gl_->Uniform3fv(location, count, v);
    836 }
    837 
    838 void GLES2TraceImplementation::Uniform3i(GLint location,
    839                                          GLint x,
    840                                          GLint y,
    841                                          GLint z) {
    842   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3i");
    843   gl_->Uniform3i(location, x, y, z);
    844 }
    845 
    846 void GLES2TraceImplementation::Uniform3iv(GLint location,
    847                                           GLsizei count,
    848                                           const GLint* v) {
    849   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3iv");
    850   gl_->Uniform3iv(location, count, v);
    851 }
    852 
    853 void GLES2TraceImplementation::Uniform4f(GLint location,
    854                                          GLfloat x,
    855                                          GLfloat y,
    856                                          GLfloat z,
    857                                          GLfloat w) {
    858   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4f");
    859   gl_->Uniform4f(location, x, y, z, w);
    860 }
    861 
    862 void GLES2TraceImplementation::Uniform4fv(GLint location,
    863                                           GLsizei count,
    864                                           const GLfloat* v) {
    865   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4fv");
    866   gl_->Uniform4fv(location, count, v);
    867 }
    868 
    869 void GLES2TraceImplementation::Uniform4i(GLint location,
    870                                          GLint x,
    871                                          GLint y,
    872                                          GLint z,
    873                                          GLint w) {
    874   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4i");
    875   gl_->Uniform4i(location, x, y, z, w);
    876 }
    877 
    878 void GLES2TraceImplementation::Uniform4iv(GLint location,
    879                                           GLsizei count,
    880                                           const GLint* v) {
    881   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4iv");
    882   gl_->Uniform4iv(location, count, v);
    883 }
    884 
    885 void GLES2TraceImplementation::UniformMatrix2fv(GLint location,
    886                                                 GLsizei count,
    887                                                 GLboolean transpose,
    888                                                 const GLfloat* value) {
    889   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix2fv");
    890   gl_->UniformMatrix2fv(location, count, transpose, value);
    891 }
    892 
    893 void GLES2TraceImplementation::UniformMatrix3fv(GLint location,
    894                                                 GLsizei count,
    895                                                 GLboolean transpose,
    896                                                 const GLfloat* value) {
    897   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix3fv");
    898   gl_->UniformMatrix3fv(location, count, transpose, value);
    899 }
    900 
    901 void GLES2TraceImplementation::UniformMatrix4fv(GLint location,
    902                                                 GLsizei count,
    903                                                 GLboolean transpose,
    904                                                 const GLfloat* value) {
    905   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix4fv");
    906   gl_->UniformMatrix4fv(location, count, transpose, value);
    907 }
    908 
    909 void GLES2TraceImplementation::UseProgram(GLuint program) {
    910   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UseProgram");
    911   gl_->UseProgram(program);
    912 }
    913 
    914 void GLES2TraceImplementation::ValidateProgram(GLuint program) {
    915   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ValidateProgram");
    916   gl_->ValidateProgram(program);
    917 }
    918 
    919 void GLES2TraceImplementation::VertexAttrib1f(GLuint indx, GLfloat x) {
    920   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib1f");
    921   gl_->VertexAttrib1f(indx, x);
    922 }
    923 
    924 void GLES2TraceImplementation::VertexAttrib1fv(GLuint indx,
    925                                                const GLfloat* values) {
    926   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib1fv");
    927   gl_->VertexAttrib1fv(indx, values);
    928 }
    929 
    930 void GLES2TraceImplementation::VertexAttrib2f(GLuint indx,
    931                                               GLfloat x,
    932                                               GLfloat y) {
    933   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib2f");
    934   gl_->VertexAttrib2f(indx, x, y);
    935 }
    936 
    937 void GLES2TraceImplementation::VertexAttrib2fv(GLuint indx,
    938                                                const GLfloat* values) {
    939   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib2fv");
    940   gl_->VertexAttrib2fv(indx, values);
    941 }
    942 
    943 void GLES2TraceImplementation::VertexAttrib3f(GLuint indx,
    944                                               GLfloat x,
    945                                               GLfloat y,
    946                                               GLfloat z) {
    947   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib3f");
    948   gl_->VertexAttrib3f(indx, x, y, z);
    949 }
    950 
    951 void GLES2TraceImplementation::VertexAttrib3fv(GLuint indx,
    952                                                const GLfloat* values) {
    953   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib3fv");
    954   gl_->VertexAttrib3fv(indx, values);
    955 }
    956 
    957 void GLES2TraceImplementation::VertexAttrib4f(GLuint indx,
    958                                               GLfloat x,
    959                                               GLfloat y,
    960                                               GLfloat z,
    961                                               GLfloat w) {
    962   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib4f");
    963   gl_->VertexAttrib4f(indx, x, y, z, w);
    964 }
    965 
    966 void GLES2TraceImplementation::VertexAttrib4fv(GLuint indx,
    967                                                const GLfloat* values) {
    968   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib4fv");
    969   gl_->VertexAttrib4fv(indx, values);
    970 }
    971 
    972 void GLES2TraceImplementation::VertexAttribPointer(GLuint indx,
    973                                                    GLint size,
    974                                                    GLenum type,
    975                                                    GLboolean normalized,
    976                                                    GLsizei stride,
    977                                                    const void* ptr) {
    978   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribPointer");
    979   gl_->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
    980 }
    981 
    982 void GLES2TraceImplementation::Viewport(GLint x,
    983                                         GLint y,
    984                                         GLsizei width,
    985                                         GLsizei height) {
    986   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Viewport");
    987   gl_->Viewport(x, y, width, height);
    988 }
    989 
    990 void GLES2TraceImplementation::BlitFramebufferCHROMIUM(GLint srcX0,
    991                                                        GLint srcY0,
    992                                                        GLint srcX1,
    993                                                        GLint srcY1,
    994                                                        GLint dstX0,
    995                                                        GLint dstY0,
    996                                                        GLint dstX1,
    997                                                        GLint dstY1,
    998                                                        GLbitfield mask,
    999                                                        GLenum filter) {
   1000   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlitFramebufferCHROMIUM");
   1001   gl_->BlitFramebufferCHROMIUM(
   1002       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
   1003 }
   1004 
   1005 void GLES2TraceImplementation::RenderbufferStorageMultisampleCHROMIUM(
   1006     GLenum target,
   1007     GLsizei samples,
   1008     GLenum internalformat,
   1009     GLsizei width,
   1010     GLsizei height) {
   1011   TRACE_EVENT_BINARY_EFFICIENT0(
   1012       "gpu", "GLES2Trace::RenderbufferStorageMultisampleCHROMIUM");
   1013   gl_->RenderbufferStorageMultisampleCHROMIUM(
   1014       target, samples, internalformat, width, height);
   1015 }
   1016 
   1017 void GLES2TraceImplementation::RenderbufferStorageMultisampleEXT(
   1018     GLenum target,
   1019     GLsizei samples,
   1020     GLenum internalformat,
   1021     GLsizei width,
   1022     GLsizei height) {
   1023   TRACE_EVENT_BINARY_EFFICIENT0(
   1024       "gpu", "GLES2Trace::RenderbufferStorageMultisampleEXT");
   1025   gl_->RenderbufferStorageMultisampleEXT(
   1026       target, samples, internalformat, width, height);
   1027 }
   1028 
   1029 void GLES2TraceImplementation::FramebufferTexture2DMultisampleEXT(
   1030     GLenum target,
   1031     GLenum attachment,
   1032     GLenum textarget,
   1033     GLuint texture,
   1034     GLint level,
   1035     GLsizei samples) {
   1036   TRACE_EVENT_BINARY_EFFICIENT0(
   1037       "gpu", "GLES2Trace::FramebufferTexture2DMultisampleEXT");
   1038   gl_->FramebufferTexture2DMultisampleEXT(
   1039       target, attachment, textarget, texture, level, samples);
   1040 }
   1041 
   1042 void GLES2TraceImplementation::TexStorage2DEXT(GLenum target,
   1043                                                GLsizei levels,
   1044                                                GLenum internalFormat,
   1045                                                GLsizei width,
   1046                                                GLsizei height) {
   1047   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexStorage2DEXT");
   1048   gl_->TexStorage2DEXT(target, levels, internalFormat, width, height);
   1049 }
   1050 
   1051 void GLES2TraceImplementation::GenQueriesEXT(GLsizei n, GLuint* queries) {
   1052   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenQueriesEXT");
   1053   gl_->GenQueriesEXT(n, queries);
   1054 }
   1055 
   1056 void GLES2TraceImplementation::DeleteQueriesEXT(GLsizei n,
   1057                                                 const GLuint* queries) {
   1058   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteQueriesEXT");
   1059   gl_->DeleteQueriesEXT(n, queries);
   1060 }
   1061 
   1062 GLboolean GLES2TraceImplementation::IsQueryEXT(GLuint id) {
   1063   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsQueryEXT");
   1064   return gl_->IsQueryEXT(id);
   1065 }
   1066 
   1067 void GLES2TraceImplementation::BeginQueryEXT(GLenum target, GLuint id) {
   1068   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BeginQueryEXT");
   1069   gl_->BeginQueryEXT(target, id);
   1070 }
   1071 
   1072 void GLES2TraceImplementation::EndQueryEXT(GLenum target) {
   1073   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EndQueryEXT");
   1074   gl_->EndQueryEXT(target);
   1075 }
   1076 
   1077 void GLES2TraceImplementation::GetQueryivEXT(GLenum target,
   1078                                              GLenum pname,
   1079                                              GLint* params) {
   1080   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryivEXT");
   1081   gl_->GetQueryivEXT(target, pname, params);
   1082 }
   1083 
   1084 void GLES2TraceImplementation::GetQueryObjectuivEXT(GLuint id,
   1085                                                     GLenum pname,
   1086                                                     GLuint* params) {
   1087   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjectuivEXT");
   1088   gl_->GetQueryObjectuivEXT(id, pname, params);
   1089 }
   1090 
   1091 void GLES2TraceImplementation::InsertEventMarkerEXT(GLsizei length,
   1092                                                     const GLchar* marker) {
   1093   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InsertEventMarkerEXT");
   1094   gl_->InsertEventMarkerEXT(length, marker);
   1095 }
   1096 
   1097 void GLES2TraceImplementation::PushGroupMarkerEXT(GLsizei length,
   1098                                                   const GLchar* marker) {
   1099   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PushGroupMarkerEXT");
   1100   gl_->PushGroupMarkerEXT(length, marker);
   1101 }
   1102 
   1103 void GLES2TraceImplementation::PopGroupMarkerEXT() {
   1104   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PopGroupMarkerEXT");
   1105   gl_->PopGroupMarkerEXT();
   1106 }
   1107 
   1108 void GLES2TraceImplementation::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
   1109   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenVertexArraysOES");
   1110   gl_->GenVertexArraysOES(n, arrays);
   1111 }
   1112 
   1113 void GLES2TraceImplementation::DeleteVertexArraysOES(GLsizei n,
   1114                                                      const GLuint* arrays) {
   1115   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteVertexArraysOES");
   1116   gl_->DeleteVertexArraysOES(n, arrays);
   1117 }
   1118 
   1119 GLboolean GLES2TraceImplementation::IsVertexArrayOES(GLuint array) {
   1120   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsVertexArrayOES");
   1121   return gl_->IsVertexArrayOES(array);
   1122 }
   1123 
   1124 void GLES2TraceImplementation::BindVertexArrayOES(GLuint array) {
   1125   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindVertexArrayOES");
   1126   gl_->BindVertexArrayOES(array);
   1127 }
   1128 
   1129 void GLES2TraceImplementation::SwapBuffers() {
   1130   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SwapBuffers");
   1131   gl_->SwapBuffers();
   1132 }
   1133 
   1134 GLuint GLES2TraceImplementation::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
   1135                                                              GLsizei count,
   1136                                                              GLenum type,
   1137                                                              GLuint offset) {
   1138   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1139                                 "GLES2Trace::GetMaxValueInBufferCHROMIUM");
   1140   return gl_->GetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
   1141 }
   1142 
   1143 void GLES2TraceImplementation::GenSharedIdsCHROMIUM(GLuint namespace_id,
   1144                                                     GLuint id_offset,
   1145                                                     GLsizei n,
   1146                                                     GLuint* ids) {
   1147   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenSharedIdsCHROMIUM");
   1148   gl_->GenSharedIdsCHROMIUM(namespace_id, id_offset, n, ids);
   1149 }
   1150 
   1151 void GLES2TraceImplementation::DeleteSharedIdsCHROMIUM(GLuint namespace_id,
   1152                                                        GLsizei n,
   1153                                                        const GLuint* ids) {
   1154   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteSharedIdsCHROMIUM");
   1155   gl_->DeleteSharedIdsCHROMIUM(namespace_id, n, ids);
   1156 }
   1157 
   1158 void GLES2TraceImplementation::RegisterSharedIdsCHROMIUM(GLuint namespace_id,
   1159                                                          GLsizei n,
   1160                                                          const GLuint* ids) {
   1161   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::RegisterSharedIdsCHROMIUM");
   1162   gl_->RegisterSharedIdsCHROMIUM(namespace_id, n, ids);
   1163 }
   1164 
   1165 GLboolean GLES2TraceImplementation::EnableFeatureCHROMIUM(const char* feature) {
   1166   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EnableFeatureCHROMIUM");
   1167   return gl_->EnableFeatureCHROMIUM(feature);
   1168 }
   1169 
   1170 void* GLES2TraceImplementation::MapBufferCHROMIUM(GLuint target,
   1171                                                   GLenum access) {
   1172   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferCHROMIUM");
   1173   return gl_->MapBufferCHROMIUM(target, access);
   1174 }
   1175 
   1176 GLboolean GLES2TraceImplementation::UnmapBufferCHROMIUM(GLuint target) {
   1177   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UnmapBufferCHROMIUM");
   1178   return gl_->UnmapBufferCHROMIUM(target);
   1179 }
   1180 
   1181 void* GLES2TraceImplementation::MapImageCHROMIUM(GLuint image_id) {
   1182   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapImageCHROMIUM");
   1183   return gl_->MapImageCHROMIUM(image_id);
   1184 }
   1185 
   1186 void GLES2TraceImplementation::UnmapImageCHROMIUM(GLuint image_id) {
   1187   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UnmapImageCHROMIUM");
   1188   gl_->UnmapImageCHROMIUM(image_id);
   1189 }
   1190 
   1191 void* GLES2TraceImplementation::MapBufferSubDataCHROMIUM(GLuint target,
   1192                                                          GLintptr offset,
   1193                                                          GLsizeiptr size,
   1194                                                          GLenum access) {
   1195   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferSubDataCHROMIUM");
   1196   return gl_->MapBufferSubDataCHROMIUM(target, offset, size, access);
   1197 }
   1198 
   1199 void GLES2TraceImplementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
   1200   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1201                                 "GLES2Trace::UnmapBufferSubDataCHROMIUM");
   1202   gl_->UnmapBufferSubDataCHROMIUM(mem);
   1203 }
   1204 
   1205 void* GLES2TraceImplementation::MapTexSubImage2DCHROMIUM(GLenum target,
   1206                                                          GLint level,
   1207                                                          GLint xoffset,
   1208                                                          GLint yoffset,
   1209                                                          GLsizei width,
   1210                                                          GLsizei height,
   1211                                                          GLenum format,
   1212                                                          GLenum type,
   1213                                                          GLenum access) {
   1214   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapTexSubImage2DCHROMIUM");
   1215   return gl_->MapTexSubImage2DCHROMIUM(
   1216       target, level, xoffset, yoffset, width, height, format, type, access);
   1217 }
   1218 
   1219 void GLES2TraceImplementation::UnmapTexSubImage2DCHROMIUM(const void* mem) {
   1220   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1221                                 "GLES2Trace::UnmapTexSubImage2DCHROMIUM");
   1222   gl_->UnmapTexSubImage2DCHROMIUM(mem);
   1223 }
   1224 
   1225 void GLES2TraceImplementation::ResizeCHROMIUM(GLuint width,
   1226                                               GLuint height,
   1227                                               GLfloat scale_factor) {
   1228   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ResizeCHROMIUM");
   1229   gl_->ResizeCHROMIUM(width, height, scale_factor);
   1230 }
   1231 
   1232 const GLchar* GLES2TraceImplementation::GetRequestableExtensionsCHROMIUM() {
   1233   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1234                                 "GLES2Trace::GetRequestableExtensionsCHROMIUM");
   1235   return gl_->GetRequestableExtensionsCHROMIUM();
   1236 }
   1237 
   1238 void GLES2TraceImplementation::RequestExtensionCHROMIUM(const char* extension) {
   1239   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::RequestExtensionCHROMIUM");
   1240   gl_->RequestExtensionCHROMIUM(extension);
   1241 }
   1242 
   1243 void GLES2TraceImplementation::RateLimitOffscreenContextCHROMIUM() {
   1244   TRACE_EVENT_BINARY_EFFICIENT0(
   1245       "gpu", "GLES2Trace::RateLimitOffscreenContextCHROMIUM");
   1246   gl_->RateLimitOffscreenContextCHROMIUM();
   1247 }
   1248 
   1249 void GLES2TraceImplementation::GetMultipleIntegervCHROMIUM(const GLenum* pnames,
   1250                                                            GLuint count,
   1251                                                            GLint* results,
   1252                                                            GLsizeiptr size) {
   1253   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1254                                 "GLES2Trace::GetMultipleIntegervCHROMIUM");
   1255   gl_->GetMultipleIntegervCHROMIUM(pnames, count, results, size);
   1256 }
   1257 
   1258 void GLES2TraceImplementation::GetProgramInfoCHROMIUM(GLuint program,
   1259                                                       GLsizei bufsize,
   1260                                                       GLsizei* size,
   1261                                                       void* info) {
   1262   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramInfoCHROMIUM");
   1263   gl_->GetProgramInfoCHROMIUM(program, bufsize, size, info);
   1264 }
   1265 
   1266 GLuint GLES2TraceImplementation::CreateStreamTextureCHROMIUM(GLuint texture) {
   1267   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1268                                 "GLES2Trace::CreateStreamTextureCHROMIUM");
   1269   return gl_->CreateStreamTextureCHROMIUM(texture);
   1270 }
   1271 
   1272 GLuint GLES2TraceImplementation::CreateImageCHROMIUM(GLsizei width,
   1273                                                      GLsizei height,
   1274                                                      GLenum internalformat,
   1275                                                      GLenum usage) {
   1276   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateImageCHROMIUM");
   1277   return gl_->CreateImageCHROMIUM(width, height, internalformat, usage);
   1278 }
   1279 
   1280 void GLES2TraceImplementation::DestroyImageCHROMIUM(GLuint image_id) {
   1281   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DestroyImageCHROMIUM");
   1282   gl_->DestroyImageCHROMIUM(image_id);
   1283 }
   1284 
   1285 void GLES2TraceImplementation::GetImageParameterivCHROMIUM(GLuint image_id,
   1286                                                            GLenum pname,
   1287                                                            GLint* params) {
   1288   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1289                                 "GLES2Trace::GetImageParameterivCHROMIUM");
   1290   gl_->GetImageParameterivCHROMIUM(image_id, pname, params);
   1291 }
   1292 
   1293 void GLES2TraceImplementation::GetTranslatedShaderSourceANGLE(GLuint shader,
   1294                                                               GLsizei bufsize,
   1295                                                               GLsizei* length,
   1296                                                               char* source) {
   1297   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1298                                 "GLES2Trace::GetTranslatedShaderSourceANGLE");
   1299   gl_->GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
   1300 }
   1301 
   1302 void GLES2TraceImplementation::PostSubBufferCHROMIUM(GLint x,
   1303                                                      GLint y,
   1304                                                      GLint width,
   1305                                                      GLint height) {
   1306   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PostSubBufferCHROMIUM");
   1307   gl_->PostSubBufferCHROMIUM(x, y, width, height);
   1308 }
   1309 
   1310 void GLES2TraceImplementation::TexImageIOSurface2DCHROMIUM(GLenum target,
   1311                                                            GLsizei width,
   1312                                                            GLsizei height,
   1313                                                            GLuint ioSurfaceId,
   1314                                                            GLuint plane) {
   1315   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1316                                 "GLES2Trace::TexImageIOSurface2DCHROMIUM");
   1317   gl_->TexImageIOSurface2DCHROMIUM(target, width, height, ioSurfaceId, plane);
   1318 }
   1319 
   1320 void GLES2TraceImplementation::CopyTextureCHROMIUM(GLenum target,
   1321                                                    GLenum source_id,
   1322                                                    GLenum dest_id,
   1323                                                    GLint level,
   1324                                                    GLint internalformat,
   1325                                                    GLenum dest_type) {
   1326   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTextureCHROMIUM");
   1327   gl_->CopyTextureCHROMIUM(
   1328       target, source_id, dest_id, level, internalformat, dest_type);
   1329 }
   1330 
   1331 void GLES2TraceImplementation::DrawArraysInstancedANGLE(GLenum mode,
   1332                                                         GLint first,
   1333                                                         GLsizei count,
   1334                                                         GLsizei primcount) {
   1335   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawArraysInstancedANGLE");
   1336   gl_->DrawArraysInstancedANGLE(mode, first, count, primcount);
   1337 }
   1338 
   1339 void GLES2TraceImplementation::DrawElementsInstancedANGLE(GLenum mode,
   1340                                                           GLsizei count,
   1341                                                           GLenum type,
   1342                                                           const void* indices,
   1343                                                           GLsizei primcount) {
   1344   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1345                                 "GLES2Trace::DrawElementsInstancedANGLE");
   1346   gl_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
   1347 }
   1348 
   1349 void GLES2TraceImplementation::VertexAttribDivisorANGLE(GLuint index,
   1350                                                         GLuint divisor) {
   1351   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribDivisorANGLE");
   1352   gl_->VertexAttribDivisorANGLE(index, divisor);
   1353 }
   1354 
   1355 void GLES2TraceImplementation::GenMailboxCHROMIUM(GLbyte* mailbox) {
   1356   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenMailboxCHROMIUM");
   1357   gl_->GenMailboxCHROMIUM(mailbox);
   1358 }
   1359 
   1360 void GLES2TraceImplementation::ProduceTextureCHROMIUM(GLenum target,
   1361                                                       const GLbyte* mailbox) {
   1362   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ProduceTextureCHROMIUM");
   1363   gl_->ProduceTextureCHROMIUM(target, mailbox);
   1364 }
   1365 
   1366 void GLES2TraceImplementation::ProduceTextureDirectCHROMIUM(
   1367     GLuint texture,
   1368     GLenum target,
   1369     const GLbyte* mailbox) {
   1370   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1371                                 "GLES2Trace::ProduceTextureDirectCHROMIUM");
   1372   gl_->ProduceTextureDirectCHROMIUM(texture, target, mailbox);
   1373 }
   1374 
   1375 void GLES2TraceImplementation::ConsumeTextureCHROMIUM(GLenum target,
   1376                                                       const GLbyte* mailbox) {
   1377   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ConsumeTextureCHROMIUM");
   1378   gl_->ConsumeTextureCHROMIUM(target, mailbox);
   1379 }
   1380 
   1381 GLuint GLES2TraceImplementation::CreateAndConsumeTextureCHROMIUM(
   1382     GLenum target,
   1383     const GLbyte* mailbox) {
   1384   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1385                                 "GLES2Trace::CreateAndConsumeTextureCHROMIUM");
   1386   return gl_->CreateAndConsumeTextureCHROMIUM(target, mailbox);
   1387 }
   1388 
   1389 void GLES2TraceImplementation::BindUniformLocationCHROMIUM(GLuint program,
   1390                                                            GLint location,
   1391                                                            const char* name) {
   1392   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1393                                 "GLES2Trace::BindUniformLocationCHROMIUM");
   1394   gl_->BindUniformLocationCHROMIUM(program, location, name);
   1395 }
   1396 
   1397 void GLES2TraceImplementation::BindTexImage2DCHROMIUM(GLenum target,
   1398                                                       GLint imageId) {
   1399   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindTexImage2DCHROMIUM");
   1400   gl_->BindTexImage2DCHROMIUM(target, imageId);
   1401 }
   1402 
   1403 void GLES2TraceImplementation::ReleaseTexImage2DCHROMIUM(GLenum target,
   1404                                                          GLint imageId) {
   1405   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReleaseTexImage2DCHROMIUM");
   1406   gl_->ReleaseTexImage2DCHROMIUM(target, imageId);
   1407 }
   1408 
   1409 void GLES2TraceImplementation::TraceBeginCHROMIUM(const char* name) {
   1410   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceBeginCHROMIUM");
   1411   gl_->TraceBeginCHROMIUM(name);
   1412 }
   1413 
   1414 void GLES2TraceImplementation::TraceEndCHROMIUM() {
   1415   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceEndCHROMIUM");
   1416   gl_->TraceEndCHROMIUM();
   1417 }
   1418 
   1419 void GLES2TraceImplementation::AsyncTexSubImage2DCHROMIUM(GLenum target,
   1420                                                           GLint level,
   1421                                                           GLint xoffset,
   1422                                                           GLint yoffset,
   1423                                                           GLsizei width,
   1424                                                           GLsizei height,
   1425                                                           GLenum format,
   1426                                                           GLenum type,
   1427                                                           const void* data) {
   1428   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1429                                 "GLES2Trace::AsyncTexSubImage2DCHROMIUM");
   1430   gl_->AsyncTexSubImage2DCHROMIUM(
   1431       target, level, xoffset, yoffset, width, height, format, type, data);
   1432 }
   1433 
   1434 void GLES2TraceImplementation::AsyncTexImage2DCHROMIUM(GLenum target,
   1435                                                        GLint level,
   1436                                                        GLenum internalformat,
   1437                                                        GLsizei width,
   1438                                                        GLsizei height,
   1439                                                        GLint border,
   1440                                                        GLenum format,
   1441                                                        GLenum type,
   1442                                                        const void* pixels) {
   1443   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::AsyncTexImage2DCHROMIUM");
   1444   gl_->AsyncTexImage2DCHROMIUM(target,
   1445                                level,
   1446                                internalformat,
   1447                                width,
   1448                                height,
   1449                                border,
   1450                                format,
   1451                                type,
   1452                                pixels);
   1453 }
   1454 
   1455 void GLES2TraceImplementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
   1456   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1457                                 "GLES2Trace::WaitAsyncTexImage2DCHROMIUM");
   1458   gl_->WaitAsyncTexImage2DCHROMIUM(target);
   1459 }
   1460 
   1461 void GLES2TraceImplementation::WaitAllAsyncTexImage2DCHROMIUM() {
   1462   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1463                                 "GLES2Trace::WaitAllAsyncTexImage2DCHROMIUM");
   1464   gl_->WaitAllAsyncTexImage2DCHROMIUM();
   1465 }
   1466 
   1467 void GLES2TraceImplementation::DiscardFramebufferEXT(
   1468     GLenum target,
   1469     GLsizei count,
   1470     const GLenum* attachments) {
   1471   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DiscardFramebufferEXT");
   1472   gl_->DiscardFramebufferEXT(target, count, attachments);
   1473 }
   1474 
   1475 void GLES2TraceImplementation::LoseContextCHROMIUM(GLenum current,
   1476                                                    GLenum other) {
   1477   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LoseContextCHROMIUM");
   1478   gl_->LoseContextCHROMIUM(current, other);
   1479 }
   1480 
   1481 GLuint GLES2TraceImplementation::InsertSyncPointCHROMIUM() {
   1482   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InsertSyncPointCHROMIUM");
   1483   return gl_->InsertSyncPointCHROMIUM();
   1484 }
   1485 
   1486 void GLES2TraceImplementation::WaitSyncPointCHROMIUM(GLuint sync_point) {
   1487   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::WaitSyncPointCHROMIUM");
   1488   gl_->WaitSyncPointCHROMIUM(sync_point);
   1489 }
   1490 
   1491 void GLES2TraceImplementation::DrawBuffersEXT(GLsizei count,
   1492                                               const GLenum* bufs) {
   1493   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawBuffersEXT");
   1494   gl_->DrawBuffersEXT(count, bufs);
   1495 }
   1496 
   1497 void GLES2TraceImplementation::DiscardBackbufferCHROMIUM() {
   1498   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DiscardBackbufferCHROMIUM");
   1499   gl_->DiscardBackbufferCHROMIUM();
   1500 }
   1501 
   1502 void GLES2TraceImplementation::ScheduleOverlayPlaneCHROMIUM(
   1503     GLint plane_z_order,
   1504     GLenum plane_transform,
   1505     GLuint overlay_texture_id,
   1506     GLint bounds_x,
   1507     GLint bounds_y,
   1508     GLint bounds_width,
   1509     GLint bounds_height,
   1510     GLfloat uv_x,
   1511     GLfloat uv_y,
   1512     GLfloat uv_width,
   1513     GLfloat uv_height) {
   1514   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
   1515                                 "GLES2Trace::ScheduleOverlayPlaneCHROMIUM");
   1516   gl_->ScheduleOverlayPlaneCHROMIUM(plane_z_order,
   1517                                     plane_transform,
   1518                                     overlay_texture_id,
   1519                                     bounds_x,
   1520                                     bounds_y,
   1521                                     bounds_width,
   1522                                     bounds_height,
   1523                                     uv_x,
   1524                                     uv_y,
   1525                                     uv_width,
   1526                                     uv_height);
   1527 }
   1528 
   1529 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_
   1530