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