gpu/blink/webgraphicscontext3d_impl.cc

   1 // Copyright (c) 2012 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 #include "gpu/blink/webgraphicscontext3d_impl.h"
   6
   7 #include "base/atomicops.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/logging.h"
  10 #include "gpu/GLES2/gl2extchromium.h"
  11 #include "gpu/command_buffer/client/gles2_implementation.h"
  12 #include "gpu/command_buffer/client/gles2_lib.h"
  13 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  14 #include "gpu/skia_bindings/gl_bindings_skia_cmd_buffer.h"
  15
  16 #include "third_party/khronos/GLES2/gl2.h"
  17 #ifndef GL_GLEXT_PROTOTYPES
  18 #define GL_GLEXT_PROTOTYPES 1
  19 #endif
  20 #include "third_party/khronos/GLES2/gl2ext.h"
  21
  22 using blink::WGC3Dbitfield;
  23 using blink::WGC3Dboolean;
  24 using blink::WGC3Dbyte;
  25 using blink::WGC3Dchar;
  26 using blink::WGC3Dclampf;
  27 using blink::WGC3Denum;
  28 using blink::WGC3Dfloat;
  29 using blink::WGC3Dint;
  30 using blink::WGC3Dintptr;
  31 using blink::WGC3Dsizei;
  32 using blink::WGC3Dsizeiptr;
  33 using blink::WGC3Duint64;
  34 using blink::WGC3Duint;
  35 using blink::WebGLId;
  36 using blink::WGC3Dsync;
  37
  38 namespace gpu_blink {
  39
  40 namespace {
  41
  42 uint32_t GenFlushID() {
  43   static base::subtle::Atomic32 flush_id = 0;
  44
  45   base::subtle::Atomic32 my_id = base::subtle::Barrier_AtomicIncrement(
  46       &flush_id, 1);
  47   return static_cast<uint32_t>(my_id);
  48 }
  49
  50 } // namespace anonymous
  51
  52 class WebGraphicsContext3DErrorMessageCallback
  53     : public ::gpu::gles2::GLES2ImplementationErrorMessageCallback {
  54  public:
  55   WebGraphicsContext3DErrorMessageCallback(
  56       WebGraphicsContext3DImpl* context)
  57       : graphics_context_(context) {
  58   }
  59
  60   void OnErrorMessage(const char* msg, int id) override;
  61
  62  private:
  63   WebGraphicsContext3DImpl* graphics_context_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(WebGraphicsContext3DErrorMessageCallback);
  66 };
  67
  68 void WebGraphicsContext3DErrorMessageCallback::OnErrorMessage(
  69     const char* msg, int id) {
  70   graphics_context_->OnErrorMessage(msg, id);
  71 }
  72
  73 // Helper macros to reduce the amount of code.
  74
  75 #define DELEGATE_TO_GL(name, glname)                                    \
  76 void WebGraphicsContext3DImpl::name() {                                 \
  77   gl_->glname();                                                        \
  78 }
  79
  80 #define DELEGATE_TO_GL_R(name, glname, rt)                              \
  81 rt WebGraphicsContext3DImpl::name() {                                   \
  82   return gl_->glname();                                                 \
  83 }
  84
  85 #define DELEGATE_TO_GL_1(name, glname, t1)                              \
  86 void WebGraphicsContext3DImpl::name(t1 a1) {                            \
  87   gl_->glname(a1);                                                      \
  88 }
  89
  90 #define DELEGATE_TO_GL_1R(name, glname, t1, rt)                         \
  91 rt WebGraphicsContext3DImpl::name(t1 a1) {                              \
  92   return gl_->glname(a1);                                               \
  93 }
  94
  95 #define DELEGATE_TO_GL_1RB(name, glname, t1, rt)                        \
  96 rt WebGraphicsContext3DImpl::name(t1 a1) {                              \
  97   return gl_->glname(a1) ? true : false;                                \
  98 }
  99
 100 #define DELEGATE_TO_GL_2(name, glname, t1, t2)                          \
 101 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2) {                     \
 102   gl_->glname(a1, a2);                                                  \
 103 }
 104
 105 #define DELEGATE_TO_GL_2R(name, glname, t1, t2, rt)                     \
 106 rt WebGraphicsContext3DImpl::name(t1 a1, t2 a2) {                       \
 107   return gl_->glname(a1, a2);                                           \
 108 }
 109
 110 #define DELEGATE_TO_GL_3(name, glname, t1, t2, t3)                      \
 111 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3) {              \
 112   gl_->glname(a1, a2, a3);                                              \
 113 }
 114
 115 #define DELEGATE_TO_GL_3R(name, glname, t1, t2, t3, rt)                 \
 116 rt WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3) {                \
 117   return gl_->glname(a1, a2, a3);                                       \
 118 }
 119
 120 #define DELEGATE_TO_GL_4(name, glname, t1, t2, t3, t4)                  \
 121 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4) {       \
 122   gl_->glname(a1, a2, a3, a4);                                          \
 123 }
 124
 125 #define DELEGATE_TO_GL_4R(name, glname, t1, t2, t3, t4, rt)             \
 126 rt WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4) {         \
 127   return gl_->glname(a1, a2, a3, a4);                                   \
 128 }
 129
 130 #define DELEGATE_TO_GL_5(name, glname, t1, t2, t3, t4, t5)              \
 131 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) {\
 132                                                                         \
 133   gl_->glname(a1, a2, a3, a4, a5);                                      \
 134 }
 135
 136 #define DELEGATE_TO_GL_6(name, glname, t1, t2, t3, t4, t5, t6)          \
 137 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,  \
 138                                     t6 a6) {                            \
 139   gl_->glname(a1, a2, a3, a4, a5, a6);                                  \
 140 }
 141
 142 #define DELEGATE_TO_GL_7(name, glname, t1, t2, t3, t4, t5, t6, t7)      \
 143 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,  \
 144                                     t6 a6, t7 a7) {                     \
 145   gl_->glname(a1, a2, a3, a4, a5, a6, a7);                              \
 146 }
 147
 148 #define DELEGATE_TO_GL_8(name, glname, t1, t2, t3, t4, t5, t6, t7, t8)  \
 149 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,  \
 150                                     t6 a6, t7 a7, t8 a8) {              \
 151   gl_->glname(a1, a2, a3, a4, a5, a6, a7, a8);                          \
 152 }
 153
 154 #define DELEGATE_TO_GL_9(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, t9) \
 155 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,  \
 156                                     t6 a6, t7 a7, t8 a8, t9 a9) {       \
 157   gl_->glname(a1, a2, a3, a4, a5, a6, a7, a8, a9);                      \
 158 }
 159
 160 #define DELEGATE_TO_GL_9R(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, \
 161                           t9, rt)                                       \
 162 rt WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,    \
 163                                     t6 a6, t7 a7, t8 a8, t9 a9) {       \
 164   return gl_->glname(a1, a2, a3, a4, a5, a6, a7, a8, a9);               \
 165 }
 166
 167 #define DELEGATE_TO_GL_10(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, \
 168                           t9, t10)                                      \
 169 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,  \
 170                                     t6 a6, t7 a7, t8 a8, t9 a9,         \
 171                                     t10 a10) {                          \
 172   gl_->glname(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);                 \
 173 }
 174
 175 #define DELEGATE_TO_GL_11(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, \
 176                           t9, t10, t11)                                 \
 177 void WebGraphicsContext3DImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5,  \
 178                                     t6 a6, t7 a7, t8 a8, t9 a9, t10 a10,\
 179                                     t11 a11) {                          \
 180   gl_->glname(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);            \
 181 }
 182
 183 WebGraphicsContext3DImpl::WebGraphicsContext3DImpl()
 184     : initialized_(false),
 185       initialize_failed_(false),
 186       context_lost_callback_(0),
 187       context_lost_reason_(GL_NO_ERROR),
 188       error_message_callback_(0),
 189       gl_(NULL),
 190       flush_id_(0) {
 191 }
 192
 193 WebGraphicsContext3DImpl::~WebGraphicsContext3DImpl() {
 194
 195 }
 196
 197 void WebGraphicsContext3DImpl::synthesizeGLError(WGC3Denum error) {
 198   if (std::find(synthetic_errors_.begin(), synthetic_errors_.end(), error) ==
 199       synthetic_errors_.end()) {
 200     synthetic_errors_.push_back(error);
 201   }
 202 }
 203
 204 uint32_t WebGraphicsContext3DImpl::lastFlushID() {
 205   return flush_id_;
 206 }
 207
 208 DELEGATE_TO_GL_R(insertSyncPoint, InsertSyncPointCHROMIUM, unsigned int)
 209
 210 DELEGATE_TO_GL_3(reshapeWithScaleFactor, ResizeCHROMIUM, int, int, float)
 211
 212 DELEGATE_TO_GL_4R(mapBufferSubDataCHROMIUM, MapBufferSubDataCHROMIUM, WGC3Denum,
 213                   WGC3Dintptr, WGC3Dsizeiptr, WGC3Denum, void*)
 214
 215 DELEGATE_TO_GL_1(unmapBufferSubDataCHROMIUM, UnmapBufferSubDataCHROMIUM,
 216                  const void*)
 217
 218 DELEGATE_TO_GL_9R(mapTexSubImage2DCHROMIUM, MapTexSubImage2DCHROMIUM, WGC3Denum,
 219                   WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei,
 220                   WGC3Denum, WGC3Denum, WGC3Denum, void*)
 221
 222 DELEGATE_TO_GL_1(unmapTexSubImage2DCHROMIUM, UnmapTexSubImage2DCHROMIUM,
 223                  const void*)
 224
 225 DELEGATE_TO_GL_3(discardFramebufferEXT, DiscardFramebufferEXT, WGC3Denum,
 226                  WGC3Dsizei, const WGC3Denum*)
 227
 228 blink::WebString WebGraphicsContext3DImpl::
 229     getRequestableExtensionsCHROMIUM() {
 230   return blink::WebString::fromUTF8(
 231       gl_->GetRequestableExtensionsCHROMIUM());
 232 }
 233
 234 DELEGATE_TO_GL_1(requestExtensionCHROMIUM, RequestExtensionCHROMIUM,
 235                  const char*)
 236
 237 void WebGraphicsContext3DImpl::blitFramebufferCHROMIUM(
 238     WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,
 239     WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,
 240     WGC3Dbitfield mask, WGC3Denum filter) {
 241   gl_->BlitFramebufferCHROMIUM(
 242       srcX0, srcY0, srcX1, srcY1,
 243       dstX0, dstY0, dstX1, dstY1,
 244       mask, filter);
 245 }
 246
 247 DELEGATE_TO_GL_5(renderbufferStorageMultisampleCHROMIUM,
 248                  RenderbufferStorageMultisampleCHROMIUM, WGC3Denum, WGC3Dsizei,
 249                  WGC3Denum, WGC3Dsizei, WGC3Dsizei)
 250
 251 DELEGATE_TO_GL_1(activeTexture, ActiveTexture, WGC3Denum)
 252
 253 DELEGATE_TO_GL_2(attachShader, AttachShader, WebGLId, WebGLId)
 254
 255 DELEGATE_TO_GL_3(bindAttribLocation, BindAttribLocation, WebGLId,
 256                  WGC3Duint, const WGC3Dchar*)
 257
 258 DELEGATE_TO_GL_2(bindBuffer, BindBuffer, WGC3Denum, WebGLId)
 259
 260 DELEGATE_TO_GL_2(bindFramebuffer, BindFramebuffer, WGC3Denum, WebGLId)
 261
 262 DELEGATE_TO_GL_2(bindRenderbuffer, BindRenderbuffer, WGC3Denum, WebGLId)
 263
 264 DELEGATE_TO_GL_2(bindTexture, BindTexture, WGC3Denum, WebGLId)
 265
 266 DELEGATE_TO_GL_4(blendColor, BlendColor,
 267                  WGC3Dclampf, WGC3Dclampf, WGC3Dclampf, WGC3Dclampf)
 268
 269 DELEGATE_TO_GL_1(blendEquation, BlendEquation, WGC3Denum)
 270
 271 DELEGATE_TO_GL_2(blendEquationSeparate, BlendEquationSeparate,
 272                  WGC3Denum, WGC3Denum)
 273
 274 DELEGATE_TO_GL_2(blendFunc, BlendFunc, WGC3Denum, WGC3Denum)
 275
 276 DELEGATE_TO_GL_4(blendFuncSeparate, BlendFuncSeparate,
 277                  WGC3Denum, WGC3Denum, WGC3Denum, WGC3Denum)
 278
 279 DELEGATE_TO_GL_4(bufferData, BufferData,
 280                  WGC3Denum, WGC3Dsizeiptr, const void*, WGC3Denum)
 281
 282 DELEGATE_TO_GL_4(bufferSubData, BufferSubData,
 283                  WGC3Denum, WGC3Dintptr, WGC3Dsizeiptr, const void*)
 284
 285 DELEGATE_TO_GL_1R(checkFramebufferStatus, CheckFramebufferStatus,
 286                   WGC3Denum, WGC3Denum)
 287
 288 DELEGATE_TO_GL_1(clear, Clear, WGC3Dbitfield)
 289
 290 DELEGATE_TO_GL_4(clearColor, ClearColor,
 291                  WGC3Dclampf, WGC3Dclampf, WGC3Dclampf, WGC3Dclampf)
 292
 293 DELEGATE_TO_GL_1(clearDepth, ClearDepthf, WGC3Dclampf)
 294
 295 DELEGATE_TO_GL_1(clearStencil, ClearStencil, WGC3Dint)
 296
 297 DELEGATE_TO_GL_4(colorMask, ColorMask,
 298                  WGC3Dboolean, WGC3Dboolean, WGC3Dboolean, WGC3Dboolean)
 299
 300 DELEGATE_TO_GL_1(compileShader, CompileShader, WebGLId)
 301
 302 DELEGATE_TO_GL_8(compressedTexImage2D, CompressedTexImage2D,
 303                  WGC3Denum, WGC3Dint, WGC3Denum, WGC3Dint, WGC3Dint,
 304                  WGC3Dsizei, WGC3Dsizei, const void*)
 305
 306 DELEGATE_TO_GL_9(compressedTexSubImage2D, CompressedTexSubImage2D,
 307                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint,
 308                  WGC3Denum, WGC3Dsizei, const void*)
 309
 310 DELEGATE_TO_GL_8(copyTexImage2D, CopyTexImage2D,
 311                  WGC3Denum, WGC3Dint, WGC3Denum, WGC3Dint, WGC3Dint,
 312                  WGC3Dsizei, WGC3Dsizei, WGC3Dint)
 313
 314 DELEGATE_TO_GL_8(copyTexSubImage2D, CopyTexSubImage2D,
 315                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint,
 316                  WGC3Dsizei, WGC3Dsizei)
 317
 318 DELEGATE_TO_GL_1(cullFace, CullFace, WGC3Denum)
 319
 320 DELEGATE_TO_GL_1(depthFunc, DepthFunc, WGC3Denum)
 321
 322 DELEGATE_TO_GL_1(depthMask, DepthMask, WGC3Dboolean)
 323
 324 DELEGATE_TO_GL_2(depthRange, DepthRangef, WGC3Dclampf, WGC3Dclampf)
 325
 326 DELEGATE_TO_GL_2(detachShader, DetachShader, WebGLId, WebGLId)
 327
 328 DELEGATE_TO_GL_1(disable, Disable, WGC3Denum)
 329
 330 DELEGATE_TO_GL_1(disableVertexAttribArray, DisableVertexAttribArray,
 331                  WGC3Duint)
 332
 333 DELEGATE_TO_GL_3(drawArrays, DrawArrays, WGC3Denum, WGC3Dint, WGC3Dsizei)
 334
 335 void WebGraphicsContext3DImpl::drawElements(WGC3Denum mode,
 336                                                          WGC3Dsizei count,
 337                                                          WGC3Denum type,
 338                                                          WGC3Dintptr offset) {
 339   gl_->DrawElements(
 340       mode, count, type,
 341       reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
 342 }
 343
 344 DELEGATE_TO_GL_1(enable, Enable, WGC3Denum)
 345
 346 DELEGATE_TO_GL_1(enableVertexAttribArray, EnableVertexAttribArray,
 347                  WGC3Duint)
 348
 349 void WebGraphicsContext3DImpl::finish() {
 350   flush_id_ = GenFlushID();
 351   gl_->Finish();
 352 }
 353
 354 void WebGraphicsContext3DImpl::flush() {
 355   flush_id_ = GenFlushID();
 356   gl_->Flush();
 357 }
 358
 359 DELEGATE_TO_GL_4(framebufferRenderbuffer, FramebufferRenderbuffer,
 360                  WGC3Denum, WGC3Denum, WGC3Denum, WebGLId)
 361
 362 DELEGATE_TO_GL_5(framebufferTexture2D, FramebufferTexture2D,
 363                  WGC3Denum, WGC3Denum, WGC3Denum, WebGLId, WGC3Dint)
 364
 365 DELEGATE_TO_GL_1(frontFace, FrontFace, WGC3Denum)
 366
 367 DELEGATE_TO_GL_1(generateMipmap, GenerateMipmap, WGC3Denum)
 368
 369 bool WebGraphicsContext3DImpl::getActiveAttrib(
 370     WebGLId program, WGC3Duint index, ActiveInfo& info) {
 371   if (!program) {
 372     synthesizeGLError(GL_INVALID_VALUE);
 373     return false;
 374   }
 375   GLint max_name_length = -1;
 376   gl_->GetProgramiv(
 377       program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &max_name_length);
 378   if (max_name_length < 0)
 379     return false;
 380   if (max_name_length == 0) {
 381     // No active attributes exist.
 382     synthesizeGLError(GL_INVALID_VALUE);
 383     return false;
 384   }
 385   scoped_ptr<GLchar[]> name(new GLchar[max_name_length]);
 386   GLsizei length = 0;
 387   GLint size = -1;
 388   GLenum type = 0;
 389   gl_->GetActiveAttrib(
 390       program, index, max_name_length, &length, &size, &type, name.get());
 391   if (size < 0) {
 392     return false;
 393   }
 394   info.name = blink::WebString::fromUTF8(name.get(), length);
 395   info.type = type;
 396   info.size = size;
 397   return true;
 398 }
 399
 400 bool WebGraphicsContext3DImpl::getActiveUniform(
 401     WebGLId program, WGC3Duint index, ActiveInfo& info) {
 402   GLint max_name_length = -1;
 403   gl_->GetProgramiv(
 404       program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_name_length);
 405   if (max_name_length < 0)
 406     return false;
 407   if (max_name_length == 0) {
 408     // No active uniforms exist.
 409     synthesizeGLError(GL_INVALID_VALUE);
 410     return false;
 411   }
 412   scoped_ptr<GLchar[]> name(new GLchar[max_name_length]);
 413   GLsizei length = 0;
 414   GLint size = -1;
 415   GLenum type = 0;
 416   gl_->GetActiveUniform(
 417       program, index, max_name_length, &length, &size, &type, name.get());
 418   if (size < 0) {
 419     return false;
 420   }
 421   info.name = blink::WebString::fromUTF8(name.get(), length);
 422   info.type = type;
 423   info.size = size;
 424   return true;
 425 }
 426
 427 DELEGATE_TO_GL_4(getAttachedShaders, GetAttachedShaders,
 428                  WebGLId, WGC3Dsizei, WGC3Dsizei*, WebGLId*)
 429
 430 DELEGATE_TO_GL_2R(getAttribLocation, GetAttribLocation,
 431                   WebGLId, const WGC3Dchar*, WGC3Dint)
 432
 433 DELEGATE_TO_GL_2(getBooleanv, GetBooleanv, WGC3Denum, WGC3Dboolean*)
 434
 435 DELEGATE_TO_GL_3(getBufferParameteriv, GetBufferParameteriv,
 436                  WGC3Denum, WGC3Denum, WGC3Dint*)
 437
 438 WGC3Denum WebGraphicsContext3DImpl::getError() {
 439   if (!synthetic_errors_.empty()) {
 440     std::vector<WGC3Denum>::iterator iter = synthetic_errors_.begin();
 441     WGC3Denum err = *iter;
 442     synthetic_errors_.erase(iter);
 443     return err;
 444   }
 445
 446   return gl_->GetError();
 447 }
 448
 449 DELEGATE_TO_GL_2(getFloatv, GetFloatv, WGC3Denum, WGC3Dfloat*)
 450
 451 DELEGATE_TO_GL_4(getFramebufferAttachmentParameteriv,
 452                  GetFramebufferAttachmentParameteriv,
 453                  WGC3Denum, WGC3Denum, WGC3Denum, WGC3Dint*)
 454
 455 DELEGATE_TO_GL_2(getIntegerv, GetIntegerv, WGC3Denum, WGC3Dint*)
 456
 457 DELEGATE_TO_GL_3(getProgramiv, GetProgramiv, WebGLId, WGC3Denum, WGC3Dint*)
 458
 459 blink::WebString WebGraphicsContext3DImpl::getProgramInfoLog(
 460     WebGLId program) {
 461   GLint logLength = 0;
 462   gl_->GetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
 463   if (!logLength)
 464     return blink::WebString();
 465   scoped_ptr<GLchar[]> log(new GLchar[logLength]);
 466   if (!log)
 467     return blink::WebString();
 468   GLsizei returnedLogLength = 0;
 469   gl_->GetProgramInfoLog(
 470       program, logLength, &returnedLogLength, log.get());
 471   DCHECK_EQ(logLength, returnedLogLength + 1);
 472   blink::WebString res =
 473       blink::WebString::fromUTF8(log.get(), returnedLogLength);
 474   return res;
 475 }
 476
 477 DELEGATE_TO_GL_3(getRenderbufferParameteriv, GetRenderbufferParameteriv,
 478                  WGC3Denum, WGC3Denum, WGC3Dint*)
 479
 480 DELEGATE_TO_GL_3(getShaderiv, GetShaderiv, WebGLId, WGC3Denum, WGC3Dint*)
 481
 482 blink::WebString WebGraphicsContext3DImpl::getShaderInfoLog(
 483     WebGLId shader) {
 484   GLint logLength = 0;
 485   gl_->GetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
 486   if (!logLength)
 487     return blink::WebString();
 488   scoped_ptr<GLchar[]> log(new GLchar[logLength]);
 489   if (!log)
 490     return blink::WebString();
 491   GLsizei returnedLogLength = 0;
 492   gl_->GetShaderInfoLog(
 493       shader, logLength, &returnedLogLength, log.get());
 494   DCHECK_EQ(logLength, returnedLogLength + 1);
 495   blink::WebString res =
 496       blink::WebString::fromUTF8(log.get(), returnedLogLength);
 497   return res;
 498 }
 499
 500 DELEGATE_TO_GL_4(getShaderPrecisionFormat, GetShaderPrecisionFormat,
 501                  WGC3Denum, WGC3Denum, WGC3Dint*, WGC3Dint*)
 502
 503 blink::WebString WebGraphicsContext3DImpl::getShaderSource(
 504     WebGLId shader) {
 505   GLint logLength = 0;
 506   gl_->GetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &logLength);
 507   if (!logLength)
 508     return blink::WebString();
 509   scoped_ptr<GLchar[]> log(new GLchar[logLength]);
 510   if (!log)
 511     return blink::WebString();
 512   GLsizei returnedLogLength = 0;
 513   gl_->GetShaderSource(
 514       shader, logLength, &returnedLogLength, log.get());
 515   if (!returnedLogLength)
 516     return blink::WebString();
 517   DCHECK_EQ(logLength, returnedLogLength + 1);
 518   blink::WebString res =
 519       blink::WebString::fromUTF8(log.get(), returnedLogLength);
 520   return res;
 521 }
 522
 523 blink::WebString WebGraphicsContext3DImpl::
 524     getTranslatedShaderSourceANGLE(WebGLId shader) {
 525   GLint logLength = 0;
 526   gl_->GetShaderiv(
 527       shader, GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE, &logLength);
 528   if (!logLength)
 529     return blink::WebString();
 530   scoped_ptr<GLchar[]> log(new GLchar[logLength]);
 531   if (!log)
 532     return blink::WebString();
 533   GLsizei returnedLogLength = 0;
 534   gl_->GetTranslatedShaderSourceANGLE(
 535       shader, logLength, &returnedLogLength, log.get());
 536   if (!returnedLogLength)
 537     return blink::WebString();
 538   DCHECK_EQ(logLength, returnedLogLength + 1);
 539   blink::WebString res =
 540       blink::WebString::fromUTF8(log.get(), returnedLogLength);
 541   return res;
 542 }
 543
 544 blink::WebString WebGraphicsContext3DImpl::getString(
 545     WGC3Denum name) {
 546   return blink::WebString::fromUTF8(
 547       reinterpret_cast<const char*>(gl_->GetString(name)));
 548 }
 549
 550 DELEGATE_TO_GL_3(getTexParameterfv, GetTexParameterfv,
 551                  WGC3Denum, WGC3Denum, WGC3Dfloat*)
 552
 553 DELEGATE_TO_GL_3(getTexParameteriv, GetTexParameteriv,
 554                  WGC3Denum, WGC3Denum, WGC3Dint*)
 555
 556 DELEGATE_TO_GL_3(getUniformfv, GetUniformfv, WebGLId, WGC3Dint, WGC3Dfloat*)
 557
 558 DELEGATE_TO_GL_3(getUniformiv, GetUniformiv, WebGLId, WGC3Dint, WGC3Dint*)
 559
 560 DELEGATE_TO_GL_2R(getUniformLocation, GetUniformLocation,
 561                   WebGLId, const WGC3Dchar*, WGC3Dint)
 562
 563 DELEGATE_TO_GL_3(getVertexAttribfv, GetVertexAttribfv,
 564                  WGC3Duint, WGC3Denum, WGC3Dfloat*)
 565
 566 DELEGATE_TO_GL_3(getVertexAttribiv, GetVertexAttribiv,
 567                  WGC3Duint, WGC3Denum, WGC3Dint*)
 568
 569 WGC3Dsizeiptr WebGraphicsContext3DImpl::getVertexAttribOffset(
 570     WGC3Duint index, WGC3Denum pname) {
 571   GLvoid* value = NULL;
 572   // NOTE: If pname is ever a value that returns more then 1 element
 573   // this will corrupt memory.
 574   gl_->GetVertexAttribPointerv(index, pname, &value);
 575   return static_cast<WGC3Dsizeiptr>(reinterpret_cast<intptr_t>(value));
 576 }
 577
 578 DELEGATE_TO_GL_2(hint, Hint, WGC3Denum, WGC3Denum)
 579
 580 DELEGATE_TO_GL_1RB(isBuffer, IsBuffer, WebGLId, WGC3Dboolean)
 581
 582 DELEGATE_TO_GL_1RB(isEnabled, IsEnabled, WGC3Denum, WGC3Dboolean)
 583
 584 DELEGATE_TO_GL_1RB(isFramebuffer, IsFramebuffer, WebGLId, WGC3Dboolean)
 585
 586 DELEGATE_TO_GL_1RB(isProgram, IsProgram, WebGLId, WGC3Dboolean)
 587
 588 DELEGATE_TO_GL_1RB(isRenderbuffer, IsRenderbuffer, WebGLId, WGC3Dboolean)
 589
 590 DELEGATE_TO_GL_1RB(isShader, IsShader, WebGLId, WGC3Dboolean)
 591
 592 DELEGATE_TO_GL_1RB(isTexture, IsTexture, WebGLId, WGC3Dboolean)
 593
 594 DELEGATE_TO_GL_1(lineWidth, LineWidth, WGC3Dfloat)
 595
 596 DELEGATE_TO_GL_1(linkProgram, LinkProgram, WebGLId)
 597
 598 DELEGATE_TO_GL_2(pixelStorei, PixelStorei, WGC3Denum, WGC3Dint)
 599
 600 DELEGATE_TO_GL_2(polygonOffset, PolygonOffset, WGC3Dfloat, WGC3Dfloat)
 601
 602 DELEGATE_TO_GL_7(readPixels, ReadPixels,
 603                  WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei, WGC3Denum,
 604                  WGC3Denum, void*)
 605
 606 DELEGATE_TO_GL_4(renderbufferStorage, RenderbufferStorage,
 607                  WGC3Denum, WGC3Denum, WGC3Dsizei, WGC3Dsizei)
 608
 609 DELEGATE_TO_GL_2(sampleCoverage, SampleCoverage, WGC3Dfloat, WGC3Dboolean)
 610
 611 DELEGATE_TO_GL_4(scissor, Scissor, WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei)
 612
 613 void WebGraphicsContext3DImpl::shaderSource(
 614     WebGLId shader, const WGC3Dchar* string) {
 615   GLint length = strlen(string);
 616   gl_->ShaderSource(shader, 1, &string, &length);
 617 }
 618
 619 DELEGATE_TO_GL_3(stencilFunc, StencilFunc, WGC3Denum, WGC3Dint, WGC3Duint)
 620
 621 DELEGATE_TO_GL_4(stencilFuncSeparate, StencilFuncSeparate,
 622                  WGC3Denum, WGC3Denum, WGC3Dint, WGC3Duint)
 623
 624 DELEGATE_TO_GL_1(stencilMask, StencilMask, WGC3Duint)
 625
 626 DELEGATE_TO_GL_2(stencilMaskSeparate, StencilMaskSeparate,
 627                  WGC3Denum, WGC3Duint)
 628
 629 DELEGATE_TO_GL_3(stencilOp, StencilOp,
 630                  WGC3Denum, WGC3Denum, WGC3Denum)
 631
 632 DELEGATE_TO_GL_4(stencilOpSeparate, StencilOpSeparate,
 633                  WGC3Denum, WGC3Denum, WGC3Denum, WGC3Denum)
 634
 635 DELEGATE_TO_GL_9(texImage2D, TexImage2D,
 636                  WGC3Denum, WGC3Dint, WGC3Denum, WGC3Dsizei, WGC3Dsizei,
 637                  WGC3Dint, WGC3Denum, WGC3Denum, const void*)
 638
 639 DELEGATE_TO_GL_3(texParameterf, TexParameterf,
 640                  WGC3Denum, WGC3Denum, WGC3Dfloat);
 641
 642 DELEGATE_TO_GL_3(texParameteri, TexParameteri,
 643                  WGC3Denum, WGC3Denum, WGC3Dint);
 644
 645 DELEGATE_TO_GL_9(texSubImage2D, TexSubImage2D,
 646                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
 647                  WGC3Dsizei, WGC3Denum, WGC3Denum, const void*)
 648
 649 DELEGATE_TO_GL_2(uniform1f, Uniform1f, WGC3Dint, WGC3Dfloat)
 650
 651 DELEGATE_TO_GL_3(uniform1fv, Uniform1fv, WGC3Dint, WGC3Dsizei,
 652                  const WGC3Dfloat*)
 653
 654 DELEGATE_TO_GL_2(uniform1i, Uniform1i, WGC3Dint, WGC3Dint)
 655
 656 DELEGATE_TO_GL_3(uniform1iv, Uniform1iv, WGC3Dint, WGC3Dsizei, const WGC3Dint*)
 657
 658 DELEGATE_TO_GL_3(uniform2f, Uniform2f, WGC3Dint, WGC3Dfloat, WGC3Dfloat)
 659
 660 DELEGATE_TO_GL_3(uniform2fv, Uniform2fv, WGC3Dint, WGC3Dsizei,
 661                  const WGC3Dfloat*)
 662
 663 DELEGATE_TO_GL_3(uniform2i, Uniform2i, WGC3Dint, WGC3Dint, WGC3Dint)
 664
 665 DELEGATE_TO_GL_3(uniform2iv, Uniform2iv, WGC3Dint, WGC3Dsizei, const WGC3Dint*)
 666
 667 DELEGATE_TO_GL_4(uniform3f, Uniform3f, WGC3Dint,
 668                  WGC3Dfloat, WGC3Dfloat, WGC3Dfloat)
 669
 670 DELEGATE_TO_GL_3(uniform3fv, Uniform3fv, WGC3Dint, WGC3Dsizei,
 671                  const WGC3Dfloat*)
 672
 673 DELEGATE_TO_GL_4(uniform3i, Uniform3i, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint)
 674
 675 DELEGATE_TO_GL_3(uniform3iv, Uniform3iv, WGC3Dint, WGC3Dsizei, const WGC3Dint*)
 676
 677 DELEGATE_TO_GL_5(uniform4f, Uniform4f, WGC3Dint,
 678                  WGC3Dfloat, WGC3Dfloat, WGC3Dfloat, WGC3Dfloat)
 679
 680 DELEGATE_TO_GL_3(uniform4fv, Uniform4fv, WGC3Dint, WGC3Dsizei,
 681                  const WGC3Dfloat*)
 682
 683 DELEGATE_TO_GL_5(uniform4i, Uniform4i, WGC3Dint,
 684                  WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint)
 685
 686 DELEGATE_TO_GL_3(uniform4iv, Uniform4iv, WGC3Dint, WGC3Dsizei, const WGC3Dint*)
 687
 688 DELEGATE_TO_GL_4(uniformMatrix2fv, UniformMatrix2fv,
 689                  WGC3Dint, WGC3Dsizei, WGC3Dboolean, const WGC3Dfloat*)
 690
 691 DELEGATE_TO_GL_4(uniformMatrix3fv, UniformMatrix3fv,
 692                  WGC3Dint, WGC3Dsizei, WGC3Dboolean, const WGC3Dfloat*)
 693
 694 DELEGATE_TO_GL_4(uniformMatrix4fv, UniformMatrix4fv,
 695                  WGC3Dint, WGC3Dsizei, WGC3Dboolean, const WGC3Dfloat*)
 696
 697 DELEGATE_TO_GL_1(useProgram, UseProgram, WebGLId)
 698
 699 DELEGATE_TO_GL_1(validateProgram, ValidateProgram, WebGLId)
 700
 701 DELEGATE_TO_GL_2(vertexAttrib1f, VertexAttrib1f, WGC3Duint, WGC3Dfloat)
 702
 703 DELEGATE_TO_GL_2(vertexAttrib1fv, VertexAttrib1fv, WGC3Duint,
 704                  const WGC3Dfloat*)
 705
 706 DELEGATE_TO_GL_3(vertexAttrib2f, VertexAttrib2f, WGC3Duint,
 707                  WGC3Dfloat, WGC3Dfloat)
 708
 709 DELEGATE_TO_GL_2(vertexAttrib2fv, VertexAttrib2fv, WGC3Duint,
 710                  const WGC3Dfloat*)
 711
 712 DELEGATE_TO_GL_4(vertexAttrib3f, VertexAttrib3f, WGC3Duint,
 713                  WGC3Dfloat, WGC3Dfloat, WGC3Dfloat)
 714
 715 DELEGATE_TO_GL_2(vertexAttrib3fv, VertexAttrib3fv, WGC3Duint,
 716                  const WGC3Dfloat*)
 717
 718 DELEGATE_TO_GL_5(vertexAttrib4f, VertexAttrib4f, WGC3Duint,
 719                  WGC3Dfloat, WGC3Dfloat, WGC3Dfloat, WGC3Dfloat)
 720
 721 DELEGATE_TO_GL_2(vertexAttrib4fv, VertexAttrib4fv, WGC3Duint,
 722                  const WGC3Dfloat*)
 723
 724 void WebGraphicsContext3DImpl::vertexAttribPointer(
 725     WGC3Duint index, WGC3Dint size, WGC3Denum type, WGC3Dboolean normalized,
 726     WGC3Dsizei stride, WGC3Dintptr offset) {
 727   gl_->VertexAttribPointer(
 728       index, size, type, normalized, stride,
 729       reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
 730 }
 731
 732 DELEGATE_TO_GL_4(viewport, Viewport,
 733                  WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei)
 734
 735 WebGLId WebGraphicsContext3DImpl::createBuffer() {
 736   GLuint o;
 737   gl_->GenBuffers(1, &o);
 738   return o;
 739 }
 740
 741 WebGLId WebGraphicsContext3DImpl::createFramebuffer() {
 742   GLuint o = 0;
 743   gl_->GenFramebuffers(1, &o);
 744   return o;
 745 }
 746
 747 WebGLId WebGraphicsContext3DImpl::createRenderbuffer() {
 748   GLuint o;
 749   gl_->GenRenderbuffers(1, &o);
 750   return o;
 751 }
 752
 753 WebGLId WebGraphicsContext3DImpl::createTexture() {
 754   GLuint o;
 755   gl_->GenTextures(1, &o);
 756   return o;
 757 }
 758
 759 void WebGraphicsContext3DImpl::deleteBuffer(WebGLId buffer) {
 760   gl_->DeleteBuffers(1, &buffer);
 761 }
 762
 763 void WebGraphicsContext3DImpl::deleteFramebuffer(
 764     WebGLId framebuffer) {
 765   gl_->DeleteFramebuffers(1, &framebuffer);
 766 }
 767
 768 void WebGraphicsContext3DImpl::deleteRenderbuffer(
 769     WebGLId renderbuffer) {
 770   gl_->DeleteRenderbuffers(1, &renderbuffer);
 771 }
 772
 773 void WebGraphicsContext3DImpl::deleteTexture(WebGLId texture) {
 774   gl_->DeleteTextures(1, &texture);
 775 }
 776
 777 DELEGATE_TO_GL_R(createProgram, CreateProgram, WebGLId)
 778
 779 DELEGATE_TO_GL_1R(createShader, CreateShader, WGC3Denum, WebGLId)
 780
 781 DELEGATE_TO_GL_1(deleteProgram, DeleteProgram, WebGLId)
 782
 783 DELEGATE_TO_GL_1(deleteShader, DeleteShader, WebGLId)
 784
 785 void WebGraphicsContext3DImpl::setErrorMessageCallback(
 786     WebGraphicsContext3D::WebGraphicsErrorMessageCallback* cb) {
 787   error_message_callback_ = cb;
 788 }
 789
 790 void WebGraphicsContext3DImpl::setContextLostCallback(
 791     WebGraphicsContext3D::WebGraphicsContextLostCallback* cb) {
 792   context_lost_callback_ = cb;
 793 }
 794
 795 DELEGATE_TO_GL_5(texImageIOSurface2DCHROMIUM, TexImageIOSurface2DCHROMIUM,
 796                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Duint, WGC3Duint)
 797
 798 DELEGATE_TO_GL_5(texStorage2DEXT, TexStorage2DEXT,
 799                  WGC3Denum, WGC3Dint, WGC3Duint, WGC3Dint, WGC3Dint)
 800
 801 WebGLId WebGraphicsContext3DImpl::createQueryEXT() {
 802   GLuint o;
 803   gl_->GenQueriesEXT(1, &o);
 804   return o;
 805 }
 806
 807 void WebGraphicsContext3DImpl::deleteQueryEXT(
 808     WebGLId query) {
 809   gl_->DeleteQueriesEXT(1, &query);
 810 }
 811
 812 DELEGATE_TO_GL_1R(isQueryEXT, IsQueryEXT, WebGLId, WGC3Dboolean)
 813 DELEGATE_TO_GL_2(beginQueryEXT, BeginQueryEXT, WGC3Denum, WebGLId)
 814 DELEGATE_TO_GL_1(endQueryEXT, EndQueryEXT, WGC3Denum)
 815 DELEGATE_TO_GL_3(getQueryivEXT, GetQueryivEXT, WGC3Denum, WGC3Denum, WGC3Dint*)
 816 DELEGATE_TO_GL_3(getQueryObjectuivEXT, GetQueryObjectuivEXT,
 817                  WebGLId, WGC3Denum, WGC3Duint*)
 818
 819 DELEGATE_TO_GL_5(copyTextureCHROMIUM,
 820                  CopyTextureCHROMIUM,
 821                  WGC3Denum,
 822                  WebGLId,
 823                  WebGLId,
 824                  WGC3Denum,
 825                  WGC3Denum);
 826
 827 DELEGATE_TO_GL_5(copySubTextureCHROMIUM,
 828                  CopySubTextureCHROMIUM,
 829                  WGC3Denum,
 830                  WebGLId,
 831                  WebGLId,
 832                  WGC3Dint,
 833                  WGC3Dint);
 834
 835 DELEGATE_TO_GL_3(bindUniformLocationCHROMIUM, BindUniformLocationCHROMIUM,
 836                  WebGLId, WGC3Dint, const WGC3Dchar*)
 837
 838 void WebGraphicsContext3DImpl::shallowFlushCHROMIUM() {
 839   flush_id_ = GenFlushID();
 840   gl_->ShallowFlushCHROMIUM();
 841 }
 842
 843 void WebGraphicsContext3DImpl::shallowFinishCHROMIUM() {
 844   flush_id_ = GenFlushID();
 845   gl_->ShallowFinishCHROMIUM();
 846 }
 847
 848 DELEGATE_TO_GL_1(waitSyncPoint, WaitSyncPointCHROMIUM, GLuint)
 849
 850 void WebGraphicsContext3DImpl::loseContextCHROMIUM(
 851     WGC3Denum current, WGC3Denum other) {
 852   gl_->LoseContextCHROMIUM(current, other);
 853   gl_->Flush();
 854 }
 855
 856 DELEGATE_TO_GL_1(genMailboxCHROMIUM, GenMailboxCHROMIUM, WGC3Dbyte*)
 857 DELEGATE_TO_GL_2(produceTextureCHROMIUM, ProduceTextureCHROMIUM,
 858                  WGC3Denum, const WGC3Dbyte*)
 859 DELEGATE_TO_GL_3(produceTextureDirectCHROMIUM, ProduceTextureDirectCHROMIUM,
 860                  WebGLId, WGC3Denum, const WGC3Dbyte*)
 861 DELEGATE_TO_GL_2(consumeTextureCHROMIUM, ConsumeTextureCHROMIUM,
 862                  WGC3Denum, const WGC3Dbyte*)
 863 DELEGATE_TO_GL_2R(createAndConsumeTextureCHROMIUM,
 864                   CreateAndConsumeTextureCHROMIUM,
 865                   WGC3Denum, const WGC3Dbyte*, WebGLId)
 866
 867 DELEGATE_TO_GL_2(genValuebuffersCHROMIUM,
 868                  GenValuebuffersCHROMIUM,
 869                  WGC3Dsizei,
 870                  WebGLId*);
 871
 872 WebGLId WebGraphicsContext3DImpl::createValuebufferCHROMIUM() {
 873   GLuint o;
 874   gl_->GenValuebuffersCHROMIUM(1, &o);
 875   return o;
 876 }
 877
 878 DELEGATE_TO_GL_2(deleteValuebuffersCHROMIUM,
 879                  DeleteValuebuffersCHROMIUM,
 880                  WGC3Dsizei,
 881                  WebGLId*);
 882
 883 void WebGraphicsContext3DImpl::deleteValuebufferCHROMIUM(WebGLId valuebuffer) {
 884   gl_->DeleteValuebuffersCHROMIUM(1, &valuebuffer);
 885 }
 886
 887 DELEGATE_TO_GL_1RB(isValuebufferCHROMIUM,
 888                    IsValuebufferCHROMIUM,
 889                    WebGLId,
 890                    WGC3Dboolean)
 891 DELEGATE_TO_GL_2(bindValuebufferCHROMIUM,
 892                  BindValuebufferCHROMIUM,
 893                  WGC3Denum,
 894                  WebGLId)
 895 DELEGATE_TO_GL_2(subscribeValueCHROMIUM,
 896                  SubscribeValueCHROMIUM,
 897                  WGC3Denum,
 898                  WGC3Denum);
 899 DELEGATE_TO_GL_1(populateSubscribedValuesCHROMIUM,
 900                  PopulateSubscribedValuesCHROMIUM,
 901                  WGC3Denum);
 902 DELEGATE_TO_GL_3(uniformValuebufferCHROMIUM,
 903                  UniformValuebufferCHROMIUM,
 904                  WGC3Dint,
 905                  WGC3Denum,
 906                  WGC3Denum);
 907 DELEGATE_TO_GL_2(traceBeginCHROMIUM,
 908                  TraceBeginCHROMIUM,
 909                  const WGC3Dchar*,
 910                  const WGC3Dchar*);
 911 DELEGATE_TO_GL(traceEndCHROMIUM, TraceEndCHROMIUM);
 912
 913 void WebGraphicsContext3DImpl::insertEventMarkerEXT(
 914     const WGC3Dchar* marker) {
 915   gl_->InsertEventMarkerEXT(0, marker);
 916 }
 917
 918 void WebGraphicsContext3DImpl::pushGroupMarkerEXT(
 919     const WGC3Dchar* marker) {
 920   gl_->PushGroupMarkerEXT(0, marker);
 921 }
 922
 923 DELEGATE_TO_GL(popGroupMarkerEXT, PopGroupMarkerEXT);
 924
 925 WebGLId WebGraphicsContext3DImpl::createVertexArrayOES() {
 926   GLuint array;
 927   gl_->GenVertexArraysOES(1, &array);
 928   return array;
 929 }
 930
 931 void WebGraphicsContext3DImpl::deleteVertexArrayOES(
 932     WebGLId array) {
 933   gl_->DeleteVertexArraysOES(1, &array);
 934 }
 935
 936 DELEGATE_TO_GL_1R(isVertexArrayOES, IsVertexArrayOES, WebGLId, WGC3Dboolean)
 937 DELEGATE_TO_GL_1(bindVertexArrayOES, BindVertexArrayOES, WebGLId)
 938
 939 DELEGATE_TO_GL_2(bindTexImage2DCHROMIUM, BindTexImage2DCHROMIUM,
 940                  WGC3Denum, WGC3Dint)
 941 DELEGATE_TO_GL_2(releaseTexImage2DCHROMIUM, ReleaseTexImage2DCHROMIUM,
 942                  WGC3Denum, WGC3Dint)
 943
 944 DELEGATE_TO_GL_2R(mapBufferCHROMIUM, MapBufferCHROMIUM, WGC3Denum, WGC3Denum,
 945                   void*)
 946 DELEGATE_TO_GL_1R(unmapBufferCHROMIUM, UnmapBufferCHROMIUM, WGC3Denum,
 947                   WGC3Dboolean)
 948
 949 DELEGATE_TO_GL_9(asyncTexImage2DCHROMIUM, AsyncTexImage2DCHROMIUM, WGC3Denum,
 950                  WGC3Dint, WGC3Denum, WGC3Dsizei, WGC3Dsizei, WGC3Dint,
 951                  WGC3Denum, WGC3Denum, const void*)
 952 DELEGATE_TO_GL_9(asyncTexSubImage2DCHROMIUM, AsyncTexSubImage2DCHROMIUM,
 953                  WGC3Denum, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
 954                  WGC3Dsizei, WGC3Denum, WGC3Denum, const void*)
 955
 956 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
 957                  WGC3Denum)
 958
 959 DELEGATE_TO_GL_2(drawBuffersEXT, DrawBuffersEXT, WGC3Dsizei, const WGC3Denum*)
 960
 961 DELEGATE_TO_GL_4(drawArraysInstancedANGLE, DrawArraysInstancedANGLE, WGC3Denum,
 962                  WGC3Dint, WGC3Dsizei, WGC3Dsizei)
 963
 964 void WebGraphicsContext3DImpl::drawElementsInstancedANGLE(
 965     WGC3Denum mode,
 966     WGC3Dsizei count,
 967     WGC3Denum type,
 968     WGC3Dintptr offset,
 969     WGC3Dsizei primcount) {
 970   gl_->DrawElementsInstancedANGLE(
 971       mode, count, type,
 972       reinterpret_cast<void*>(static_cast<intptr_t>(offset)), primcount);
 973 }
 974
 975 DELEGATE_TO_GL_2(vertexAttribDivisorANGLE, VertexAttribDivisorANGLE, WGC3Duint,
 976                  WGC3Duint)
 977
 978 DELEGATE_TO_GL_4R(createGpuMemoryBufferImageCHROMIUM,
 979                   CreateGpuMemoryBufferImageCHROMIUM,
 980                   WGC3Dsizei,
 981                   WGC3Dsizei,
 982                   WGC3Denum,
 983                   WGC3Denum,
 984                   WGC3Duint);
 985
 986 DELEGATE_TO_GL_1(destroyImageCHROMIUM, DestroyImageCHROMIUM, WGC3Duint);
 987
 988 DELEGATE_TO_GL_6(framebufferTexture2DMultisampleEXT,
 989                  FramebufferTexture2DMultisampleEXT,
 990                  WGC3Denum, WGC3Denum, WGC3Denum, WebGLId, WGC3Dint, WGC3Dsizei)
 991
 992 DELEGATE_TO_GL_5(renderbufferStorageMultisampleEXT,
 993                  RenderbufferStorageMultisampleEXT, WGC3Denum, WGC3Dsizei,
 994                  WGC3Denum, WGC3Dsizei, WGC3Dsizei)
 995
 996 DELEGATE_TO_GL_1(beginTransformFeedback, BeginTransformFeedback, WGC3Denum)
 997 DELEGATE_TO_GL_3(bindBufferBase, BindBufferBase, WGC3Denum, WGC3Duint,
 998                  WGC3Duint)
 999 DELEGATE_TO_GL_5(bindBufferRange, BindBufferRange, WGC3Denum, WGC3Duint,
1000                  WGC3Duint, WGC3Dintptr, WGC3Dsizeiptr)
1001 DELEGATE_TO_GL_2(bindSampler, BindSampler, WGC3Duint, WebGLId)
1002 DELEGATE_TO_GL_2(bindTransformFeedback, BindTransformFeedback, WGC3Denum,
1003                  WebGLId)
1004 DELEGATE_TO_GL_4(clearBufferfi, ClearBufferfi, WGC3Denum, WGC3Dint, WGC3Dfloat,
1005                  WGC3Dint)
1006 DELEGATE_TO_GL_3(clearBufferfv, ClearBufferfv, WGC3Denum, WGC3Dint,
1007                  const WGC3Dfloat *)
1008 DELEGATE_TO_GL_3(clearBufferiv, ClearBufferiv, WGC3Denum, WGC3Dint,
1009                  const WGC3Dint *)
1010 DELEGATE_TO_GL_3(clearBufferuiv, ClearBufferuiv, WGC3Denum, WGC3Dint,
1011                  const WGC3Duint *)
1012 WGC3Denum WebGraphicsContext3DImpl::clientWaitSync(WGC3Dsync sync,
1013                                                    WGC3Dbitfield flags,
1014                                                    WGC3Duint64 timeout) {
1015   return gl_->ClientWaitSync(reinterpret_cast<GLsync>(sync), flags, timeout);
1016 }
1017 DELEGATE_TO_GL_9(compressedTexImage3D, CompressedTexImage3D, WGC3Denum,
1018                  WGC3Dint, WGC3Denum, WGC3Dsizei, WGC3Dsizei, WGC3Dsizei,
1019                  WGC3Dint, WGC3Dsizei, const void *)
1020 DELEGATE_TO_GL_11(compressedTexSubImage3D, CompressedTexSubImage3D, WGC3Denum,
1021                   WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
1022                   WGC3Dsizei, WGC3Dsizei, WGC3Denum, WGC3Dsizei, const void *)
1023 DELEGATE_TO_GL_5(copyBufferSubData, CopyBufferSubData, WGC3Denum, WGC3Denum,
1024                  WGC3Dintptr, WGC3Dintptr, WGC3Dsizeiptr)
1025 DELEGATE_TO_GL_9(copyTexSubImage3D, CopyTexSubImage3D, WGC3Denum, WGC3Dint,
1026                  WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dint, WGC3Dsizei,
1027                  WGC3Dsizei)
1028 WebGLId WebGraphicsContext3DImpl::createSampler() {
1029   GLuint sampler;
1030   gl_->GenSamplers(1, &sampler);
1031   return sampler;
1032 }
1033 WebGLId WebGraphicsContext3DImpl::createTransformFeedback() {
1034   GLuint tf;
1035   gl_->GenTransformFeedbacks(1, &tf);
1036   return tf;
1037 }
1038 void WebGraphicsContext3DImpl::deleteSampler(WebGLId sampler) {
1039   gl_->DeleteSamplers(1, &sampler);
1040 }
1041 void WebGraphicsContext3DImpl::deleteSync(WGC3Dsync sync) {
1042   gl_->DeleteSync(reinterpret_cast<GLsync>(sync));
1043 }
1044 void WebGraphicsContext3DImpl::deleteTransformFeedback(WebGLId tf) {
1045   gl_->DeleteTransformFeedbacks(1, &tf);
1046 }
1047 void WebGraphicsContext3DImpl::drawRangeElements(
1048     WGC3Denum mode, WGC3Duint start, WGC3Duint end, WGC3Dsizei count,
1049     WGC3Denum type, WGC3Dintptr offset) {
1050   gl_->DrawRangeElements(mode, start, end, count, type,
1051       reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
1052 }
1053 DELEGATE_TO_GL(endTransformFeedback, EndTransformFeedback)
1054 WGC3Dsync WebGraphicsContext3DImpl::fenceSync(WGC3Denum condition,
1055                                               WGC3Dbitfield flags) {
1056   return reinterpret_cast<WGC3Dsync>(gl_->FenceSync(condition, flags));
1057 }
1058 DELEGATE_TO_GL_5(framebufferTextureLayer, FramebufferTextureLayer, WGC3Denum,
1059                  WGC3Denum, WGC3Duint, WGC3Dint, WGC3Dint)
1060 DELEGATE_TO_GL_5(getActiveUniformBlockName, GetActiveUniformBlockName,
1061                  WGC3Duint, WGC3Duint, WGC3Dsizei, WGC3Dsizei *, WGC3Dchar *)
1062 DELEGATE_TO_GL_4(getActiveUniformBlockiv, GetActiveUniformBlockiv, WGC3Duint,
1063                  WGC3Duint, WGC3Denum, WGC3Dint *)
1064 DELEGATE_TO_GL_5(getActiveUniformsiv, GetActiveUniformsiv, WGC3Duint,
1065                  WGC3Dsizei, const WGC3Duint *, WGC3Denum, WGC3Dint *)
1066 DELEGATE_TO_GL_2R(getFragDataLocation, GetFragDataLocation, WGC3Duint,
1067                   const WGC3Dchar *, WGC3Dint)
1068 DELEGATE_TO_GL_5(getInternalformativ, GetInternalformativ, WGC3Denum, WGC3Denum,
1069                  WGC3Denum, WGC3Dsizei, WGC3Dint *)
1070 DELEGATE_TO_GL_3(getSamplerParameterfv, GetSamplerParameterfv, WGC3Duint,
1071                  WGC3Denum, WGC3Dfloat *)
1072 DELEGATE_TO_GL_3(getSamplerParameteriv, GetSamplerParameteriv, WGC3Duint,
1073                  WGC3Denum, WGC3Dint *)
1074 DELEGATE_TO_GL_7(getTransformFeedbackVarying, GetTransformFeedbackVarying,
1075                  WGC3Duint, WGC3Duint, WGC3Dsizei, WGC3Dsizei *, WGC3Dsizei *,
1076                  WGC3Denum *, WGC3Dchar *)
1077 DELEGATE_TO_GL_2R(getUniformBlockIndex, GetUniformBlockIndex, WGC3Duint,
1078                   const WGC3Dchar *, WGC3Duint)
1079 DELEGATE_TO_GL_4(getUniformIndices, GetUniformIndices, WGC3Duint, WGC3Dsizei,
1080                  const WGC3Dchar *const*, WGC3Duint *)
1081 //DELEGATE_TO_GL_3(getUniformuiv, GetUniformuiv, WGC3Duint, WGC3Dint,
1082 //                 WGC3Duint *)
1083 //DELEGATE_TO_GL_3(getVertexAttribIiv, GetVertexAttribIiv, WGC3Duint,
1084 //                 WGC3Denum, WGC3Dint *)
1085 //DELEGATE_TO_GL_3(getVertexAttribIuiv, GetVertexAttribIuiv, WGC3Duint,
1086 //                 WGC3Denum, WGC3Duint *)
1087 DELEGATE_TO_GL_3(invalidateFramebuffer, InvalidateFramebuffer, WGC3Denum,
1088                  WGC3Dsizei, const WGC3Denum *)
1089 DELEGATE_TO_GL_7(invalidateSubFramebuffer, InvalidateSubFramebuffer, WGC3Denum,
1090                  WGC3Dsizei, const WGC3Denum *, WGC3Dint, WGC3Dint, WGC3Dsizei,
1091                  WGC3Dsizei)
1092 DELEGATE_TO_GL_1R(isSampler, IsSampler, WebGLId, WGC3Dboolean)
1093 WGC3Dboolean WebGraphicsContext3DImpl::isSync(WGC3Dsync sync) {
1094   return gl_->IsSync(reinterpret_cast<GLsync>(sync));
1095 }
1096 DELEGATE_TO_GL_1R(isTransformFeedback, IsTransformFeedback, WGC3Duint,
1097                   WGC3Dboolean)
1098 DELEGATE_TO_GL(pauseTransformFeedback, PauseTransformFeedback)
1099 //DELEGATE_TO_GL_3(programParameteri, ProgramParameteri, WGC3Duint, WGC3Denum,
1100 //                 WGC3Dint)
1101 DELEGATE_TO_GL_1(readBuffer, ReadBuffer, WGC3Denum)
1102 DELEGATE_TO_GL(resumeTransformFeedback, ResumeTransformFeedback)
1103 DELEGATE_TO_GL_3(samplerParameterf, SamplerParameterf, WGC3Duint, WGC3Denum,
1104                  WGC3Dfloat)
1105 DELEGATE_TO_GL_3(samplerParameterfv, SamplerParameterfv, WGC3Duint, WGC3Denum,
1106                  const WGC3Dfloat *)
1107 DELEGATE_TO_GL_3(samplerParameteri, SamplerParameteri, WGC3Duint, WGC3Denum,
1108                  WGC3Dint)
1109 DELEGATE_TO_GL_3(samplerParameteriv, SamplerParameteriv, WGC3Duint, WGC3Denum,
1110                  const WGC3Dint *)
1111 DELEGATE_TO_GL_10(texImage3D, TexImage3D, WGC3Denum, WGC3Dint, WGC3Dint,
1112                   WGC3Dsizei, WGC3Dsizei, WGC3Dsizei, WGC3Dint, WGC3Denum,
1113                   WGC3Denum, const void *)
1114 DELEGATE_TO_GL_6(texStorage3D, TexStorage3D, WGC3Denum, WGC3Dsizei, WGC3Denum,
1115                  WGC3Dsizei, WGC3Dsizei, WGC3Dsizei)
1116 DELEGATE_TO_GL_11(texSubImage3D, TexSubImage3D, WGC3Denum, WGC3Dint, WGC3Dint,
1117                   WGC3Dint, WGC3Dint, WGC3Dsizei, WGC3Dsizei, WGC3Dsizei,
1118                   WGC3Denum, WGC3Denum, const void *)
1119 DELEGATE_TO_GL_4(transformFeedbackVaryings, TransformFeedbackVaryings,
1120                  WGC3Duint, WGC3Dsizei, const WGC3Dchar *const*, WGC3Denum)
1121 DELEGATE_TO_GL_2(uniform1ui, Uniform1ui, WGC3Dint, WGC3Duint)
1122 DELEGATE_TO_GL_3(uniform1uiv, Uniform1uiv, WGC3Dint, WGC3Dsizei,
1123                  const WGC3Duint *)
1124 DELEGATE_TO_GL_3(uniform2ui, Uniform2ui, WGC3Dint, WGC3Duint, WGC3Duint)
1125 DELEGATE_TO_GL_3(uniform2uiv, Uniform2uiv, WGC3Dint, WGC3Dsizei,
1126                  const WGC3Duint *)
1127 DELEGATE_TO_GL_4(uniform3ui, Uniform3ui, WGC3Dint, WGC3Duint, WGC3Duint,
1128                  WGC3Duint)
1129 DELEGATE_TO_GL_3(uniform3uiv, Uniform3uiv, WGC3Dint, WGC3Dsizei,
1130                  const WGC3Duint *)
1131 DELEGATE_TO_GL_5(uniform4ui, Uniform4ui, WGC3Dint, WGC3Duint, WGC3Duint,
1132                  WGC3Duint, WGC3Duint)
1133 DELEGATE_TO_GL_3(uniform4uiv, Uniform4uiv, WGC3Dint, WGC3Dsizei,
1134                  const WGC3Duint *)
1135 DELEGATE_TO_GL_3(uniformBlockBinding, UniformBlockBinding, WGC3Duint, WGC3Duint,
1136                  WGC3Duint)
1137 DELEGATE_TO_GL_4(uniformMatrix2x3fv, UniformMatrix2x3fv, WGC3Dint, WGC3Dsizei,
1138                  WGC3Dboolean, const WGC3Dfloat*)
1139 DELEGATE_TO_GL_4(uniformMatrix2x4fv, UniformMatrix2x4fv, WGC3Dint, WGC3Dsizei,
1140                  WGC3Dboolean, const WGC3Dfloat*)
1141 DELEGATE_TO_GL_4(uniformMatrix3x2fv, UniformMatrix3x2fv, WGC3Dint, WGC3Dsizei,
1142                  WGC3Dboolean, const WGC3Dfloat*)
1143 DELEGATE_TO_GL_4(uniformMatrix3x4fv, UniformMatrix3x4fv, WGC3Dint, WGC3Dsizei,
1144                  WGC3Dboolean, const WGC3Dfloat*)
1145 DELEGATE_TO_GL_4(uniformMatrix4x2fv, UniformMatrix4x2fv, WGC3Dint, WGC3Dsizei,
1146                  WGC3Dboolean, const WGC3Dfloat*)
1147 DELEGATE_TO_GL_4(uniformMatrix4x3fv, UniformMatrix4x3fv, WGC3Dint, WGC3Dsizei,
1148                  WGC3Dboolean, const WGC3Dfloat*)
1149 DELEGATE_TO_GL_5(vertexAttribI4i, VertexAttribI4i, WGC3Duint, WGC3Dint,
1150                  WGC3Dint, WGC3Dint, WGC3Dint)
1151 DELEGATE_TO_GL_2(vertexAttribI4iv, VertexAttribI4iv, WGC3Duint,
1152                  const WGC3Dint *)
1153 DELEGATE_TO_GL_5(vertexAttribI4ui, VertexAttribI4ui, WGC3Duint, WGC3Duint,
1154                  WGC3Duint, WGC3Duint, WGC3Duint)
1155 DELEGATE_TO_GL_2(vertexAttribI4uiv, VertexAttribI4uiv, WGC3Duint,
1156                  const WGC3Duint *)
1157 void WebGraphicsContext3DImpl::vertexAttribIPointer(
1158     WGC3Duint index, WGC3Dint size, WGC3Denum type, WGC3Dsizei stride,
1159     WGC3Dintptr offset) {
1160   gl_->VertexAttribIPointer(
1161       index, size, type, stride,
1162       reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
1163 }
1164 void WebGraphicsContext3DImpl::waitSync(WGC3Dsync sync,
1165                                         WGC3Dbitfield flags,
1166                                         WGC3Duint64 timeout) {
1167   gl_->WaitSync(reinterpret_cast<GLsync>(sync), flags, timeout);
1168 }
1169
1170 GrGLInterface* WebGraphicsContext3DImpl::createGrGLInterface() {
1171   return skia_bindings::CreateCommandBufferSkiaGLBinding();
1172 }
1173
1174 ::gpu::gles2::GLES2ImplementationErrorMessageCallback*
1175     WebGraphicsContext3DImpl::getErrorMessageCallback() {
1176   if (!client_error_message_callback_) {
1177     client_error_message_callback_.reset(
1178         new WebGraphicsContext3DErrorMessageCallback(this));
1179   }
1180   return client_error_message_callback_.get();
1181 }
1182
1183 void WebGraphicsContext3DImpl::OnErrorMessage(
1184     const std::string& message, int id) {
1185   if (error_message_callback_) {
1186     blink::WebString str = blink::WebString::fromUTF8(message.c_str());
1187     error_message_callback_->onErrorMessage(str, id);
1188   }
1189 }
1190
1191 // TODO(bajones): Look into removing these functions from the blink interface
1192 void WebGraphicsContext3DImpl::prepareTexture() {
1193   NOTREACHED();
1194 }
1195
1196 void WebGraphicsContext3DImpl::postSubBufferCHROMIUM(
1197     int x, int y, int width, int height) {
1198   NOTREACHED();
1199 }
1200
1201 void WebGraphicsContext3DImpl::setVisibilityCHROMIUM(
1202     bool visible) {
1203   NOTREACHED();
1204 }
1205
1206 void WebGraphicsContext3DImpl::copyTextureToParentTextureCHROMIUM(
1207     WebGLId texture, WebGLId parentTexture) {
1208   NOTIMPLEMENTED();
1209 }
1210
1211 void WebGraphicsContext3DImpl::releaseShaderCompiler() {
1212 }
1213
1214 // static
1215 void WebGraphicsContext3DImpl::ConvertAttributes(
1216     const blink::WebGraphicsContext3D::Attributes& attributes,
1217     ::gpu::gles2::ContextCreationAttribHelper* output_attribs) {
1218   output_attribs->alpha_size = attributes.alpha ? 8 : 0;
1219   output_attribs->depth_size = attributes.depth ? 24 : 0;
1220   output_attribs->stencil_size = attributes.stencil ? 8 : 0;
1221   output_attribs->samples = attributes.antialias ? 4 : 0;
1222   output_attribs->sample_buffers = attributes.antialias ? 1 : 0;
1223   output_attribs->fail_if_major_perf_caveat =
1224       attributes.failIfMajorPerformanceCaveat;
1225   output_attribs->bind_generates_resource = false;
1226   output_attribs->es3_context_required =
1227       (attributes.webGL && attributes.webGLVersion == 2);
1228 }
1229
1230 }  // namespace gpu_blink