gpu/command_buffer/client/gles2_trace_implementation_impl_autogen.h

   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::BindBufferBase(GLenum target,
  38                                               GLuint index,
  39                                               GLuint buffer) {
  40   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindBufferBase");
  41   gl_->BindBufferBase(target, index, buffer);
  42 }
  43
  44 void GLES2TraceImplementation::BindBufferRange(GLenum target,
  45                                                GLuint index,
  46                                                GLuint buffer,
  47                                                GLintptr offset,
  48                                                GLsizeiptr size) {
  49   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindBufferRange");
  50   gl_->BindBufferRange(target, index, buffer, offset, size);
  51 }
  52
  53 void GLES2TraceImplementation::BindFramebuffer(GLenum target,
  54                                                GLuint framebuffer) {
  55   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindFramebuffer");
  56   gl_->BindFramebuffer(target, framebuffer);
  57 }
  58
  59 void GLES2TraceImplementation::BindRenderbuffer(GLenum target,
  60                                                 GLuint renderbuffer) {
  61   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindRenderbuffer");
  62   gl_->BindRenderbuffer(target, renderbuffer);
  63 }
  64
  65 void GLES2TraceImplementation::BindSampler(GLuint unit, GLuint sampler) {
  66   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindSampler");
  67   gl_->BindSampler(unit, sampler);
  68 }
  69
  70 void GLES2TraceImplementation::BindTexture(GLenum target, GLuint texture) {
  71   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindTexture");
  72   gl_->BindTexture(target, texture);
  73 }
  74
  75 void GLES2TraceImplementation::BindTransformFeedback(GLenum target,
  76                                                      GLuint transformfeedback) {
  77   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindTransformFeedback");
  78   gl_->BindTransformFeedback(target, transformfeedback);
  79 }
  80
  81 void GLES2TraceImplementation::BlendColor(GLclampf red,
  82                                           GLclampf green,
  83                                           GLclampf blue,
  84                                           GLclampf alpha) {
  85   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendColor");
  86   gl_->BlendColor(red, green, blue, alpha);
  87 }
  88
  89 void GLES2TraceImplementation::BlendEquation(GLenum mode) {
  90   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendEquation");
  91   gl_->BlendEquation(mode);
  92 }
  93
  94 void GLES2TraceImplementation::BlendEquationSeparate(GLenum modeRGB,
  95                                                      GLenum modeAlpha) {
  96   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendEquationSeparate");
  97   gl_->BlendEquationSeparate(modeRGB, modeAlpha);
  98 }
  99
 100 void GLES2TraceImplementation::BlendFunc(GLenum sfactor, GLenum dfactor) {
 101   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendFunc");
 102   gl_->BlendFunc(sfactor, dfactor);
 103 }
 104
 105 void GLES2TraceImplementation::BlendFuncSeparate(GLenum srcRGB,
 106                                                  GLenum dstRGB,
 107                                                  GLenum srcAlpha,
 108                                                  GLenum dstAlpha) {
 109   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendFuncSeparate");
 110   gl_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 111 }
 112
 113 void GLES2TraceImplementation::BufferData(GLenum target,
 114                                           GLsizeiptr size,
 115                                           const void* data,
 116                                           GLenum usage) {
 117   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BufferData");
 118   gl_->BufferData(target, size, data, usage);
 119 }
 120
 121 void GLES2TraceImplementation::BufferSubData(GLenum target,
 122                                              GLintptr offset,
 123                                              GLsizeiptr size,
 124                                              const void* data) {
 125   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BufferSubData");
 126   gl_->BufferSubData(target, offset, size, data);
 127 }
 128
 129 GLenum GLES2TraceImplementation::CheckFramebufferStatus(GLenum target) {
 130   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CheckFramebufferStatus");
 131   return gl_->CheckFramebufferStatus(target);
 132 }
 133
 134 void GLES2TraceImplementation::Clear(GLbitfield mask) {
 135   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Clear");
 136   gl_->Clear(mask);
 137 }
 138
 139 void GLES2TraceImplementation::ClearBufferfi(GLenum buffer,
 140                                              GLint drawbuffers,
 141                                              GLfloat depth,
 142                                              GLint stencil) {
 143   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferfi");
 144   gl_->ClearBufferfi(buffer, drawbuffers, depth, stencil);
 145 }
 146
 147 void GLES2TraceImplementation::ClearBufferfv(GLenum buffer,
 148                                              GLint drawbuffers,
 149                                              const GLfloat* value) {
 150   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferfv");
 151   gl_->ClearBufferfv(buffer, drawbuffers, value);
 152 }
 153
 154 void GLES2TraceImplementation::ClearBufferiv(GLenum buffer,
 155                                              GLint drawbuffers,
 156                                              const GLint* value) {
 157   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferiv");
 158   gl_->ClearBufferiv(buffer, drawbuffers, value);
 159 }
 160
 161 void GLES2TraceImplementation::ClearBufferuiv(GLenum buffer,
 162                                               GLint drawbuffers,
 163                                               const GLuint* value) {
 164   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearBufferuiv");
 165   gl_->ClearBufferuiv(buffer, drawbuffers, value);
 166 }
 167
 168 void GLES2TraceImplementation::ClearColor(GLclampf red,
 169                                           GLclampf green,
 170                                           GLclampf blue,
 171                                           GLclampf alpha) {
 172   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearColor");
 173   gl_->ClearColor(red, green, blue, alpha);
 174 }
 175
 176 void GLES2TraceImplementation::ClearDepthf(GLclampf depth) {
 177   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearDepthf");
 178   gl_->ClearDepthf(depth);
 179 }
 180
 181 void GLES2TraceImplementation::ClearStencil(GLint s) {
 182   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClearStencil");
 183   gl_->ClearStencil(s);
 184 }
 185
 186 GLenum GLES2TraceImplementation::ClientWaitSync(GLsync sync,
 187                                                 GLbitfield flags,
 188                                                 GLuint64 timeout) {
 189   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ClientWaitSync");
 190   return gl_->ClientWaitSync(sync, flags, timeout);
 191 }
 192
 193 void GLES2TraceImplementation::ColorMask(GLboolean red,
 194                                          GLboolean green,
 195                                          GLboolean blue,
 196                                          GLboolean alpha) {
 197   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ColorMask");
 198   gl_->ColorMask(red, green, blue, alpha);
 199 }
 200
 201 void GLES2TraceImplementation::CompileShader(GLuint shader) {
 202   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompileShader");
 203   gl_->CompileShader(shader);
 204 }
 205
 206 void GLES2TraceImplementation::CompressedTexImage2D(GLenum target,
 207                                                     GLint level,
 208                                                     GLenum internalformat,
 209                                                     GLsizei width,
 210                                                     GLsizei height,
 211                                                     GLint border,
 212                                                     GLsizei imageSize,
 213                                                     const void* data) {
 214   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompressedTexImage2D");
 215   gl_->CompressedTexImage2D(target, level, internalformat, width, height,
 216                             border, imageSize, data);
 217 }
 218
 219 void GLES2TraceImplementation::CompressedTexSubImage2D(GLenum target,
 220                                                        GLint level,
 221                                                        GLint xoffset,
 222                                                        GLint yoffset,
 223                                                        GLsizei width,
 224                                                        GLsizei height,
 225                                                        GLenum format,
 226                                                        GLsizei imageSize,
 227                                                        const void* data) {
 228   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompressedTexSubImage2D");
 229   gl_->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
 230                                format, imageSize, data);
 231 }
 232
 233 void GLES2TraceImplementation::CompressedTexImage3D(GLenum target,
 234                                                     GLint level,
 235                                                     GLenum internalformat,
 236                                                     GLsizei width,
 237                                                     GLsizei height,
 238                                                     GLsizei depth,
 239                                                     GLint border,
 240                                                     GLsizei imageSize,
 241                                                     const void* data) {
 242   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompressedTexImage3D");
 243   gl_->CompressedTexImage3D(target, level, internalformat, width, height, depth,
 244                             border, imageSize, data);
 245 }
 246
 247 void GLES2TraceImplementation::CompressedTexSubImage3D(GLenum target,
 248                                                        GLint level,
 249                                                        GLint xoffset,
 250                                                        GLint yoffset,
 251                                                        GLint zoffset,
 252                                                        GLsizei width,
 253                                                        GLsizei height,
 254                                                        GLsizei depth,
 255                                                        GLenum format,
 256                                                        GLsizei imageSize,
 257                                                        const void* data) {
 258   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CompressedTexSubImage3D");
 259   gl_->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
 260                                height, depth, format, imageSize, data);
 261 }
 262
 263 void GLES2TraceImplementation::CopyBufferSubData(GLenum readtarget,
 264                                                  GLenum writetarget,
 265                                                  GLintptr readoffset,
 266                                                  GLintptr writeoffset,
 267                                                  GLsizeiptr size) {
 268   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyBufferSubData");
 269   gl_->CopyBufferSubData(readtarget, writetarget, readoffset, writeoffset,
 270                          size);
 271 }
 272
 273 void GLES2TraceImplementation::CopyTexImage2D(GLenum target,
 274                                               GLint level,
 275                                               GLenum internalformat,
 276                                               GLint x,
 277                                               GLint y,
 278                                               GLsizei width,
 279                                               GLsizei height,
 280                                               GLint border) {
 281   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTexImage2D");
 282   gl_->CopyTexImage2D(target, level, internalformat, x, y, width, height,
 283                       border);
 284 }
 285
 286 void GLES2TraceImplementation::CopyTexSubImage2D(GLenum target,
 287                                                  GLint level,
 288                                                  GLint xoffset,
 289                                                  GLint yoffset,
 290                                                  GLint x,
 291                                                  GLint y,
 292                                                  GLsizei width,
 293                                                  GLsizei height) {
 294   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTexSubImage2D");
 295   gl_->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 296 }
 297
 298 void GLES2TraceImplementation::CopyTexSubImage3D(GLenum target,
 299                                                  GLint level,
 300                                                  GLint xoffset,
 301                                                  GLint yoffset,
 302                                                  GLint zoffset,
 303                                                  GLint x,
 304                                                  GLint y,
 305                                                  GLsizei width,
 306                                                  GLsizei height) {
 307   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTexSubImage3D");
 308   gl_->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width,
 309                          height);
 310 }
 311
 312 GLuint GLES2TraceImplementation::CreateProgram() {
 313   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateProgram");
 314   return gl_->CreateProgram();
 315 }
 316
 317 GLuint GLES2TraceImplementation::CreateShader(GLenum type) {
 318   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateShader");
 319   return gl_->CreateShader(type);
 320 }
 321
 322 void GLES2TraceImplementation::CullFace(GLenum mode) {
 323   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CullFace");
 324   gl_->CullFace(mode);
 325 }
 326
 327 void GLES2TraceImplementation::DeleteBuffers(GLsizei n, const GLuint* buffers) {
 328   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteBuffers");
 329   gl_->DeleteBuffers(n, buffers);
 330 }
 331
 332 void GLES2TraceImplementation::DeleteFramebuffers(GLsizei n,
 333                                                   const GLuint* framebuffers) {
 334   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteFramebuffers");
 335   gl_->DeleteFramebuffers(n, framebuffers);
 336 }
 337
 338 void GLES2TraceImplementation::DeleteProgram(GLuint program) {
 339   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteProgram");
 340   gl_->DeleteProgram(program);
 341 }
 342
 343 void GLES2TraceImplementation::DeleteRenderbuffers(
 344     GLsizei n,
 345     const GLuint* renderbuffers) {
 346   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteRenderbuffers");
 347   gl_->DeleteRenderbuffers(n, renderbuffers);
 348 }
 349
 350 void GLES2TraceImplementation::DeleteSamplers(GLsizei n,
 351                                               const GLuint* samplers) {
 352   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteSamplers");
 353   gl_->DeleteSamplers(n, samplers);
 354 }
 355
 356 void GLES2TraceImplementation::DeleteSync(GLsync sync) {
 357   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteSync");
 358   gl_->DeleteSync(sync);
 359 }
 360
 361 void GLES2TraceImplementation::DeleteShader(GLuint shader) {
 362   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteShader");
 363   gl_->DeleteShader(shader);
 364 }
 365
 366 void GLES2TraceImplementation::DeleteTextures(GLsizei n,
 367                                               const GLuint* textures) {
 368   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteTextures");
 369   gl_->DeleteTextures(n, textures);
 370 }
 371
 372 void GLES2TraceImplementation::DeleteTransformFeedbacks(GLsizei n,
 373                                                         const GLuint* ids) {
 374   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteTransformFeedbacks");
 375   gl_->DeleteTransformFeedbacks(n, ids);
 376 }
 377
 378 void GLES2TraceImplementation::DepthFunc(GLenum func) {
 379   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DepthFunc");
 380   gl_->DepthFunc(func);
 381 }
 382
 383 void GLES2TraceImplementation::DepthMask(GLboolean flag) {
 384   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DepthMask");
 385   gl_->DepthMask(flag);
 386 }
 387
 388 void GLES2TraceImplementation::DepthRangef(GLclampf zNear, GLclampf zFar) {
 389   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DepthRangef");
 390   gl_->DepthRangef(zNear, zFar);
 391 }
 392
 393 void GLES2TraceImplementation::DetachShader(GLuint program, GLuint shader) {
 394   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DetachShader");
 395   gl_->DetachShader(program, shader);
 396 }
 397
 398 void GLES2TraceImplementation::Disable(GLenum cap) {
 399   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Disable");
 400   gl_->Disable(cap);
 401 }
 402
 403 void GLES2TraceImplementation::DisableVertexAttribArray(GLuint index) {
 404   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DisableVertexAttribArray");
 405   gl_->DisableVertexAttribArray(index);
 406 }
 407
 408 void GLES2TraceImplementation::DrawArrays(GLenum mode,
 409                                           GLint first,
 410                                           GLsizei count) {
 411   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawArrays");
 412   gl_->DrawArrays(mode, first, count);
 413 }
 414
 415 void GLES2TraceImplementation::DrawElements(GLenum mode,
 416                                             GLsizei count,
 417                                             GLenum type,
 418                                             const void* indices) {
 419   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawElements");
 420   gl_->DrawElements(mode, count, type, indices);
 421 }
 422
 423 void GLES2TraceImplementation::DrawRangeElements(GLenum mode,
 424                                                  GLuint start,
 425                                                  GLuint end,
 426                                                  GLsizei count,
 427                                                  GLenum type,
 428                                                  const void* indices) {
 429   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawRangeElements");
 430   gl_->DrawRangeElements(mode, start, end, count, type, indices);
 431 }
 432
 433 void GLES2TraceImplementation::Enable(GLenum cap) {
 434   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Enable");
 435   gl_->Enable(cap);
 436 }
 437
 438 void GLES2TraceImplementation::EnableVertexAttribArray(GLuint index) {
 439   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EnableVertexAttribArray");
 440   gl_->EnableVertexAttribArray(index);
 441 }
 442
 443 GLsync GLES2TraceImplementation::FenceSync(GLenum condition, GLbitfield flags) {
 444   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FenceSync");
 445   return gl_->FenceSync(condition, flags);
 446 }
 447
 448 void GLES2TraceImplementation::Finish() {
 449   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Finish");
 450   gl_->Finish();
 451 }
 452
 453 void GLES2TraceImplementation::Flush() {
 454   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Flush");
 455   gl_->Flush();
 456 }
 457
 458 void GLES2TraceImplementation::FramebufferRenderbuffer(
 459     GLenum target,
 460     GLenum attachment,
 461     GLenum renderbuffertarget,
 462     GLuint renderbuffer) {
 463   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FramebufferRenderbuffer");
 464   gl_->FramebufferRenderbuffer(target, attachment, renderbuffertarget,
 465                                renderbuffer);
 466 }
 467
 468 void GLES2TraceImplementation::FramebufferTexture2D(GLenum target,
 469                                                     GLenum attachment,
 470                                                     GLenum textarget,
 471                                                     GLuint texture,
 472                                                     GLint level) {
 473   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FramebufferTexture2D");
 474   gl_->FramebufferTexture2D(target, attachment, textarget, texture, level);
 475 }
 476
 477 void GLES2TraceImplementation::FramebufferTextureLayer(GLenum target,
 478                                                        GLenum attachment,
 479                                                        GLuint texture,
 480                                                        GLint level,
 481                                                        GLint layer) {
 482   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FramebufferTextureLayer");
 483   gl_->FramebufferTextureLayer(target, attachment, texture, level, layer);
 484 }
 485
 486 void GLES2TraceImplementation::FrontFace(GLenum mode) {
 487   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FrontFace");
 488   gl_->FrontFace(mode);
 489 }
 490
 491 void GLES2TraceImplementation::GenBuffers(GLsizei n, GLuint* buffers) {
 492   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenBuffers");
 493   gl_->GenBuffers(n, buffers);
 494 }
 495
 496 void GLES2TraceImplementation::GenerateMipmap(GLenum target) {
 497   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenerateMipmap");
 498   gl_->GenerateMipmap(target);
 499 }
 500
 501 void GLES2TraceImplementation::GenFramebuffers(GLsizei n,
 502                                                GLuint* framebuffers) {
 503   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenFramebuffers");
 504   gl_->GenFramebuffers(n, framebuffers);
 505 }
 506
 507 void GLES2TraceImplementation::GenRenderbuffers(GLsizei n,
 508                                                 GLuint* renderbuffers) {
 509   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenRenderbuffers");
 510   gl_->GenRenderbuffers(n, renderbuffers);
 511 }
 512
 513 void GLES2TraceImplementation::GenSamplers(GLsizei n, GLuint* samplers) {
 514   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenSamplers");
 515   gl_->GenSamplers(n, samplers);
 516 }
 517
 518 void GLES2TraceImplementation::GenTextures(GLsizei n, GLuint* textures) {
 519   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenTextures");
 520   gl_->GenTextures(n, textures);
 521 }
 522
 523 void GLES2TraceImplementation::GenTransformFeedbacks(GLsizei n, GLuint* ids) {
 524   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenTransformFeedbacks");
 525   gl_->GenTransformFeedbacks(n, ids);
 526 }
 527
 528 void GLES2TraceImplementation::GetActiveAttrib(GLuint program,
 529                                                GLuint index,
 530                                                GLsizei bufsize,
 531                                                GLsizei* length,
 532                                                GLint* size,
 533                                                GLenum* type,
 534                                                char* name) {
 535   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveAttrib");
 536   gl_->GetActiveAttrib(program, index, bufsize, length, size, type, name);
 537 }
 538
 539 void GLES2TraceImplementation::GetActiveUniform(GLuint program,
 540                                                 GLuint index,
 541                                                 GLsizei bufsize,
 542                                                 GLsizei* length,
 543                                                 GLint* size,
 544                                                 GLenum* type,
 545                                                 char* name) {
 546   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveUniform");
 547   gl_->GetActiveUniform(program, index, bufsize, length, size, type, name);
 548 }
 549
 550 void GLES2TraceImplementation::GetActiveUniformBlockiv(GLuint program,
 551                                                        GLuint index,
 552                                                        GLenum pname,
 553                                                        GLint* params) {
 554   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveUniformBlockiv");
 555   gl_->GetActiveUniformBlockiv(program, index, pname, params);
 556 }
 557
 558 void GLES2TraceImplementation::GetActiveUniformBlockName(GLuint program,
 559                                                          GLuint index,
 560                                                          GLsizei bufsize,
 561                                                          GLsizei* length,
 562                                                          char* name) {
 563   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveUniformBlockName");
 564   gl_->GetActiveUniformBlockName(program, index, bufsize, length, name);
 565 }
 566
 567 void GLES2TraceImplementation::GetActiveUniformsiv(GLuint program,
 568                                                    GLsizei count,
 569                                                    const GLuint* indices,
 570                                                    GLenum pname,
 571                                                    GLint* params) {
 572   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetActiveUniformsiv");
 573   gl_->GetActiveUniformsiv(program, count, indices, pname, params);
 574 }
 575
 576 void GLES2TraceImplementation::GetAttachedShaders(GLuint program,
 577                                                   GLsizei maxcount,
 578                                                   GLsizei* count,
 579                                                   GLuint* shaders) {
 580   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetAttachedShaders");
 581   gl_->GetAttachedShaders(program, maxcount, count, shaders);
 582 }
 583
 584 GLint GLES2TraceImplementation::GetAttribLocation(GLuint program,
 585                                                   const char* name) {
 586   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetAttribLocation");
 587   return gl_->GetAttribLocation(program, name);
 588 }
 589
 590 void GLES2TraceImplementation::GetBooleanv(GLenum pname, GLboolean* params) {
 591   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetBooleanv");
 592   gl_->GetBooleanv(pname, params);
 593 }
 594
 595 void GLES2TraceImplementation::GetBufferParameteri64v(GLenum target,
 596                                                       GLenum pname,
 597                                                       GLint64* params) {
 598   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetBufferParameteri64v");
 599   gl_->GetBufferParameteri64v(target, pname, params);
 600 }
 601
 602 void GLES2TraceImplementation::GetBufferParameteriv(GLenum target,
 603                                                     GLenum pname,
 604                                                     GLint* params) {
 605   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetBufferParameteriv");
 606   gl_->GetBufferParameteriv(target, pname, params);
 607 }
 608
 609 GLenum GLES2TraceImplementation::GetError() {
 610   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetError");
 611   return gl_->GetError();
 612 }
 613
 614 void GLES2TraceImplementation::GetFloatv(GLenum pname, GLfloat* params) {
 615   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetFloatv");
 616   gl_->GetFloatv(pname, params);
 617 }
 618
 619 GLint GLES2TraceImplementation::GetFragDataLocation(GLuint program,
 620                                                     const char* name) {
 621   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetFragDataLocation");
 622   return gl_->GetFragDataLocation(program, name);
 623 }
 624
 625 void GLES2TraceImplementation::GetFramebufferAttachmentParameteriv(
 626     GLenum target,
 627     GLenum attachment,
 628     GLenum pname,
 629     GLint* params) {
 630   TRACE_EVENT_BINARY_EFFICIENT0(
 631       "gpu", "GLES2Trace::GetFramebufferAttachmentParameteriv");
 632   gl_->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 633 }
 634
 635 void GLES2TraceImplementation::GetInteger64v(GLenum pname, GLint64* params) {
 636   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetInteger64v");
 637   gl_->GetInteger64v(pname, params);
 638 }
 639
 640 void GLES2TraceImplementation::GetIntegeri_v(GLenum pname,
 641                                              GLuint index,
 642                                              GLint* data) {
 643   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetIntegeri_v");
 644   gl_->GetIntegeri_v(pname, index, data);
 645 }
 646
 647 void GLES2TraceImplementation::GetInteger64i_v(GLenum pname,
 648                                                GLuint index,
 649                                                GLint64* data) {
 650   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetInteger64i_v");
 651   gl_->GetInteger64i_v(pname, index, data);
 652 }
 653
 654 void GLES2TraceImplementation::GetIntegerv(GLenum pname, GLint* params) {
 655   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetIntegerv");
 656   gl_->GetIntegerv(pname, params);
 657 }
 658
 659 void GLES2TraceImplementation::GetInternalformativ(GLenum target,
 660                                                    GLenum format,
 661                                                    GLenum pname,
 662                                                    GLsizei bufSize,
 663                                                    GLint* params) {
 664   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetInternalformativ");
 665   gl_->GetInternalformativ(target, format, pname, bufSize, params);
 666 }
 667
 668 void GLES2TraceImplementation::GetProgramiv(GLuint program,
 669                                             GLenum pname,
 670                                             GLint* params) {
 671   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramiv");
 672   gl_->GetProgramiv(program, pname, params);
 673 }
 674
 675 void GLES2TraceImplementation::GetProgramInfoLog(GLuint program,
 676                                                  GLsizei bufsize,
 677                                                  GLsizei* length,
 678                                                  char* infolog) {
 679   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramInfoLog");
 680   gl_->GetProgramInfoLog(program, bufsize, length, infolog);
 681 }
 682
 683 void GLES2TraceImplementation::GetRenderbufferParameteriv(GLenum target,
 684                                                           GLenum pname,
 685                                                           GLint* params) {
 686   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
 687                                 "GLES2Trace::GetRenderbufferParameteriv");
 688   gl_->GetRenderbufferParameteriv(target, pname, params);
 689 }
 690
 691 void GLES2TraceImplementation::GetSamplerParameterfv(GLuint sampler,
 692                                                      GLenum pname,
 693                                                      GLfloat* params) {
 694   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetSamplerParameterfv");
 695   gl_->GetSamplerParameterfv(sampler, pname, params);
 696 }
 697
 698 void GLES2TraceImplementation::GetSamplerParameteriv(GLuint sampler,
 699                                                      GLenum pname,
 700                                                      GLint* params) {
 701   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetSamplerParameteriv");
 702   gl_->GetSamplerParameteriv(sampler, pname, params);
 703 }
 704
 705 void GLES2TraceImplementation::GetShaderiv(GLuint shader,
 706                                            GLenum pname,
 707                                            GLint* params) {
 708   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderiv");
 709   gl_->GetShaderiv(shader, pname, params);
 710 }
 711
 712 void GLES2TraceImplementation::GetShaderInfoLog(GLuint shader,
 713                                                 GLsizei bufsize,
 714                                                 GLsizei* length,
 715                                                 char* infolog) {
 716   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderInfoLog");
 717   gl_->GetShaderInfoLog(shader, bufsize, length, infolog);
 718 }
 719
 720 void GLES2TraceImplementation::GetShaderPrecisionFormat(GLenum shadertype,
 721                                                         GLenum precisiontype,
 722                                                         GLint* range,
 723                                                         GLint* precision) {
 724   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderPrecisionFormat");
 725   gl_->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 726 }
 727
 728 void GLES2TraceImplementation::GetShaderSource(GLuint shader,
 729                                                GLsizei bufsize,
 730                                                GLsizei* length,
 731                                                char* source) {
 732   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetShaderSource");
 733   gl_->GetShaderSource(shader, bufsize, length, source);
 734 }
 735
 736 const GLubyte* GLES2TraceImplementation::GetString(GLenum name) {
 737   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetString");
 738   return gl_->GetString(name);
 739 }
 740
 741 void GLES2TraceImplementation::GetSynciv(GLsync sync,
 742                                          GLenum pname,
 743                                          GLsizei bufsize,
 744                                          GLsizei* length,
 745                                          GLint* values) {
 746   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetSynciv");
 747   gl_->GetSynciv(sync, pname, bufsize, length, values);
 748 }
 749
 750 void GLES2TraceImplementation::GetTexParameterfv(GLenum target,
 751                                                  GLenum pname,
 752                                                  GLfloat* params) {
 753   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetTexParameterfv");
 754   gl_->GetTexParameterfv(target, pname, params);
 755 }
 756
 757 void GLES2TraceImplementation::GetTexParameteriv(GLenum target,
 758                                                  GLenum pname,
 759                                                  GLint* params) {
 760   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetTexParameteriv");
 761   gl_->GetTexParameteriv(target, pname, params);
 762 }
 763
 764 void GLES2TraceImplementation::GetTransformFeedbackVarying(GLuint program,
 765                                                            GLuint index,
 766                                                            GLsizei bufsize,
 767                                                            GLsizei* length,
 768                                                            GLsizei* size,
 769                                                            GLenum* type,
 770                                                            char* name) {
 771   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
 772                                 "GLES2Trace::GetTransformFeedbackVarying");
 773   gl_->GetTransformFeedbackVarying(program, index, bufsize, length, size, type,
 774                                    name);
 775 }
 776
 777 GLuint GLES2TraceImplementation::GetUniformBlockIndex(GLuint program,
 778                                                       const char* name) {
 779   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformBlockIndex");
 780   return gl_->GetUniformBlockIndex(program, name);
 781 }
 782
 783 void GLES2TraceImplementation::GetUniformfv(GLuint program,
 784                                             GLint location,
 785                                             GLfloat* params) {
 786   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformfv");
 787   gl_->GetUniformfv(program, location, params);
 788 }
 789
 790 void GLES2TraceImplementation::GetUniformiv(GLuint program,
 791                                             GLint location,
 792                                             GLint* params) {
 793   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformiv");
 794   gl_->GetUniformiv(program, location, params);
 795 }
 796
 797 void GLES2TraceImplementation::GetUniformuiv(GLuint program,
 798                                              GLint location,
 799                                              GLuint* params) {
 800   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformuiv");
 801   gl_->GetUniformuiv(program, location, params);
 802 }
 803
 804 void GLES2TraceImplementation::GetUniformIndices(GLuint program,
 805                                                  GLsizei count,
 806                                                  const char* const* names,
 807                                                  GLuint* indices) {
 808   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformIndices");
 809   gl_->GetUniformIndices(program, count, names, indices);
 810 }
 811
 812 GLint GLES2TraceImplementation::GetUniformLocation(GLuint program,
 813                                                    const char* name) {
 814   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformLocation");
 815   return gl_->GetUniformLocation(program, name);
 816 }
 817
 818 void GLES2TraceImplementation::GetVertexAttribfv(GLuint index,
 819                                                  GLenum pname,
 820                                                  GLfloat* params) {
 821   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribfv");
 822   gl_->GetVertexAttribfv(index, pname, params);
 823 }
 824
 825 void GLES2TraceImplementation::GetVertexAttribiv(GLuint index,
 826                                                  GLenum pname,
 827                                                  GLint* params) {
 828   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribiv");
 829   gl_->GetVertexAttribiv(index, pname, params);
 830 }
 831
 832 void GLES2TraceImplementation::GetVertexAttribIiv(GLuint index,
 833                                                   GLenum pname,
 834                                                   GLint* params) {
 835   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribIiv");
 836   gl_->GetVertexAttribIiv(index, pname, params);
 837 }
 838
 839 void GLES2TraceImplementation::GetVertexAttribIuiv(GLuint index,
 840                                                    GLenum pname,
 841                                                    GLuint* params) {
 842   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribIuiv");
 843   gl_->GetVertexAttribIuiv(index, pname, params);
 844 }
 845
 846 void GLES2TraceImplementation::GetVertexAttribPointerv(GLuint index,
 847                                                        GLenum pname,
 848                                                        void** pointer) {
 849   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetVertexAttribPointerv");
 850   gl_->GetVertexAttribPointerv(index, pname, pointer);
 851 }
 852
 853 void GLES2TraceImplementation::Hint(GLenum target, GLenum mode) {
 854   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Hint");
 855   gl_->Hint(target, mode);
 856 }
 857
 858 void GLES2TraceImplementation::InvalidateFramebuffer(
 859     GLenum target,
 860     GLsizei count,
 861     const GLenum* attachments) {
 862   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InvalidateFramebuffer");
 863   gl_->InvalidateFramebuffer(target, count, attachments);
 864 }
 865
 866 void GLES2TraceImplementation::InvalidateSubFramebuffer(
 867     GLenum target,
 868     GLsizei count,
 869     const GLenum* attachments,
 870     GLint x,
 871     GLint y,
 872     GLsizei width,
 873     GLsizei height) {
 874   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InvalidateSubFramebuffer");
 875   gl_->InvalidateSubFramebuffer(target, count, attachments, x, y, width,
 876                                 height);
 877 }
 878
 879 GLboolean GLES2TraceImplementation::IsBuffer(GLuint buffer) {
 880   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsBuffer");
 881   return gl_->IsBuffer(buffer);
 882 }
 883
 884 GLboolean GLES2TraceImplementation::IsEnabled(GLenum cap) {
 885   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsEnabled");
 886   return gl_->IsEnabled(cap);
 887 }
 888
 889 GLboolean GLES2TraceImplementation::IsFramebuffer(GLuint framebuffer) {
 890   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsFramebuffer");
 891   return gl_->IsFramebuffer(framebuffer);
 892 }
 893
 894 GLboolean GLES2TraceImplementation::IsProgram(GLuint program) {
 895   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsProgram");
 896   return gl_->IsProgram(program);
 897 }
 898
 899 GLboolean GLES2TraceImplementation::IsRenderbuffer(GLuint renderbuffer) {
 900   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsRenderbuffer");
 901   return gl_->IsRenderbuffer(renderbuffer);
 902 }
 903
 904 GLboolean GLES2TraceImplementation::IsSampler(GLuint sampler) {
 905   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsSampler");
 906   return gl_->IsSampler(sampler);
 907 }
 908
 909 GLboolean GLES2TraceImplementation::IsShader(GLuint shader) {
 910   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsShader");
 911   return gl_->IsShader(shader);
 912 }
 913
 914 GLboolean GLES2TraceImplementation::IsSync(GLsync sync) {
 915   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsSync");
 916   return gl_->IsSync(sync);
 917 }
 918
 919 GLboolean GLES2TraceImplementation::IsTexture(GLuint texture) {
 920   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsTexture");
 921   return gl_->IsTexture(texture);
 922 }
 923
 924 GLboolean GLES2TraceImplementation::IsTransformFeedback(
 925     GLuint transformfeedback) {
 926   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsTransformFeedback");
 927   return gl_->IsTransformFeedback(transformfeedback);
 928 }
 929
 930 void GLES2TraceImplementation::LineWidth(GLfloat width) {
 931   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LineWidth");
 932   gl_->LineWidth(width);
 933 }
 934
 935 void GLES2TraceImplementation::LinkProgram(GLuint program) {
 936   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LinkProgram");
 937   gl_->LinkProgram(program);
 938 }
 939
 940 void GLES2TraceImplementation::PauseTransformFeedback() {
 941   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PauseTransformFeedback");
 942   gl_->PauseTransformFeedback();
 943 }
 944
 945 void GLES2TraceImplementation::PixelStorei(GLenum pname, GLint param) {
 946   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PixelStorei");
 947   gl_->PixelStorei(pname, param);
 948 }
 949
 950 void GLES2TraceImplementation::PolygonOffset(GLfloat factor, GLfloat units) {
 951   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PolygonOffset");
 952   gl_->PolygonOffset(factor, units);
 953 }
 954
 955 void GLES2TraceImplementation::ReadBuffer(GLenum src) {
 956   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReadBuffer");
 957   gl_->ReadBuffer(src);
 958 }
 959
 960 void GLES2TraceImplementation::ReadPixels(GLint x,
 961                                           GLint y,
 962                                           GLsizei width,
 963                                           GLsizei height,
 964                                           GLenum format,
 965                                           GLenum type,
 966                                           void* pixels) {
 967   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReadPixels");
 968   gl_->ReadPixels(x, y, width, height, format, type, pixels);
 969 }
 970
 971 void GLES2TraceImplementation::ReleaseShaderCompiler() {
 972   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReleaseShaderCompiler");
 973   gl_->ReleaseShaderCompiler();
 974 }
 975
 976 void GLES2TraceImplementation::RenderbufferStorage(GLenum target,
 977                                                    GLenum internalformat,
 978                                                    GLsizei width,
 979                                                    GLsizei height) {
 980   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::RenderbufferStorage");
 981   gl_->RenderbufferStorage(target, internalformat, width, height);
 982 }
 983
 984 void GLES2TraceImplementation::ResumeTransformFeedback() {
 985   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ResumeTransformFeedback");
 986   gl_->ResumeTransformFeedback();
 987 }
 988
 989 void GLES2TraceImplementation::SampleCoverage(GLclampf value,
 990                                               GLboolean invert) {
 991   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SampleCoverage");
 992   gl_->SampleCoverage(value, invert);
 993 }
 994
 995 void GLES2TraceImplementation::SamplerParameterf(GLuint sampler,
 996                                                  GLenum pname,
 997                                                  GLfloat param) {
 998   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SamplerParameterf");
 999   gl_->SamplerParameterf(sampler, pname, param);
1000 }
1001
1002 void GLES2TraceImplementation::SamplerParameterfv(GLuint sampler,
1003                                                   GLenum pname,
1004                                                   const GLfloat* params) {
1005   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SamplerParameterfv");
1006   gl_->SamplerParameterfv(sampler, pname, params);
1007 }
1008
1009 void GLES2TraceImplementation::SamplerParameteri(GLuint sampler,
1010                                                  GLenum pname,
1011                                                  GLint param) {
1012   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SamplerParameteri");
1013   gl_->SamplerParameteri(sampler, pname, param);
1014 }
1015
1016 void GLES2TraceImplementation::SamplerParameteriv(GLuint sampler,
1017                                                   GLenum pname,
1018                                                   const GLint* params) {
1019   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SamplerParameteriv");
1020   gl_->SamplerParameteriv(sampler, pname, params);
1021 }
1022
1023 void GLES2TraceImplementation::Scissor(GLint x,
1024                                        GLint y,
1025                                        GLsizei width,
1026                                        GLsizei height) {
1027   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Scissor");
1028   gl_->Scissor(x, y, width, height);
1029 }
1030
1031 void GLES2TraceImplementation::ShaderBinary(GLsizei n,
1032                                             const GLuint* shaders,
1033                                             GLenum binaryformat,
1034                                             const void* binary,
1035                                             GLsizei length) {
1036   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShaderBinary");
1037   gl_->ShaderBinary(n, shaders, binaryformat, binary, length);
1038 }
1039
1040 void GLES2TraceImplementation::ShaderSource(GLuint shader,
1041                                             GLsizei count,
1042                                             const GLchar* const* str,
1043                                             const GLint* length) {
1044   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShaderSource");
1045   gl_->ShaderSource(shader, count, str, length);
1046 }
1047
1048 void GLES2TraceImplementation::ShallowFinishCHROMIUM() {
1049   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShallowFinishCHROMIUM");
1050   gl_->ShallowFinishCHROMIUM();
1051 }
1052
1053 void GLES2TraceImplementation::ShallowFlushCHROMIUM() {
1054   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ShallowFlushCHROMIUM");
1055   gl_->ShallowFlushCHROMIUM();
1056 }
1057
1058 void GLES2TraceImplementation::OrderingBarrierCHROMIUM() {
1059   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::OrderingBarrierCHROMIUM");
1060   gl_->OrderingBarrierCHROMIUM();
1061 }
1062
1063 void GLES2TraceImplementation::StencilFunc(GLenum func,
1064                                            GLint ref,
1065                                            GLuint mask) {
1066   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilFunc");
1067   gl_->StencilFunc(func, ref, mask);
1068 }
1069
1070 void GLES2TraceImplementation::StencilFuncSeparate(GLenum face,
1071                                                    GLenum func,
1072                                                    GLint ref,
1073                                                    GLuint mask) {
1074   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilFuncSeparate");
1075   gl_->StencilFuncSeparate(face, func, ref, mask);
1076 }
1077
1078 void GLES2TraceImplementation::StencilMask(GLuint mask) {
1079   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilMask");
1080   gl_->StencilMask(mask);
1081 }
1082
1083 void GLES2TraceImplementation::StencilMaskSeparate(GLenum face, GLuint mask) {
1084   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilMaskSeparate");
1085   gl_->StencilMaskSeparate(face, mask);
1086 }
1087
1088 void GLES2TraceImplementation::StencilOp(GLenum fail,
1089                                          GLenum zfail,
1090                                          GLenum zpass) {
1091   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilOp");
1092   gl_->StencilOp(fail, zfail, zpass);
1093 }
1094
1095 void GLES2TraceImplementation::StencilOpSeparate(GLenum face,
1096                                                  GLenum fail,
1097                                                  GLenum zfail,
1098                                                  GLenum zpass) {
1099   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilOpSeparate");
1100   gl_->StencilOpSeparate(face, fail, zfail, zpass);
1101 }
1102
1103 void GLES2TraceImplementation::TexImage2D(GLenum target,
1104                                           GLint level,
1105                                           GLint internalformat,
1106                                           GLsizei width,
1107                                           GLsizei height,
1108                                           GLint border,
1109                                           GLenum format,
1110                                           GLenum type,
1111                                           const void* pixels) {
1112   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexImage2D");
1113   gl_->TexImage2D(target, level, internalformat, width, height, border, format,
1114                   type, pixels);
1115 }
1116
1117 void GLES2TraceImplementation::TexImage3D(GLenum target,
1118                                           GLint level,
1119                                           GLint internalformat,
1120                                           GLsizei width,
1121                                           GLsizei height,
1122                                           GLsizei depth,
1123                                           GLint border,
1124                                           GLenum format,
1125                                           GLenum type,
1126                                           const void* pixels) {
1127   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexImage3D");
1128   gl_->TexImage3D(target, level, internalformat, width, height, depth, border,
1129                   format, type, pixels);
1130 }
1131
1132 void GLES2TraceImplementation::TexParameterf(GLenum target,
1133                                              GLenum pname,
1134                                              GLfloat param) {
1135   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameterf");
1136   gl_->TexParameterf(target, pname, param);
1137 }
1138
1139 void GLES2TraceImplementation::TexParameterfv(GLenum target,
1140                                               GLenum pname,
1141                                               const GLfloat* params) {
1142   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameterfv");
1143   gl_->TexParameterfv(target, pname, params);
1144 }
1145
1146 void GLES2TraceImplementation::TexParameteri(GLenum target,
1147                                              GLenum pname,
1148                                              GLint param) {
1149   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameteri");
1150   gl_->TexParameteri(target, pname, param);
1151 }
1152
1153 void GLES2TraceImplementation::TexParameteriv(GLenum target,
1154                                               GLenum pname,
1155                                               const GLint* params) {
1156   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexParameteriv");
1157   gl_->TexParameteriv(target, pname, params);
1158 }
1159
1160 void GLES2TraceImplementation::TexStorage3D(GLenum target,
1161                                             GLsizei levels,
1162                                             GLenum internalFormat,
1163                                             GLsizei width,
1164                                             GLsizei height,
1165                                             GLsizei depth) {
1166   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexStorage3D");
1167   gl_->TexStorage3D(target, levels, internalFormat, width, height, depth);
1168 }
1169
1170 void GLES2TraceImplementation::TexSubImage2D(GLenum target,
1171                                              GLint level,
1172                                              GLint xoffset,
1173                                              GLint yoffset,
1174                                              GLsizei width,
1175                                              GLsizei height,
1176                                              GLenum format,
1177                                              GLenum type,
1178                                              const void* pixels) {
1179   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexSubImage2D");
1180   gl_->TexSubImage2D(target, level, xoffset, yoffset, width, height, format,
1181                      type, pixels);
1182 }
1183
1184 void GLES2TraceImplementation::TexSubImage3D(GLenum target,
1185                                              GLint level,
1186                                              GLint xoffset,
1187                                              GLint yoffset,
1188                                              GLint zoffset,
1189                                              GLsizei width,
1190                                              GLsizei height,
1191                                              GLsizei depth,
1192                                              GLenum format,
1193                                              GLenum type,
1194                                              const void* pixels) {
1195   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexSubImage3D");
1196   gl_->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
1197                      depth, format, type, pixels);
1198 }
1199
1200 void GLES2TraceImplementation::TransformFeedbackVaryings(
1201     GLuint program,
1202     GLsizei count,
1203     const char* const* varyings,
1204     GLenum buffermode) {
1205   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TransformFeedbackVaryings");
1206   gl_->TransformFeedbackVaryings(program, count, varyings, buffermode);
1207 }
1208
1209 void GLES2TraceImplementation::Uniform1f(GLint location, GLfloat x) {
1210   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1f");
1211   gl_->Uniform1f(location, x);
1212 }
1213
1214 void GLES2TraceImplementation::Uniform1fv(GLint location,
1215                                           GLsizei count,
1216                                           const GLfloat* v) {
1217   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1fv");
1218   gl_->Uniform1fv(location, count, v);
1219 }
1220
1221 void GLES2TraceImplementation::Uniform1i(GLint location, GLint x) {
1222   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1i");
1223   gl_->Uniform1i(location, x);
1224 }
1225
1226 void GLES2TraceImplementation::Uniform1iv(GLint location,
1227                                           GLsizei count,
1228                                           const GLint* v) {
1229   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1iv");
1230   gl_->Uniform1iv(location, count, v);
1231 }
1232
1233 void GLES2TraceImplementation::Uniform1ui(GLint location, GLuint x) {
1234   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1ui");
1235   gl_->Uniform1ui(location, x);
1236 }
1237
1238 void GLES2TraceImplementation::Uniform1uiv(GLint location,
1239                                            GLsizei count,
1240                                            const GLuint* v) {
1241   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform1uiv");
1242   gl_->Uniform1uiv(location, count, v);
1243 }
1244
1245 void GLES2TraceImplementation::Uniform2f(GLint location, GLfloat x, GLfloat y) {
1246   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2f");
1247   gl_->Uniform2f(location, x, y);
1248 }
1249
1250 void GLES2TraceImplementation::Uniform2fv(GLint location,
1251                                           GLsizei count,
1252                                           const GLfloat* v) {
1253   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2fv");
1254   gl_->Uniform2fv(location, count, v);
1255 }
1256
1257 void GLES2TraceImplementation::Uniform2i(GLint location, GLint x, GLint y) {
1258   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2i");
1259   gl_->Uniform2i(location, x, y);
1260 }
1261
1262 void GLES2TraceImplementation::Uniform2iv(GLint location,
1263                                           GLsizei count,
1264                                           const GLint* v) {
1265   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2iv");
1266   gl_->Uniform2iv(location, count, v);
1267 }
1268
1269 void GLES2TraceImplementation::Uniform2ui(GLint location, GLuint x, GLuint y) {
1270   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2ui");
1271   gl_->Uniform2ui(location, x, y);
1272 }
1273
1274 void GLES2TraceImplementation::Uniform2uiv(GLint location,
1275                                            GLsizei count,
1276                                            const GLuint* v) {
1277   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform2uiv");
1278   gl_->Uniform2uiv(location, count, v);
1279 }
1280
1281 void GLES2TraceImplementation::Uniform3f(GLint location,
1282                                          GLfloat x,
1283                                          GLfloat y,
1284                                          GLfloat z) {
1285   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3f");
1286   gl_->Uniform3f(location, x, y, z);
1287 }
1288
1289 void GLES2TraceImplementation::Uniform3fv(GLint location,
1290                                           GLsizei count,
1291                                           const GLfloat* v) {
1292   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3fv");
1293   gl_->Uniform3fv(location, count, v);
1294 }
1295
1296 void GLES2TraceImplementation::Uniform3i(GLint location,
1297                                          GLint x,
1298                                          GLint y,
1299                                          GLint z) {
1300   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3i");
1301   gl_->Uniform3i(location, x, y, z);
1302 }
1303
1304 void GLES2TraceImplementation::Uniform3iv(GLint location,
1305                                           GLsizei count,
1306                                           const GLint* v) {
1307   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3iv");
1308   gl_->Uniform3iv(location, count, v);
1309 }
1310
1311 void GLES2TraceImplementation::Uniform3ui(GLint location,
1312                                           GLuint x,
1313                                           GLuint y,
1314                                           GLuint z) {
1315   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3ui");
1316   gl_->Uniform3ui(location, x, y, z);
1317 }
1318
1319 void GLES2TraceImplementation::Uniform3uiv(GLint location,
1320                                            GLsizei count,
1321                                            const GLuint* v) {
1322   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform3uiv");
1323   gl_->Uniform3uiv(location, count, v);
1324 }
1325
1326 void GLES2TraceImplementation::Uniform4f(GLint location,
1327                                          GLfloat x,
1328                                          GLfloat y,
1329                                          GLfloat z,
1330                                          GLfloat w) {
1331   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4f");
1332   gl_->Uniform4f(location, x, y, z, w);
1333 }
1334
1335 void GLES2TraceImplementation::Uniform4fv(GLint location,
1336                                           GLsizei count,
1337                                           const GLfloat* v) {
1338   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4fv");
1339   gl_->Uniform4fv(location, count, v);
1340 }
1341
1342 void GLES2TraceImplementation::Uniform4i(GLint location,
1343                                          GLint x,
1344                                          GLint y,
1345                                          GLint z,
1346                                          GLint w) {
1347   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4i");
1348   gl_->Uniform4i(location, x, y, z, w);
1349 }
1350
1351 void GLES2TraceImplementation::Uniform4iv(GLint location,
1352                                           GLsizei count,
1353                                           const GLint* v) {
1354   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4iv");
1355   gl_->Uniform4iv(location, count, v);
1356 }
1357
1358 void GLES2TraceImplementation::Uniform4ui(GLint location,
1359                                           GLuint x,
1360                                           GLuint y,
1361                                           GLuint z,
1362                                           GLuint w) {
1363   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4ui");
1364   gl_->Uniform4ui(location, x, y, z, w);
1365 }
1366
1367 void GLES2TraceImplementation::Uniform4uiv(GLint location,
1368                                            GLsizei count,
1369                                            const GLuint* v) {
1370   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Uniform4uiv");
1371   gl_->Uniform4uiv(location, count, v);
1372 }
1373
1374 void GLES2TraceImplementation::UniformBlockBinding(GLuint program,
1375                                                    GLuint index,
1376                                                    GLuint binding) {
1377   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformBlockBinding");
1378   gl_->UniformBlockBinding(program, index, binding);
1379 }
1380
1381 void GLES2TraceImplementation::UniformMatrix2fv(GLint location,
1382                                                 GLsizei count,
1383                                                 GLboolean transpose,
1384                                                 const GLfloat* value) {
1385   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix2fv");
1386   gl_->UniformMatrix2fv(location, count, transpose, value);
1387 }
1388
1389 void GLES2TraceImplementation::UniformMatrix2x3fv(GLint location,
1390                                                   GLsizei count,
1391                                                   GLboolean transpose,
1392                                                   const GLfloat* value) {
1393   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix2x3fv");
1394   gl_->UniformMatrix2x3fv(location, count, transpose, value);
1395 }
1396
1397 void GLES2TraceImplementation::UniformMatrix2x4fv(GLint location,
1398                                                   GLsizei count,
1399                                                   GLboolean transpose,
1400                                                   const GLfloat* value) {
1401   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix2x4fv");
1402   gl_->UniformMatrix2x4fv(location, count, transpose, value);
1403 }
1404
1405 void GLES2TraceImplementation::UniformMatrix3fv(GLint location,
1406                                                 GLsizei count,
1407                                                 GLboolean transpose,
1408                                                 const GLfloat* value) {
1409   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix3fv");
1410   gl_->UniformMatrix3fv(location, count, transpose, value);
1411 }
1412
1413 void GLES2TraceImplementation::UniformMatrix3x2fv(GLint location,
1414                                                   GLsizei count,
1415                                                   GLboolean transpose,
1416                                                   const GLfloat* value) {
1417   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix3x2fv");
1418   gl_->UniformMatrix3x2fv(location, count, transpose, value);
1419 }
1420
1421 void GLES2TraceImplementation::UniformMatrix3x4fv(GLint location,
1422                                                   GLsizei count,
1423                                                   GLboolean transpose,
1424                                                   const GLfloat* value) {
1425   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix3x4fv");
1426   gl_->UniformMatrix3x4fv(location, count, transpose, value);
1427 }
1428
1429 void GLES2TraceImplementation::UniformMatrix4fv(GLint location,
1430                                                 GLsizei count,
1431                                                 GLboolean transpose,
1432                                                 const GLfloat* value) {
1433   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix4fv");
1434   gl_->UniformMatrix4fv(location, count, transpose, value);
1435 }
1436
1437 void GLES2TraceImplementation::UniformMatrix4x2fv(GLint location,
1438                                                   GLsizei count,
1439                                                   GLboolean transpose,
1440                                                   const GLfloat* value) {
1441   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix4x2fv");
1442   gl_->UniformMatrix4x2fv(location, count, transpose, value);
1443 }
1444
1445 void GLES2TraceImplementation::UniformMatrix4x3fv(GLint location,
1446                                                   GLsizei count,
1447                                                   GLboolean transpose,
1448                                                   const GLfloat* value) {
1449   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UniformMatrix4x3fv");
1450   gl_->UniformMatrix4x3fv(location, count, transpose, value);
1451 }
1452
1453 void GLES2TraceImplementation::UseProgram(GLuint program) {
1454   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UseProgram");
1455   gl_->UseProgram(program);
1456 }
1457
1458 void GLES2TraceImplementation::ValidateProgram(GLuint program) {
1459   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ValidateProgram");
1460   gl_->ValidateProgram(program);
1461 }
1462
1463 void GLES2TraceImplementation::VertexAttrib1f(GLuint indx, GLfloat x) {
1464   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib1f");
1465   gl_->VertexAttrib1f(indx, x);
1466 }
1467
1468 void GLES2TraceImplementation::VertexAttrib1fv(GLuint indx,
1469                                                const GLfloat* values) {
1470   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib1fv");
1471   gl_->VertexAttrib1fv(indx, values);
1472 }
1473
1474 void GLES2TraceImplementation::VertexAttrib2f(GLuint indx,
1475                                               GLfloat x,
1476                                               GLfloat y) {
1477   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib2f");
1478   gl_->VertexAttrib2f(indx, x, y);
1479 }
1480
1481 void GLES2TraceImplementation::VertexAttrib2fv(GLuint indx,
1482                                                const GLfloat* values) {
1483   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib2fv");
1484   gl_->VertexAttrib2fv(indx, values);
1485 }
1486
1487 void GLES2TraceImplementation::VertexAttrib3f(GLuint indx,
1488                                               GLfloat x,
1489                                               GLfloat y,
1490                                               GLfloat z) {
1491   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib3f");
1492   gl_->VertexAttrib3f(indx, x, y, z);
1493 }
1494
1495 void GLES2TraceImplementation::VertexAttrib3fv(GLuint indx,
1496                                                const GLfloat* values) {
1497   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib3fv");
1498   gl_->VertexAttrib3fv(indx, values);
1499 }
1500
1501 void GLES2TraceImplementation::VertexAttrib4f(GLuint indx,
1502                                               GLfloat x,
1503                                               GLfloat y,
1504                                               GLfloat z,
1505                                               GLfloat w) {
1506   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib4f");
1507   gl_->VertexAttrib4f(indx, x, y, z, w);
1508 }
1509
1510 void GLES2TraceImplementation::VertexAttrib4fv(GLuint indx,
1511                                                const GLfloat* values) {
1512   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttrib4fv");
1513   gl_->VertexAttrib4fv(indx, values);
1514 }
1515
1516 void GLES2TraceImplementation::VertexAttribI4i(GLuint indx,
1517                                                GLint x,
1518                                                GLint y,
1519                                                GLint z,
1520                                                GLint w) {
1521   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribI4i");
1522   gl_->VertexAttribI4i(indx, x, y, z, w);
1523 }
1524
1525 void GLES2TraceImplementation::VertexAttribI4iv(GLuint indx,
1526                                                 const GLint* values) {
1527   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribI4iv");
1528   gl_->VertexAttribI4iv(indx, values);
1529 }
1530
1531 void GLES2TraceImplementation::VertexAttribI4ui(GLuint indx,
1532                                                 GLuint x,
1533                                                 GLuint y,
1534                                                 GLuint z,
1535                                                 GLuint w) {
1536   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribI4ui");
1537   gl_->VertexAttribI4ui(indx, x, y, z, w);
1538 }
1539
1540 void GLES2TraceImplementation::VertexAttribI4uiv(GLuint indx,
1541                                                  const GLuint* values) {
1542   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribI4uiv");
1543   gl_->VertexAttribI4uiv(indx, values);
1544 }
1545
1546 void GLES2TraceImplementation::VertexAttribIPointer(GLuint indx,
1547                                                     GLint size,
1548                                                     GLenum type,
1549                                                     GLsizei stride,
1550                                                     const void* ptr) {
1551   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribIPointer");
1552   gl_->VertexAttribIPointer(indx, size, type, stride, ptr);
1553 }
1554
1555 void GLES2TraceImplementation::VertexAttribPointer(GLuint indx,
1556                                                    GLint size,
1557                                                    GLenum type,
1558                                                    GLboolean normalized,
1559                                                    GLsizei stride,
1560                                                    const void* ptr) {
1561   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribPointer");
1562   gl_->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
1563 }
1564
1565 void GLES2TraceImplementation::Viewport(GLint x,
1566                                         GLint y,
1567                                         GLsizei width,
1568                                         GLsizei height) {
1569   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::Viewport");
1570   gl_->Viewport(x, y, width, height);
1571 }
1572
1573 void GLES2TraceImplementation::WaitSync(GLsync sync,
1574                                         GLbitfield flags,
1575                                         GLuint64 timeout) {
1576   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::WaitSync");
1577   gl_->WaitSync(sync, flags, timeout);
1578 }
1579
1580 void GLES2TraceImplementation::BlitFramebufferCHROMIUM(GLint srcX0,
1581                                                        GLint srcY0,
1582                                                        GLint srcX1,
1583                                                        GLint srcY1,
1584                                                        GLint dstX0,
1585                                                        GLint dstY0,
1586                                                        GLint dstX1,
1587                                                        GLint dstY1,
1588                                                        GLbitfield mask,
1589                                                        GLenum filter) {
1590   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlitFramebufferCHROMIUM");
1591   gl_->BlitFramebufferCHROMIUM(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
1592                                dstY1, mask, filter);
1593 }
1594
1595 void GLES2TraceImplementation::RenderbufferStorageMultisampleCHROMIUM(
1596     GLenum target,
1597     GLsizei samples,
1598     GLenum internalformat,
1599     GLsizei width,
1600     GLsizei height) {
1601   TRACE_EVENT_BINARY_EFFICIENT0(
1602       "gpu", "GLES2Trace::RenderbufferStorageMultisampleCHROMIUM");
1603   gl_->RenderbufferStorageMultisampleCHROMIUM(target, samples, internalformat,
1604                                               width, height);
1605 }
1606
1607 void GLES2TraceImplementation::RenderbufferStorageMultisampleEXT(
1608     GLenum target,
1609     GLsizei samples,
1610     GLenum internalformat,
1611     GLsizei width,
1612     GLsizei height) {
1613   TRACE_EVENT_BINARY_EFFICIENT0(
1614       "gpu", "GLES2Trace::RenderbufferStorageMultisampleEXT");
1615   gl_->RenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
1616                                          height);
1617 }
1618
1619 void GLES2TraceImplementation::FramebufferTexture2DMultisampleEXT(
1620     GLenum target,
1621     GLenum attachment,
1622     GLenum textarget,
1623     GLuint texture,
1624     GLint level,
1625     GLsizei samples) {
1626   TRACE_EVENT_BINARY_EFFICIENT0(
1627       "gpu", "GLES2Trace::FramebufferTexture2DMultisampleEXT");
1628   gl_->FramebufferTexture2DMultisampleEXT(target, attachment, textarget,
1629                                           texture, level, samples);
1630 }
1631
1632 void GLES2TraceImplementation::TexStorage2DEXT(GLenum target,
1633                                                GLsizei levels,
1634                                                GLenum internalFormat,
1635                                                GLsizei width,
1636                                                GLsizei height) {
1637   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TexStorage2DEXT");
1638   gl_->TexStorage2DEXT(target, levels, internalFormat, width, height);
1639 }
1640
1641 void GLES2TraceImplementation::GenQueriesEXT(GLsizei n, GLuint* queries) {
1642   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenQueriesEXT");
1643   gl_->GenQueriesEXT(n, queries);
1644 }
1645
1646 void GLES2TraceImplementation::DeleteQueriesEXT(GLsizei n,
1647                                                 const GLuint* queries) {
1648   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteQueriesEXT");
1649   gl_->DeleteQueriesEXT(n, queries);
1650 }
1651
1652 void GLES2TraceImplementation::QueryCounterEXT(GLuint id, GLenum target) {
1653   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::QueryCounterEXT");
1654   gl_->QueryCounterEXT(id, target);
1655 }
1656
1657 GLboolean GLES2TraceImplementation::IsQueryEXT(GLuint id) {
1658   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsQueryEXT");
1659   return gl_->IsQueryEXT(id);
1660 }
1661
1662 void GLES2TraceImplementation::BeginQueryEXT(GLenum target, GLuint id) {
1663   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BeginQueryEXT");
1664   gl_->BeginQueryEXT(target, id);
1665 }
1666
1667 void GLES2TraceImplementation::BeginTransformFeedback(GLenum primitivemode) {
1668   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BeginTransformFeedback");
1669   gl_->BeginTransformFeedback(primitivemode);
1670 }
1671
1672 void GLES2TraceImplementation::EndQueryEXT(GLenum target) {
1673   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EndQueryEXT");
1674   gl_->EndQueryEXT(target);
1675 }
1676
1677 void GLES2TraceImplementation::EndTransformFeedback() {
1678   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EndTransformFeedback");
1679   gl_->EndTransformFeedback();
1680 }
1681
1682 void GLES2TraceImplementation::GetQueryivEXT(GLenum target,
1683                                              GLenum pname,
1684                                              GLint* params) {
1685   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryivEXT");
1686   gl_->GetQueryivEXT(target, pname, params);
1687 }
1688
1689 void GLES2TraceImplementation::GetQueryObjectuivEXT(GLuint id,
1690                                                     GLenum pname,
1691                                                     GLuint* params) {
1692   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjectuivEXT");
1693   gl_->GetQueryObjectuivEXT(id, pname, params);
1694 }
1695
1696 void GLES2TraceImplementation::GetQueryObjectui64vEXT(GLuint id,
1697                                                       GLenum pname,
1698                                                       GLuint64* params) {
1699   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjectui64vEXT");
1700   gl_->GetQueryObjectui64vEXT(id, pname, params);
1701 }
1702
1703 void GLES2TraceImplementation::InsertEventMarkerEXT(GLsizei length,
1704                                                     const GLchar* marker) {
1705   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InsertEventMarkerEXT");
1706   gl_->InsertEventMarkerEXT(length, marker);
1707 }
1708
1709 void GLES2TraceImplementation::PushGroupMarkerEXT(GLsizei length,
1710                                                   const GLchar* marker) {
1711   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PushGroupMarkerEXT");
1712   gl_->PushGroupMarkerEXT(length, marker);
1713 }
1714
1715 void GLES2TraceImplementation::PopGroupMarkerEXT() {
1716   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PopGroupMarkerEXT");
1717   gl_->PopGroupMarkerEXT();
1718 }
1719
1720 void GLES2TraceImplementation::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1721   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenVertexArraysOES");
1722   gl_->GenVertexArraysOES(n, arrays);
1723 }
1724
1725 void GLES2TraceImplementation::DeleteVertexArraysOES(GLsizei n,
1726                                                      const GLuint* arrays) {
1727   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteVertexArraysOES");
1728   gl_->DeleteVertexArraysOES(n, arrays);
1729 }
1730
1731 GLboolean GLES2TraceImplementation::IsVertexArrayOES(GLuint array) {
1732   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsVertexArrayOES");
1733   return gl_->IsVertexArrayOES(array);
1734 }
1735
1736 void GLES2TraceImplementation::BindVertexArrayOES(GLuint array) {
1737   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindVertexArrayOES");
1738   gl_->BindVertexArrayOES(array);
1739 }
1740
1741 void GLES2TraceImplementation::SwapBuffers() {
1742   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SwapBuffers");
1743   gl_->SwapBuffers();
1744 }
1745
1746 GLuint GLES2TraceImplementation::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1747                                                              GLsizei count,
1748                                                              GLenum type,
1749                                                              GLuint offset) {
1750   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1751                                 "GLES2Trace::GetMaxValueInBufferCHROMIUM");
1752   return gl_->GetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
1753 }
1754
1755 GLboolean GLES2TraceImplementation::EnableFeatureCHROMIUM(const char* feature) {
1756   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EnableFeatureCHROMIUM");
1757   return gl_->EnableFeatureCHROMIUM(feature);
1758 }
1759
1760 void* GLES2TraceImplementation::MapBufferCHROMIUM(GLuint target,
1761                                                   GLenum access) {
1762   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferCHROMIUM");
1763   return gl_->MapBufferCHROMIUM(target, access);
1764 }
1765
1766 GLboolean GLES2TraceImplementation::UnmapBufferCHROMIUM(GLuint target) {
1767   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UnmapBufferCHROMIUM");
1768   return gl_->UnmapBufferCHROMIUM(target);
1769 }
1770
1771 void* GLES2TraceImplementation::MapBufferSubDataCHROMIUM(GLuint target,
1772                                                          GLintptr offset,
1773                                                          GLsizeiptr size,
1774                                                          GLenum access) {
1775   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferSubDataCHROMIUM");
1776   return gl_->MapBufferSubDataCHROMIUM(target, offset, size, access);
1777 }
1778
1779 void GLES2TraceImplementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
1780   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1781                                 "GLES2Trace::UnmapBufferSubDataCHROMIUM");
1782   gl_->UnmapBufferSubDataCHROMIUM(mem);
1783 }
1784
1785 void* GLES2TraceImplementation::MapBufferRange(GLenum target,
1786                                                GLintptr offset,
1787                                                GLsizeiptr size,
1788                                                GLbitfield access) {
1789   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferRange");
1790   return gl_->MapBufferRange(target, offset, size, access);
1791 }
1792
1793 GLboolean GLES2TraceImplementation::UnmapBuffer(GLenum target) {
1794   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UnmapBuffer");
1795   return gl_->UnmapBuffer(target);
1796 }
1797
1798 void* GLES2TraceImplementation::MapTexSubImage2DCHROMIUM(GLenum target,
1799                                                          GLint level,
1800                                                          GLint xoffset,
1801                                                          GLint yoffset,
1802                                                          GLsizei width,
1803                                                          GLsizei height,
1804                                                          GLenum format,
1805                                                          GLenum type,
1806                                                          GLenum access) {
1807   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapTexSubImage2DCHROMIUM");
1808   return gl_->MapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1809                                        height, format, type, access);
1810 }
1811
1812 void GLES2TraceImplementation::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1813   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1814                                 "GLES2Trace::UnmapTexSubImage2DCHROMIUM");
1815   gl_->UnmapTexSubImage2DCHROMIUM(mem);
1816 }
1817
1818 void GLES2TraceImplementation::ResizeCHROMIUM(GLuint width,
1819                                               GLuint height,
1820                                               GLfloat scale_factor) {
1821   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ResizeCHROMIUM");
1822   gl_->ResizeCHROMIUM(width, height, scale_factor);
1823 }
1824
1825 const GLchar* GLES2TraceImplementation::GetRequestableExtensionsCHROMIUM() {
1826   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1827                                 "GLES2Trace::GetRequestableExtensionsCHROMIUM");
1828   return gl_->GetRequestableExtensionsCHROMIUM();
1829 }
1830
1831 void GLES2TraceImplementation::RequestExtensionCHROMIUM(const char* extension) {
1832   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::RequestExtensionCHROMIUM");
1833   gl_->RequestExtensionCHROMIUM(extension);
1834 }
1835
1836 void GLES2TraceImplementation::RateLimitOffscreenContextCHROMIUM() {
1837   TRACE_EVENT_BINARY_EFFICIENT0(
1838       "gpu", "GLES2Trace::RateLimitOffscreenContextCHROMIUM");
1839   gl_->RateLimitOffscreenContextCHROMIUM();
1840 }
1841
1842 void GLES2TraceImplementation::GetProgramInfoCHROMIUM(GLuint program,
1843                                                       GLsizei bufsize,
1844                                                       GLsizei* size,
1845                                                       void* info) {
1846   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramInfoCHROMIUM");
1847   gl_->GetProgramInfoCHROMIUM(program, bufsize, size, info);
1848 }
1849
1850 void GLES2TraceImplementation::GetUniformBlocksCHROMIUM(GLuint program,
1851                                                         GLsizei bufsize,
1852                                                         GLsizei* size,
1853                                                         void* info) {
1854   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformBlocksCHROMIUM");
1855   gl_->GetUniformBlocksCHROMIUM(program, bufsize, size, info);
1856 }
1857
1858 void GLES2TraceImplementation::GetTransformFeedbackVaryingsCHROMIUM(
1859     GLuint program,
1860     GLsizei bufsize,
1861     GLsizei* size,
1862     void* info) {
1863   TRACE_EVENT_BINARY_EFFICIENT0(
1864       "gpu", "GLES2Trace::GetTransformFeedbackVaryingsCHROMIUM");
1865   gl_->GetTransformFeedbackVaryingsCHROMIUM(program, bufsize, size, info);
1866 }
1867
1868 void GLES2TraceImplementation::GetUniformsES3CHROMIUM(GLuint program,
1869                                                       GLsizei bufsize,
1870                                                       GLsizei* size,
1871                                                       void* info) {
1872   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformsES3CHROMIUM");
1873   gl_->GetUniformsES3CHROMIUM(program, bufsize, size, info);
1874 }
1875
1876 GLuint GLES2TraceImplementation::CreateStreamTextureCHROMIUM(GLuint texture) {
1877   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1878                                 "GLES2Trace::CreateStreamTextureCHROMIUM");
1879   return gl_->CreateStreamTextureCHROMIUM(texture);
1880 }
1881
1882 GLuint GLES2TraceImplementation::CreateImageCHROMIUM(ClientBuffer buffer,
1883                                                      GLsizei width,
1884                                                      GLsizei height,
1885                                                      GLenum internalformat) {
1886   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateImageCHROMIUM");
1887   return gl_->CreateImageCHROMIUM(buffer, width, height, internalformat);
1888 }
1889
1890 void GLES2TraceImplementation::DestroyImageCHROMIUM(GLuint image_id) {
1891   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DestroyImageCHROMIUM");
1892   gl_->DestroyImageCHROMIUM(image_id);
1893 }
1894
1895 GLuint GLES2TraceImplementation::CreateGpuMemoryBufferImageCHROMIUM(
1896     GLsizei width,
1897     GLsizei height,
1898     GLenum internalformat,
1899     GLenum usage) {
1900   TRACE_EVENT_BINARY_EFFICIENT0(
1901       "gpu", "GLES2Trace::CreateGpuMemoryBufferImageCHROMIUM");
1902   return gl_->CreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
1903                                                  usage);
1904 }
1905
1906 void GLES2TraceImplementation::GetTranslatedShaderSourceANGLE(GLuint shader,
1907                                                               GLsizei bufsize,
1908                                                               GLsizei* length,
1909                                                               char* source) {
1910   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1911                                 "GLES2Trace::GetTranslatedShaderSourceANGLE");
1912   gl_->GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
1913 }
1914
1915 void GLES2TraceImplementation::PostSubBufferCHROMIUM(GLint x,
1916                                                      GLint y,
1917                                                      GLint width,
1918                                                      GLint height) {
1919   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PostSubBufferCHROMIUM");
1920   gl_->PostSubBufferCHROMIUM(x, y, width, height);
1921 }
1922
1923 void GLES2TraceImplementation::TexImageIOSurface2DCHROMIUM(GLenum target,
1924                                                            GLsizei width,
1925                                                            GLsizei height,
1926                                                            GLuint ioSurfaceId,
1927                                                            GLuint plane) {
1928   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1929                                 "GLES2Trace::TexImageIOSurface2DCHROMIUM");
1930   gl_->TexImageIOSurface2DCHROMIUM(target, width, height, ioSurfaceId, plane);
1931 }
1932
1933 void GLES2TraceImplementation::CopyTextureCHROMIUM(
1934     GLenum target,
1935     GLenum source_id,
1936     GLenum dest_id,
1937     GLint internalformat,
1938     GLenum dest_type,
1939     GLboolean unpack_flip_y,
1940     GLboolean unpack_premultiply_alpha,
1941     GLboolean unpack_unmultiply_alpha) {
1942   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTextureCHROMIUM");
1943   gl_->CopyTextureCHROMIUM(target, source_id, dest_id, internalformat,
1944                            dest_type, unpack_flip_y, unpack_premultiply_alpha,
1945                            unpack_unmultiply_alpha);
1946 }
1947
1948 void GLES2TraceImplementation::CopySubTextureCHROMIUM(
1949     GLenum target,
1950     GLenum source_id,
1951     GLenum dest_id,
1952     GLint xoffset,
1953     GLint yoffset,
1954     GLint x,
1955     GLint y,
1956     GLsizei width,
1957     GLsizei height,
1958     GLboolean unpack_flip_y,
1959     GLboolean unpack_premultiply_alpha,
1960     GLboolean unpack_unmultiply_alpha) {
1961   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopySubTextureCHROMIUM");
1962   gl_->CopySubTextureCHROMIUM(
1963       target, source_id, dest_id, xoffset, yoffset, x, y, width, height,
1964       unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
1965 }
1966
1967 void GLES2TraceImplementation::CompressedCopyTextureCHROMIUM(GLenum target,
1968                                                              GLenum source_id,
1969                                                              GLenum dest_id) {
1970   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1971                                 "GLES2Trace::CompressedCopyTextureCHROMIUM");
1972   gl_->CompressedCopyTextureCHROMIUM(target, source_id, dest_id);
1973 }
1974
1975 void GLES2TraceImplementation::DrawArraysInstancedANGLE(GLenum mode,
1976                                                         GLint first,
1977                                                         GLsizei count,
1978                                                         GLsizei primcount) {
1979   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawArraysInstancedANGLE");
1980   gl_->DrawArraysInstancedANGLE(mode, first, count, primcount);
1981 }
1982
1983 void GLES2TraceImplementation::DrawElementsInstancedANGLE(GLenum mode,
1984                                                           GLsizei count,
1985                                                           GLenum type,
1986                                                           const void* indices,
1987                                                           GLsizei primcount) {
1988   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1989                                 "GLES2Trace::DrawElementsInstancedANGLE");
1990   gl_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
1991 }
1992
1993 void GLES2TraceImplementation::VertexAttribDivisorANGLE(GLuint index,
1994                                                         GLuint divisor) {
1995   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribDivisorANGLE");
1996   gl_->VertexAttribDivisorANGLE(index, divisor);
1997 }
1998
1999 void GLES2TraceImplementation::GenMailboxCHROMIUM(GLbyte* mailbox) {
2000   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenMailboxCHROMIUM");
2001   gl_->GenMailboxCHROMIUM(mailbox);
2002 }
2003
2004 void GLES2TraceImplementation::ProduceTextureCHROMIUM(GLenum target,
2005                                                       const GLbyte* mailbox) {
2006   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ProduceTextureCHROMIUM");
2007   gl_->ProduceTextureCHROMIUM(target, mailbox);
2008 }
2009
2010 void GLES2TraceImplementation::ProduceTextureDirectCHROMIUM(
2011     GLuint texture,
2012     GLenum target,
2013     const GLbyte* mailbox) {
2014   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2015                                 "GLES2Trace::ProduceTextureDirectCHROMIUM");
2016   gl_->ProduceTextureDirectCHROMIUM(texture, target, mailbox);
2017 }
2018
2019 void GLES2TraceImplementation::ConsumeTextureCHROMIUM(GLenum target,
2020                                                       const GLbyte* mailbox) {
2021   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ConsumeTextureCHROMIUM");
2022   gl_->ConsumeTextureCHROMIUM(target, mailbox);
2023 }
2024
2025 GLuint GLES2TraceImplementation::CreateAndConsumeTextureCHROMIUM(
2026     GLenum target,
2027     const GLbyte* mailbox) {
2028   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2029                                 "GLES2Trace::CreateAndConsumeTextureCHROMIUM");
2030   return gl_->CreateAndConsumeTextureCHROMIUM(target, mailbox);
2031 }
2032
2033 void GLES2TraceImplementation::BindUniformLocationCHROMIUM(GLuint program,
2034                                                            GLint location,
2035                                                            const char* name) {
2036   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2037                                 "GLES2Trace::BindUniformLocationCHROMIUM");
2038   gl_->BindUniformLocationCHROMIUM(program, location, name);
2039 }
2040
2041 void GLES2TraceImplementation::GenValuebuffersCHROMIUM(GLsizei n,
2042                                                        GLuint* buffers) {
2043   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenValuebuffersCHROMIUM");
2044   gl_->GenValuebuffersCHROMIUM(n, buffers);
2045 }
2046
2047 void GLES2TraceImplementation::DeleteValuebuffersCHROMIUM(
2048     GLsizei n,
2049     const GLuint* valuebuffers) {
2050   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2051                                 "GLES2Trace::DeleteValuebuffersCHROMIUM");
2052   gl_->DeleteValuebuffersCHROMIUM(n, valuebuffers);
2053 }
2054
2055 GLboolean GLES2TraceImplementation::IsValuebufferCHROMIUM(GLuint valuebuffer) {
2056   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsValuebufferCHROMIUM");
2057   return gl_->IsValuebufferCHROMIUM(valuebuffer);
2058 }
2059
2060 void GLES2TraceImplementation::BindValuebufferCHROMIUM(GLenum target,
2061                                                        GLuint valuebuffer) {
2062   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindValuebufferCHROMIUM");
2063   gl_->BindValuebufferCHROMIUM(target, valuebuffer);
2064 }
2065
2066 void GLES2TraceImplementation::SubscribeValueCHROMIUM(GLenum target,
2067                                                       GLenum subscription) {
2068   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SubscribeValueCHROMIUM");
2069   gl_->SubscribeValueCHROMIUM(target, subscription);
2070 }
2071
2072 void GLES2TraceImplementation::PopulateSubscribedValuesCHROMIUM(GLenum target) {
2073   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2074                                 "GLES2Trace::PopulateSubscribedValuesCHROMIUM");
2075   gl_->PopulateSubscribedValuesCHROMIUM(target);
2076 }
2077
2078 void GLES2TraceImplementation::UniformValuebufferCHROMIUM(GLint location,
2079                                                           GLenum target,
2080                                                           GLenum subscription) {
2081   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2082                                 "GLES2Trace::UniformValuebufferCHROMIUM");
2083   gl_->UniformValuebufferCHROMIUM(location, target, subscription);
2084 }
2085
2086 void GLES2TraceImplementation::BindTexImage2DCHROMIUM(GLenum target,
2087                                                       GLint imageId) {
2088   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindTexImage2DCHROMIUM");
2089   gl_->BindTexImage2DCHROMIUM(target, imageId);
2090 }
2091
2092 void GLES2TraceImplementation::ReleaseTexImage2DCHROMIUM(GLenum target,
2093                                                          GLint imageId) {
2094   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReleaseTexImage2DCHROMIUM");
2095   gl_->ReleaseTexImage2DCHROMIUM(target, imageId);
2096 }
2097
2098 void GLES2TraceImplementation::TraceBeginCHROMIUM(const char* category_name,
2099                                                   const char* trace_name) {
2100   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceBeginCHROMIUM");
2101   gl_->TraceBeginCHROMIUM(category_name, trace_name);
2102 }
2103
2104 void GLES2TraceImplementation::TraceEndCHROMIUM() {
2105   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceEndCHROMIUM");
2106   gl_->TraceEndCHROMIUM();
2107 }
2108
2109 void GLES2TraceImplementation::AsyncTexSubImage2DCHROMIUM(GLenum target,
2110                                                           GLint level,
2111                                                           GLint xoffset,
2112                                                           GLint yoffset,
2113                                                           GLsizei width,
2114                                                           GLsizei height,
2115                                                           GLenum format,
2116                                                           GLenum type,
2117                                                           const void* data) {
2118   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2119                                 "GLES2Trace::AsyncTexSubImage2DCHROMIUM");
2120   gl_->AsyncTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
2121                                   height, format, type, data);
2122 }
2123
2124 void GLES2TraceImplementation::AsyncTexImage2DCHROMIUM(GLenum target,
2125                                                        GLint level,
2126                                                        GLenum internalformat,
2127                                                        GLsizei width,
2128                                                        GLsizei height,
2129                                                        GLint border,
2130                                                        GLenum format,
2131                                                        GLenum type,
2132                                                        const void* pixels) {
2133   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::AsyncTexImage2DCHROMIUM");
2134   gl_->AsyncTexImage2DCHROMIUM(target, level, internalformat, width, height,
2135                                border, format, type, pixels);
2136 }
2137
2138 void GLES2TraceImplementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
2139   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2140                                 "GLES2Trace::WaitAsyncTexImage2DCHROMIUM");
2141   gl_->WaitAsyncTexImage2DCHROMIUM(target);
2142 }
2143
2144 void GLES2TraceImplementation::WaitAllAsyncTexImage2DCHROMIUM() {
2145   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2146                                 "GLES2Trace::WaitAllAsyncTexImage2DCHROMIUM");
2147   gl_->WaitAllAsyncTexImage2DCHROMIUM();
2148 }
2149
2150 void GLES2TraceImplementation::DiscardFramebufferEXT(
2151     GLenum target,
2152     GLsizei count,
2153     const GLenum* attachments) {
2154   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DiscardFramebufferEXT");
2155   gl_->DiscardFramebufferEXT(target, count, attachments);
2156 }
2157
2158 void GLES2TraceImplementation::LoseContextCHROMIUM(GLenum current,
2159                                                    GLenum other) {
2160   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LoseContextCHROMIUM");
2161   gl_->LoseContextCHROMIUM(current, other);
2162 }
2163
2164 GLuint GLES2TraceImplementation::InsertSyncPointCHROMIUM() {
2165   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InsertSyncPointCHROMIUM");
2166   return gl_->InsertSyncPointCHROMIUM();
2167 }
2168
2169 void GLES2TraceImplementation::WaitSyncPointCHROMIUM(GLuint sync_point) {
2170   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::WaitSyncPointCHROMIUM");
2171   gl_->WaitSyncPointCHROMIUM(sync_point);
2172 }
2173
2174 void GLES2TraceImplementation::DrawBuffersEXT(GLsizei count,
2175                                               const GLenum* bufs) {
2176   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawBuffersEXT");
2177   gl_->DrawBuffersEXT(count, bufs);
2178 }
2179
2180 void GLES2TraceImplementation::DiscardBackbufferCHROMIUM() {
2181   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DiscardBackbufferCHROMIUM");
2182   gl_->DiscardBackbufferCHROMIUM();
2183 }
2184
2185 void GLES2TraceImplementation::ScheduleOverlayPlaneCHROMIUM(
2186     GLint plane_z_order,
2187     GLenum plane_transform,
2188     GLuint overlay_texture_id,
2189     GLint bounds_x,
2190     GLint bounds_y,
2191     GLint bounds_width,
2192     GLint bounds_height,
2193     GLfloat uv_x,
2194     GLfloat uv_y,
2195     GLfloat uv_width,
2196     GLfloat uv_height) {
2197   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2198                                 "GLES2Trace::ScheduleOverlayPlaneCHROMIUM");
2199   gl_->ScheduleOverlayPlaneCHROMIUM(
2200       plane_z_order, plane_transform, overlay_texture_id, bounds_x, bounds_y,
2201       bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
2202 }
2203
2204 void GLES2TraceImplementation::SwapInterval(GLint interval) {
2205   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SwapInterval");
2206   gl_->SwapInterval(interval);
2207 }
2208
2209 void GLES2TraceImplementation::FlushDriverCachesCHROMIUM() {
2210   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FlushDriverCachesCHROMIUM");
2211   gl_->FlushDriverCachesCHROMIUM();
2212 }
2213
2214 void GLES2TraceImplementation::MatrixLoadfCHROMIUM(GLenum matrixMode,
2215                                                    const GLfloat* m) {
2216   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MatrixLoadfCHROMIUM");
2217   gl_->MatrixLoadfCHROMIUM(matrixMode, m);
2218 }
2219
2220 void GLES2TraceImplementation::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
2221   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2222                                 "GLES2Trace::MatrixLoadIdentityCHROMIUM");
2223   gl_->MatrixLoadIdentityCHROMIUM(matrixMode);
2224 }
2225
2226 GLuint GLES2TraceImplementation::GenPathsCHROMIUM(GLsizei range) {
2227   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenPathsCHROMIUM");
2228   return gl_->GenPathsCHROMIUM(range);
2229 }
2230
2231 void GLES2TraceImplementation::DeletePathsCHROMIUM(GLuint path, GLsizei range) {
2232   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeletePathsCHROMIUM");
2233   gl_->DeletePathsCHROMIUM(path, range);
2234 }
2235
2236 GLboolean GLES2TraceImplementation::IsPathCHROMIUM(GLuint path) {
2237   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsPathCHROMIUM");
2238   return gl_->IsPathCHROMIUM(path);
2239 }
2240
2241 void GLES2TraceImplementation::PathCommandsCHROMIUM(GLuint path,
2242                                                     GLsizei numCommands,
2243                                                     const GLubyte* commands,
2244                                                     GLsizei numCoords,
2245                                                     GLenum coordType,
2246                                                     const GLvoid* coords) {
2247   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathCommandsCHROMIUM");
2248   gl_->PathCommandsCHROMIUM(path, numCommands, commands, numCoords, coordType,
2249                             coords);
2250 }
2251
2252 void GLES2TraceImplementation::PathParameterfCHROMIUM(GLuint path,
2253                                                       GLenum pname,
2254                                                       GLfloat value) {
2255   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathParameterfCHROMIUM");
2256   gl_->PathParameterfCHROMIUM(path, pname, value);
2257 }
2258
2259 void GLES2TraceImplementation::PathParameteriCHROMIUM(GLuint path,
2260                                                       GLenum pname,
2261                                                       GLint value) {
2262   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathParameteriCHROMIUM");
2263   gl_->PathParameteriCHROMIUM(path, pname, value);
2264 }
2265
2266 void GLES2TraceImplementation::PathStencilFuncCHROMIUM(GLenum func,
2267                                                        GLint ref,
2268                                                        GLuint mask) {
2269   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathStencilFuncCHROMIUM");
2270   gl_->PathStencilFuncCHROMIUM(func, ref, mask);
2271 }
2272
2273 void GLES2TraceImplementation::StencilFillPathCHROMIUM(GLuint path,
2274                                                        GLenum fillMode,
2275                                                        GLuint mask) {
2276   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilFillPathCHROMIUM");
2277   gl_->StencilFillPathCHROMIUM(path, fillMode, mask);
2278 }
2279
2280 void GLES2TraceImplementation::StencilStrokePathCHROMIUM(GLuint path,
2281                                                          GLint reference,
2282                                                          GLuint mask) {
2283   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilStrokePathCHROMIUM");
2284   gl_->StencilStrokePathCHROMIUM(path, reference, mask);
2285 }
2286
2287 void GLES2TraceImplementation::CoverFillPathCHROMIUM(GLuint path,
2288                                                      GLenum coverMode) {
2289   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CoverFillPathCHROMIUM");
2290   gl_->CoverFillPathCHROMIUM(path, coverMode);
2291 }
2292
2293 void GLES2TraceImplementation::CoverStrokePathCHROMIUM(GLuint path,
2294                                                        GLenum coverMode) {
2295   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CoverStrokePathCHROMIUM");
2296   gl_->CoverStrokePathCHROMIUM(path, coverMode);
2297 }
2298
2299 void GLES2TraceImplementation::StencilThenCoverFillPathCHROMIUM(
2300     GLuint path,
2301     GLenum fillMode,
2302     GLuint mask,
2303     GLenum coverMode) {
2304   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2305                                 "GLES2Trace::StencilThenCoverFillPathCHROMIUM");
2306   gl_->StencilThenCoverFillPathCHROMIUM(path, fillMode, mask, coverMode);
2307 }
2308
2309 void GLES2TraceImplementation::StencilThenCoverStrokePathCHROMIUM(
2310     GLuint path,
2311     GLint reference,
2312     GLuint mask,
2313     GLenum coverMode) {
2314   TRACE_EVENT_BINARY_EFFICIENT0(
2315       "gpu", "GLES2Trace::StencilThenCoverStrokePathCHROMIUM");
2316   gl_->StencilThenCoverStrokePathCHROMIUM(path, reference, mask, coverMode);
2317 }
2318
2319 GLenum GLES2TraceImplementation::GetGraphicsResetStatusKHR() {
2320   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetGraphicsResetStatusKHR");
2321   return gl_->GetGraphicsResetStatusKHR();
2322 }
2323
2324 void GLES2TraceImplementation::BlendBarrierKHR() {
2325   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendBarrierKHR");
2326   gl_->BlendBarrierKHR();
2327 }
2328
2329 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_