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::GetQueryObjectivEXT(GLuint id,
1690                                                    GLenum pname,
1691                                                    GLint* params) {
1692   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjectivEXT");
1693   gl_->GetQueryObjectivEXT(id, pname, params);
1694 }
1695
1696 void GLES2TraceImplementation::GetQueryObjectuivEXT(GLuint id,
1697                                                     GLenum pname,
1698                                                     GLuint* params) {
1699   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjectuivEXT");
1700   gl_->GetQueryObjectuivEXT(id, pname, params);
1701 }
1702
1703 void GLES2TraceImplementation::GetQueryObjecti64vEXT(GLuint id,
1704                                                      GLenum pname,
1705                                                      GLint64* params) {
1706   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjecti64vEXT");
1707   gl_->GetQueryObjecti64vEXT(id, pname, params);
1708 }
1709
1710 void GLES2TraceImplementation::GetQueryObjectui64vEXT(GLuint id,
1711                                                       GLenum pname,
1712                                                       GLuint64* params) {
1713   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetQueryObjectui64vEXT");
1714   gl_->GetQueryObjectui64vEXT(id, pname, params);
1715 }
1716
1717 void GLES2TraceImplementation::SetDisjointValueSyncCHROMIUM() {
1718   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1719                                 "GLES2Trace::SetDisjointValueSyncCHROMIUM");
1720   gl_->SetDisjointValueSyncCHROMIUM();
1721 }
1722
1723 void GLES2TraceImplementation::InsertEventMarkerEXT(GLsizei length,
1724                                                     const GLchar* marker) {
1725   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InsertEventMarkerEXT");
1726   gl_->InsertEventMarkerEXT(length, marker);
1727 }
1728
1729 void GLES2TraceImplementation::PushGroupMarkerEXT(GLsizei length,
1730                                                   const GLchar* marker) {
1731   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PushGroupMarkerEXT");
1732   gl_->PushGroupMarkerEXT(length, marker);
1733 }
1734
1735 void GLES2TraceImplementation::PopGroupMarkerEXT() {
1736   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PopGroupMarkerEXT");
1737   gl_->PopGroupMarkerEXT();
1738 }
1739
1740 void GLES2TraceImplementation::GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1741   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenVertexArraysOES");
1742   gl_->GenVertexArraysOES(n, arrays);
1743 }
1744
1745 void GLES2TraceImplementation::DeleteVertexArraysOES(GLsizei n,
1746                                                      const GLuint* arrays) {
1747   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeleteVertexArraysOES");
1748   gl_->DeleteVertexArraysOES(n, arrays);
1749 }
1750
1751 GLboolean GLES2TraceImplementation::IsVertexArrayOES(GLuint array) {
1752   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsVertexArrayOES");
1753   return gl_->IsVertexArrayOES(array);
1754 }
1755
1756 void GLES2TraceImplementation::BindVertexArrayOES(GLuint array) {
1757   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindVertexArrayOES");
1758   gl_->BindVertexArrayOES(array);
1759 }
1760
1761 void GLES2TraceImplementation::SwapBuffers() {
1762   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SwapBuffers");
1763   gl_->SwapBuffers();
1764 }
1765
1766 GLuint GLES2TraceImplementation::GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1767                                                              GLsizei count,
1768                                                              GLenum type,
1769                                                              GLuint offset) {
1770   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1771                                 "GLES2Trace::GetMaxValueInBufferCHROMIUM");
1772   return gl_->GetMaxValueInBufferCHROMIUM(buffer_id, count, type, offset);
1773 }
1774
1775 GLboolean GLES2TraceImplementation::EnableFeatureCHROMIUM(const char* feature) {
1776   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::EnableFeatureCHROMIUM");
1777   return gl_->EnableFeatureCHROMIUM(feature);
1778 }
1779
1780 void* GLES2TraceImplementation::MapBufferCHROMIUM(GLuint target,
1781                                                   GLenum access) {
1782   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferCHROMIUM");
1783   return gl_->MapBufferCHROMIUM(target, access);
1784 }
1785
1786 GLboolean GLES2TraceImplementation::UnmapBufferCHROMIUM(GLuint target) {
1787   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UnmapBufferCHROMIUM");
1788   return gl_->UnmapBufferCHROMIUM(target);
1789 }
1790
1791 void* GLES2TraceImplementation::MapBufferSubDataCHROMIUM(GLuint target,
1792                                                          GLintptr offset,
1793                                                          GLsizeiptr size,
1794                                                          GLenum access) {
1795   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferSubDataCHROMIUM");
1796   return gl_->MapBufferSubDataCHROMIUM(target, offset, size, access);
1797 }
1798
1799 void GLES2TraceImplementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
1800   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1801                                 "GLES2Trace::UnmapBufferSubDataCHROMIUM");
1802   gl_->UnmapBufferSubDataCHROMIUM(mem);
1803 }
1804
1805 void* GLES2TraceImplementation::MapBufferRange(GLenum target,
1806                                                GLintptr offset,
1807                                                GLsizeiptr size,
1808                                                GLbitfield access) {
1809   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapBufferRange");
1810   return gl_->MapBufferRange(target, offset, size, access);
1811 }
1812
1813 GLboolean GLES2TraceImplementation::UnmapBuffer(GLenum target) {
1814   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::UnmapBuffer");
1815   return gl_->UnmapBuffer(target);
1816 }
1817
1818 void* GLES2TraceImplementation::MapTexSubImage2DCHROMIUM(GLenum target,
1819                                                          GLint level,
1820                                                          GLint xoffset,
1821                                                          GLint yoffset,
1822                                                          GLsizei width,
1823                                                          GLsizei height,
1824                                                          GLenum format,
1825                                                          GLenum type,
1826                                                          GLenum access) {
1827   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MapTexSubImage2DCHROMIUM");
1828   return gl_->MapTexSubImage2DCHROMIUM(target, level, xoffset, yoffset, width,
1829                                        height, format, type, access);
1830 }
1831
1832 void GLES2TraceImplementation::UnmapTexSubImage2DCHROMIUM(const void* mem) {
1833   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1834                                 "GLES2Trace::UnmapTexSubImage2DCHROMIUM");
1835   gl_->UnmapTexSubImage2DCHROMIUM(mem);
1836 }
1837
1838 void GLES2TraceImplementation::ResizeCHROMIUM(GLuint width,
1839                                               GLuint height,
1840                                               GLfloat scale_factor) {
1841   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ResizeCHROMIUM");
1842   gl_->ResizeCHROMIUM(width, height, scale_factor);
1843 }
1844
1845 const GLchar* GLES2TraceImplementation::GetRequestableExtensionsCHROMIUM() {
1846   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1847                                 "GLES2Trace::GetRequestableExtensionsCHROMIUM");
1848   return gl_->GetRequestableExtensionsCHROMIUM();
1849 }
1850
1851 void GLES2TraceImplementation::RequestExtensionCHROMIUM(const char* extension) {
1852   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::RequestExtensionCHROMIUM");
1853   gl_->RequestExtensionCHROMIUM(extension);
1854 }
1855
1856 void GLES2TraceImplementation::RateLimitOffscreenContextCHROMIUM() {
1857   TRACE_EVENT_BINARY_EFFICIENT0(
1858       "gpu", "GLES2Trace::RateLimitOffscreenContextCHROMIUM");
1859   gl_->RateLimitOffscreenContextCHROMIUM();
1860 }
1861
1862 void GLES2TraceImplementation::GetProgramInfoCHROMIUM(GLuint program,
1863                                                       GLsizei bufsize,
1864                                                       GLsizei* size,
1865                                                       void* info) {
1866   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetProgramInfoCHROMIUM");
1867   gl_->GetProgramInfoCHROMIUM(program, bufsize, size, info);
1868 }
1869
1870 void GLES2TraceImplementation::GetUniformBlocksCHROMIUM(GLuint program,
1871                                                         GLsizei bufsize,
1872                                                         GLsizei* size,
1873                                                         void* info) {
1874   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformBlocksCHROMIUM");
1875   gl_->GetUniformBlocksCHROMIUM(program, bufsize, size, info);
1876 }
1877
1878 void GLES2TraceImplementation::GetTransformFeedbackVaryingsCHROMIUM(
1879     GLuint program,
1880     GLsizei bufsize,
1881     GLsizei* size,
1882     void* info) {
1883   TRACE_EVENT_BINARY_EFFICIENT0(
1884       "gpu", "GLES2Trace::GetTransformFeedbackVaryingsCHROMIUM");
1885   gl_->GetTransformFeedbackVaryingsCHROMIUM(program, bufsize, size, info);
1886 }
1887
1888 void GLES2TraceImplementation::GetUniformsES3CHROMIUM(GLuint program,
1889                                                       GLsizei bufsize,
1890                                                       GLsizei* size,
1891                                                       void* info) {
1892   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetUniformsES3CHROMIUM");
1893   gl_->GetUniformsES3CHROMIUM(program, bufsize, size, info);
1894 }
1895
1896 GLuint GLES2TraceImplementation::CreateStreamTextureCHROMIUM(GLuint texture) {
1897   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1898                                 "GLES2Trace::CreateStreamTextureCHROMIUM");
1899   return gl_->CreateStreamTextureCHROMIUM(texture);
1900 }
1901
1902 GLuint GLES2TraceImplementation::CreateImageCHROMIUM(ClientBuffer buffer,
1903                                                      GLsizei width,
1904                                                      GLsizei height,
1905                                                      GLenum internalformat) {
1906   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CreateImageCHROMIUM");
1907   return gl_->CreateImageCHROMIUM(buffer, width, height, internalformat);
1908 }
1909
1910 void GLES2TraceImplementation::DestroyImageCHROMIUM(GLuint image_id) {
1911   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DestroyImageCHROMIUM");
1912   gl_->DestroyImageCHROMIUM(image_id);
1913 }
1914
1915 GLuint GLES2TraceImplementation::CreateGpuMemoryBufferImageCHROMIUM(
1916     GLsizei width,
1917     GLsizei height,
1918     GLenum internalformat,
1919     GLenum usage) {
1920   TRACE_EVENT_BINARY_EFFICIENT0(
1921       "gpu", "GLES2Trace::CreateGpuMemoryBufferImageCHROMIUM");
1922   return gl_->CreateGpuMemoryBufferImageCHROMIUM(width, height, internalformat,
1923                                                  usage);
1924 }
1925
1926 void GLES2TraceImplementation::GetTranslatedShaderSourceANGLE(GLuint shader,
1927                                                               GLsizei bufsize,
1928                                                               GLsizei* length,
1929                                                               char* source) {
1930   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1931                                 "GLES2Trace::GetTranslatedShaderSourceANGLE");
1932   gl_->GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
1933 }
1934
1935 void GLES2TraceImplementation::PostSubBufferCHROMIUM(GLint x,
1936                                                      GLint y,
1937                                                      GLint width,
1938                                                      GLint height) {
1939   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PostSubBufferCHROMIUM");
1940   gl_->PostSubBufferCHROMIUM(x, y, width, height);
1941 }
1942
1943 void GLES2TraceImplementation::TexImageIOSurface2DCHROMIUM(GLenum target,
1944                                                            GLsizei width,
1945                                                            GLsizei height,
1946                                                            GLuint ioSurfaceId,
1947                                                            GLuint plane) {
1948   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1949                                 "GLES2Trace::TexImageIOSurface2DCHROMIUM");
1950   gl_->TexImageIOSurface2DCHROMIUM(target, width, height, ioSurfaceId, plane);
1951 }
1952
1953 void GLES2TraceImplementation::CopyTextureCHROMIUM(
1954     GLenum target,
1955     GLenum source_id,
1956     GLenum dest_id,
1957     GLint internalformat,
1958     GLenum dest_type,
1959     GLboolean unpack_flip_y,
1960     GLboolean unpack_premultiply_alpha,
1961     GLboolean unpack_unmultiply_alpha) {
1962   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopyTextureCHROMIUM");
1963   gl_->CopyTextureCHROMIUM(target, source_id, dest_id, internalformat,
1964                            dest_type, unpack_flip_y, unpack_premultiply_alpha,
1965                            unpack_unmultiply_alpha);
1966 }
1967
1968 void GLES2TraceImplementation::CopySubTextureCHROMIUM(
1969     GLenum target,
1970     GLenum source_id,
1971     GLenum dest_id,
1972     GLint xoffset,
1973     GLint yoffset,
1974     GLint x,
1975     GLint y,
1976     GLsizei width,
1977     GLsizei height,
1978     GLboolean unpack_flip_y,
1979     GLboolean unpack_premultiply_alpha,
1980     GLboolean unpack_unmultiply_alpha) {
1981   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CopySubTextureCHROMIUM");
1982   gl_->CopySubTextureCHROMIUM(
1983       target, source_id, dest_id, xoffset, yoffset, x, y, width, height,
1984       unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
1985 }
1986
1987 void GLES2TraceImplementation::CompressedCopyTextureCHROMIUM(GLenum target,
1988                                                              GLenum source_id,
1989                                                              GLenum dest_id) {
1990   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
1991                                 "GLES2Trace::CompressedCopyTextureCHROMIUM");
1992   gl_->CompressedCopyTextureCHROMIUM(target, source_id, dest_id);
1993 }
1994
1995 void GLES2TraceImplementation::CompressedCopySubTextureCHROMIUM(
1996     GLenum target,
1997     GLenum source_id,
1998     GLenum dest_id,
1999     GLint xoffset,
2000     GLint yoffset,
2001     GLint x,
2002     GLint y,
2003     GLsizei width,
2004     GLsizei height) {
2005   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2006                                 "GLES2Trace::CompressedCopySubTextureCHROMIUM");
2007   gl_->CompressedCopySubTextureCHROMIUM(target, source_id, dest_id, xoffset,
2008                                         yoffset, x, y, width, height);
2009 }
2010
2011 void GLES2TraceImplementation::DrawArraysInstancedANGLE(GLenum mode,
2012                                                         GLint first,
2013                                                         GLsizei count,
2014                                                         GLsizei primcount) {
2015   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawArraysInstancedANGLE");
2016   gl_->DrawArraysInstancedANGLE(mode, first, count, primcount);
2017 }
2018
2019 void GLES2TraceImplementation::DrawElementsInstancedANGLE(GLenum mode,
2020                                                           GLsizei count,
2021                                                           GLenum type,
2022                                                           const void* indices,
2023                                                           GLsizei primcount) {
2024   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2025                                 "GLES2Trace::DrawElementsInstancedANGLE");
2026   gl_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
2027 }
2028
2029 void GLES2TraceImplementation::VertexAttribDivisorANGLE(GLuint index,
2030                                                         GLuint divisor) {
2031   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::VertexAttribDivisorANGLE");
2032   gl_->VertexAttribDivisorANGLE(index, divisor);
2033 }
2034
2035 void GLES2TraceImplementation::GenMailboxCHROMIUM(GLbyte* mailbox) {
2036   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenMailboxCHROMIUM");
2037   gl_->GenMailboxCHROMIUM(mailbox);
2038 }
2039
2040 void GLES2TraceImplementation::ProduceTextureCHROMIUM(GLenum target,
2041                                                       const GLbyte* mailbox) {
2042   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ProduceTextureCHROMIUM");
2043   gl_->ProduceTextureCHROMIUM(target, mailbox);
2044 }
2045
2046 void GLES2TraceImplementation::ProduceTextureDirectCHROMIUM(
2047     GLuint texture,
2048     GLenum target,
2049     const GLbyte* mailbox) {
2050   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2051                                 "GLES2Trace::ProduceTextureDirectCHROMIUM");
2052   gl_->ProduceTextureDirectCHROMIUM(texture, target, mailbox);
2053 }
2054
2055 void GLES2TraceImplementation::ConsumeTextureCHROMIUM(GLenum target,
2056                                                       const GLbyte* mailbox) {
2057   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ConsumeTextureCHROMIUM");
2058   gl_->ConsumeTextureCHROMIUM(target, mailbox);
2059 }
2060
2061 GLuint GLES2TraceImplementation::CreateAndConsumeTextureCHROMIUM(
2062     GLenum target,
2063     const GLbyte* mailbox) {
2064   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2065                                 "GLES2Trace::CreateAndConsumeTextureCHROMIUM");
2066   return gl_->CreateAndConsumeTextureCHROMIUM(target, mailbox);
2067 }
2068
2069 void GLES2TraceImplementation::BindUniformLocationCHROMIUM(GLuint program,
2070                                                            GLint location,
2071                                                            const char* name) {
2072   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2073                                 "GLES2Trace::BindUniformLocationCHROMIUM");
2074   gl_->BindUniformLocationCHROMIUM(program, location, name);
2075 }
2076
2077 void GLES2TraceImplementation::GenValuebuffersCHROMIUM(GLsizei n,
2078                                                        GLuint* buffers) {
2079   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenValuebuffersCHROMIUM");
2080   gl_->GenValuebuffersCHROMIUM(n, buffers);
2081 }
2082
2083 void GLES2TraceImplementation::DeleteValuebuffersCHROMIUM(
2084     GLsizei n,
2085     const GLuint* valuebuffers) {
2086   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2087                                 "GLES2Trace::DeleteValuebuffersCHROMIUM");
2088   gl_->DeleteValuebuffersCHROMIUM(n, valuebuffers);
2089 }
2090
2091 GLboolean GLES2TraceImplementation::IsValuebufferCHROMIUM(GLuint valuebuffer) {
2092   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsValuebufferCHROMIUM");
2093   return gl_->IsValuebufferCHROMIUM(valuebuffer);
2094 }
2095
2096 void GLES2TraceImplementation::BindValuebufferCHROMIUM(GLenum target,
2097                                                        GLuint valuebuffer) {
2098   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindValuebufferCHROMIUM");
2099   gl_->BindValuebufferCHROMIUM(target, valuebuffer);
2100 }
2101
2102 void GLES2TraceImplementation::SubscribeValueCHROMIUM(GLenum target,
2103                                                       GLenum subscription) {
2104   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SubscribeValueCHROMIUM");
2105   gl_->SubscribeValueCHROMIUM(target, subscription);
2106 }
2107
2108 void GLES2TraceImplementation::PopulateSubscribedValuesCHROMIUM(GLenum target) {
2109   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2110                                 "GLES2Trace::PopulateSubscribedValuesCHROMIUM");
2111   gl_->PopulateSubscribedValuesCHROMIUM(target);
2112 }
2113
2114 void GLES2TraceImplementation::UniformValuebufferCHROMIUM(GLint location,
2115                                                           GLenum target,
2116                                                           GLenum subscription) {
2117   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2118                                 "GLES2Trace::UniformValuebufferCHROMIUM");
2119   gl_->UniformValuebufferCHROMIUM(location, target, subscription);
2120 }
2121
2122 void GLES2TraceImplementation::BindTexImage2DCHROMIUM(GLenum target,
2123                                                       GLint imageId) {
2124   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BindTexImage2DCHROMIUM");
2125   gl_->BindTexImage2DCHROMIUM(target, imageId);
2126 }
2127
2128 void GLES2TraceImplementation::ReleaseTexImage2DCHROMIUM(GLenum target,
2129                                                          GLint imageId) {
2130   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::ReleaseTexImage2DCHROMIUM");
2131   gl_->ReleaseTexImage2DCHROMIUM(target, imageId);
2132 }
2133
2134 void GLES2TraceImplementation::TraceBeginCHROMIUM(const char* category_name,
2135                                                   const char* trace_name) {
2136   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceBeginCHROMIUM");
2137   gl_->TraceBeginCHROMIUM(category_name, trace_name);
2138 }
2139
2140 void GLES2TraceImplementation::TraceEndCHROMIUM() {
2141   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::TraceEndCHROMIUM");
2142   gl_->TraceEndCHROMIUM();
2143 }
2144
2145 void GLES2TraceImplementation::DiscardFramebufferEXT(
2146     GLenum target,
2147     GLsizei count,
2148     const GLenum* attachments) {
2149   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DiscardFramebufferEXT");
2150   gl_->DiscardFramebufferEXT(target, count, attachments);
2151 }
2152
2153 void GLES2TraceImplementation::LoseContextCHROMIUM(GLenum current,
2154                                                    GLenum other) {
2155   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::LoseContextCHROMIUM");
2156   gl_->LoseContextCHROMIUM(current, other);
2157 }
2158
2159 GLuint GLES2TraceImplementation::InsertSyncPointCHROMIUM() {
2160   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::InsertSyncPointCHROMIUM");
2161   return gl_->InsertSyncPointCHROMIUM();
2162 }
2163
2164 void GLES2TraceImplementation::WaitSyncPointCHROMIUM(GLuint sync_point) {
2165   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::WaitSyncPointCHROMIUM");
2166   gl_->WaitSyncPointCHROMIUM(sync_point);
2167 }
2168
2169 void GLES2TraceImplementation::DrawBuffersEXT(GLsizei count,
2170                                               const GLenum* bufs) {
2171   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DrawBuffersEXT");
2172   gl_->DrawBuffersEXT(count, bufs);
2173 }
2174
2175 void GLES2TraceImplementation::DiscardBackbufferCHROMIUM() {
2176   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DiscardBackbufferCHROMIUM");
2177   gl_->DiscardBackbufferCHROMIUM();
2178 }
2179
2180 void GLES2TraceImplementation::ScheduleOverlayPlaneCHROMIUM(
2181     GLint plane_z_order,
2182     GLenum plane_transform,
2183     GLuint overlay_texture_id,
2184     GLint bounds_x,
2185     GLint bounds_y,
2186     GLint bounds_width,
2187     GLint bounds_height,
2188     GLfloat uv_x,
2189     GLfloat uv_y,
2190     GLfloat uv_width,
2191     GLfloat uv_height) {
2192   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2193                                 "GLES2Trace::ScheduleOverlayPlaneCHROMIUM");
2194   gl_->ScheduleOverlayPlaneCHROMIUM(
2195       plane_z_order, plane_transform, overlay_texture_id, bounds_x, bounds_y,
2196       bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
2197 }
2198
2199 void GLES2TraceImplementation::SwapInterval(GLint interval) {
2200   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::SwapInterval");
2201   gl_->SwapInterval(interval);
2202 }
2203
2204 void GLES2TraceImplementation::FlushDriverCachesCHROMIUM() {
2205   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::FlushDriverCachesCHROMIUM");
2206   gl_->FlushDriverCachesCHROMIUM();
2207 }
2208
2209 void GLES2TraceImplementation::MatrixLoadfCHROMIUM(GLenum matrixMode,
2210                                                    const GLfloat* m) {
2211   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::MatrixLoadfCHROMIUM");
2212   gl_->MatrixLoadfCHROMIUM(matrixMode, m);
2213 }
2214
2215 void GLES2TraceImplementation::MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
2216   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2217                                 "GLES2Trace::MatrixLoadIdentityCHROMIUM");
2218   gl_->MatrixLoadIdentityCHROMIUM(matrixMode);
2219 }
2220
2221 GLuint GLES2TraceImplementation::GenPathsCHROMIUM(GLsizei range) {
2222   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GenPathsCHROMIUM");
2223   return gl_->GenPathsCHROMIUM(range);
2224 }
2225
2226 void GLES2TraceImplementation::DeletePathsCHROMIUM(GLuint path, GLsizei range) {
2227   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::DeletePathsCHROMIUM");
2228   gl_->DeletePathsCHROMIUM(path, range);
2229 }
2230
2231 GLboolean GLES2TraceImplementation::IsPathCHROMIUM(GLuint path) {
2232   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::IsPathCHROMIUM");
2233   return gl_->IsPathCHROMIUM(path);
2234 }
2235
2236 void GLES2TraceImplementation::PathCommandsCHROMIUM(GLuint path,
2237                                                     GLsizei numCommands,
2238                                                     const GLubyte* commands,
2239                                                     GLsizei numCoords,
2240                                                     GLenum coordType,
2241                                                     const GLvoid* coords) {
2242   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathCommandsCHROMIUM");
2243   gl_->PathCommandsCHROMIUM(path, numCommands, commands, numCoords, coordType,
2244                             coords);
2245 }
2246
2247 void GLES2TraceImplementation::PathParameterfCHROMIUM(GLuint path,
2248                                                       GLenum pname,
2249                                                       GLfloat value) {
2250   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathParameterfCHROMIUM");
2251   gl_->PathParameterfCHROMIUM(path, pname, value);
2252 }
2253
2254 void GLES2TraceImplementation::PathParameteriCHROMIUM(GLuint path,
2255                                                       GLenum pname,
2256                                                       GLint value) {
2257   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathParameteriCHROMIUM");
2258   gl_->PathParameteriCHROMIUM(path, pname, value);
2259 }
2260
2261 void GLES2TraceImplementation::PathStencilFuncCHROMIUM(GLenum func,
2262                                                        GLint ref,
2263                                                        GLuint mask) {
2264   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::PathStencilFuncCHROMIUM");
2265   gl_->PathStencilFuncCHROMIUM(func, ref, mask);
2266 }
2267
2268 void GLES2TraceImplementation::StencilFillPathCHROMIUM(GLuint path,
2269                                                        GLenum fillMode,
2270                                                        GLuint mask) {
2271   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilFillPathCHROMIUM");
2272   gl_->StencilFillPathCHROMIUM(path, fillMode, mask);
2273 }
2274
2275 void GLES2TraceImplementation::StencilStrokePathCHROMIUM(GLuint path,
2276                                                          GLint reference,
2277                                                          GLuint mask) {
2278   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::StencilStrokePathCHROMIUM");
2279   gl_->StencilStrokePathCHROMIUM(path, reference, mask);
2280 }
2281
2282 void GLES2TraceImplementation::CoverFillPathCHROMIUM(GLuint path,
2283                                                      GLenum coverMode) {
2284   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CoverFillPathCHROMIUM");
2285   gl_->CoverFillPathCHROMIUM(path, coverMode);
2286 }
2287
2288 void GLES2TraceImplementation::CoverStrokePathCHROMIUM(GLuint path,
2289                                                        GLenum coverMode) {
2290   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::CoverStrokePathCHROMIUM");
2291   gl_->CoverStrokePathCHROMIUM(path, coverMode);
2292 }
2293
2294 void GLES2TraceImplementation::StencilThenCoverFillPathCHROMIUM(
2295     GLuint path,
2296     GLenum fillMode,
2297     GLuint mask,
2298     GLenum coverMode) {
2299   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
2300                                 "GLES2Trace::StencilThenCoverFillPathCHROMIUM");
2301   gl_->StencilThenCoverFillPathCHROMIUM(path, fillMode, mask, coverMode);
2302 }
2303
2304 void GLES2TraceImplementation::StencilThenCoverStrokePathCHROMIUM(
2305     GLuint path,
2306     GLint reference,
2307     GLuint mask,
2308     GLenum coverMode) {
2309   TRACE_EVENT_BINARY_EFFICIENT0(
2310       "gpu", "GLES2Trace::StencilThenCoverStrokePathCHROMIUM");
2311   gl_->StencilThenCoverStrokePathCHROMIUM(path, reference, mask, coverMode);
2312 }
2313
2314 GLenum GLES2TraceImplementation::GetGraphicsResetStatusKHR() {
2315   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::GetGraphicsResetStatusKHR");
2316   return gl_->GetGraphicsResetStatusKHR();
2317 }
2318
2319 void GLES2TraceImplementation::BlendBarrierKHR() {
2320   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "GLES2Trace::BlendBarrierKHR");
2321   gl_->BlendBarrierKHR();
2322 }
2323
2324 void GLES2TraceImplementation::ApplyScreenSpaceAntialiasingCHROMIUM() {
2325   TRACE_EVENT_BINARY_EFFICIENT0(
2326       "gpu", "GLES2Trace::ApplyScreenSpaceAntialiasingCHROMIUM");
2327   gl_->ApplyScreenSpaceAntialiasingCHROMIUM();
2328 }
2329
2330 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_TRACE_IMPLEMENTATION_IMPL_AUTOGEN_H_