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