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