gpu/blink/webgraphicscontext3d_impl.h

   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 #ifndef GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_
   6 #define GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "gpu/blink/gpu_blink_export.h"
  14 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
  15 #include "third_party/WebKit/public/platform/WebString.h"
  16
  17 namespace gpu {
  18
  19 namespace gles2 {
  20 class GLES2Interface;
  21 class GLES2ImplementationErrorMessageCallback;
  22 struct ContextCreationAttribHelper;
  23 }
  24 }
  25
  26 namespace gpu_blink {
  27
  28 class WebGraphicsContext3DErrorMessageCallback;
  29
  30 class GPU_BLINK_EXPORT WebGraphicsContext3DImpl
  31     : public NON_EXPORTED_BASE(blink::WebGraphicsContext3D) {
  32  public:
  33   virtual ~WebGraphicsContext3DImpl();
  34
  35   //----------------------------------------------------------------------
  36   // WebGraphicsContext3D methods
  37
  38   virtual uint32_t lastFlushID();
  39
  40   virtual unsigned int insertSyncPoint();
  41   virtual void waitSyncPoint(unsigned int sync_point);
  42
  43   virtual void loseContextCHROMIUM(blink::WGC3Denum current,
  44                                    blink::WGC3Denum other);
  45
  46   virtual void reshapeWithScaleFactor(
  47       int width, int height, float scale_factor);
  48
  49   virtual void prepareTexture();
  50   virtual void postSubBufferCHROMIUM(int x, int y, int width, int height);
  51
  52   virtual void activeTexture(blink::WGC3Denum texture);
  53   virtual void attachShader(blink::WebGLId program, blink::WebGLId shader);
  54   virtual void bindAttribLocation(blink::WebGLId program,
  55                                   blink::WGC3Duint index,
  56                                   const blink::WGC3Dchar* name);
  57   virtual void bindBuffer(blink::WGC3Denum target, blink::WebGLId buffer);
  58   virtual void bindFramebuffer(blink::WGC3Denum target,
  59                                blink::WebGLId framebuffer);
  60   virtual void bindRenderbuffer(blink::WGC3Denum target,
  61                                 blink::WebGLId renderbuffer);
  62   virtual void bindTexture(blink::WGC3Denum target, blink::WebGLId texture);
  63   virtual void blendColor(blink::WGC3Dclampf red,
  64                           blink::WGC3Dclampf green,
  65                           blink::WGC3Dclampf blue,
  66                           blink::WGC3Dclampf alpha);
  67   virtual void blendEquation(blink::WGC3Denum mode);
  68   virtual void blendEquationSeparate(blink::WGC3Denum modeRGB,
  69                                      blink::WGC3Denum modeAlpha);
  70   virtual void blendFunc(blink::WGC3Denum sfactor, blink::WGC3Denum dfactor);
  71   virtual void blendFuncSeparate(blink::WGC3Denum srcRGB,
  72                                  blink::WGC3Denum dstRGB,
  73                                  blink::WGC3Denum srcAlpha,
  74                                  blink::WGC3Denum dstAlpha);
  75
  76   virtual void bufferData(blink::WGC3Denum target,
  77                           blink::WGC3Dsizeiptr size,
  78                           const void* data,
  79                           blink::WGC3Denum usage);
  80   virtual void bufferSubData(blink::WGC3Denum target,
  81                              blink::WGC3Dintptr offset,
  82                              blink::WGC3Dsizeiptr size,
  83                              const void* data);
  84
  85   virtual blink::WGC3Denum checkFramebufferStatus(blink::WGC3Denum target);
  86   virtual void clear(blink::WGC3Dbitfield mask);
  87   virtual void clearColor(blink::WGC3Dclampf red,
  88                           blink::WGC3Dclampf green,
  89                           blink::WGC3Dclampf blue,
  90                           blink::WGC3Dclampf alpha);
  91   virtual void clearDepth(blink::WGC3Dclampf depth);
  92   virtual void clearStencil(blink::WGC3Dint s);
  93   virtual void colorMask(blink::WGC3Dboolean red,
  94                          blink::WGC3Dboolean green,
  95                          blink::WGC3Dboolean blue,
  96                          blink::WGC3Dboolean alpha);
  97   virtual void compileShader(blink::WebGLId shader);
  98
  99   virtual void compressedTexImage2D(blink::WGC3Denum target,
 100                                     blink::WGC3Dint level,
 101                                     blink::WGC3Denum internalformat,
 102                                     blink::WGC3Dsizei width,
 103                                     blink::WGC3Dsizei height,
 104                                     blink::WGC3Dint border,
 105                                     blink::WGC3Dsizei imageSize,
 106                                     const void* data);
 107   virtual void compressedTexSubImage2D(blink::WGC3Denum target,
 108                                        blink::WGC3Dint level,
 109                                        blink::WGC3Dint xoffset,
 110                                        blink::WGC3Dint yoffset,
 111                                        blink::WGC3Dsizei width,
 112                                        blink::WGC3Dsizei height,
 113                                        blink::WGC3Denum format,
 114                                        blink::WGC3Dsizei imageSize,
 115                                        const void* data);
 116   virtual void copyTexImage2D(blink::WGC3Denum target,
 117                               blink::WGC3Dint level,
 118                               blink::WGC3Denum internalformat,
 119                               blink::WGC3Dint x,
 120                               blink::WGC3Dint y,
 121                               blink::WGC3Dsizei width,
 122                               blink::WGC3Dsizei height,
 123                               blink::WGC3Dint border);
 124   virtual void copyTexSubImage2D(blink::WGC3Denum target,
 125                                  blink::WGC3Dint level,
 126                                  blink::WGC3Dint xoffset,
 127                                  blink::WGC3Dint yoffset,
 128                                  blink::WGC3Dint x,
 129                                  blink::WGC3Dint y,
 130                                  blink::WGC3Dsizei width,
 131                                  blink::WGC3Dsizei height);
 132   virtual void cullFace(blink::WGC3Denum mode);
 133   virtual void depthFunc(blink::WGC3Denum func);
 134   virtual void depthMask(blink::WGC3Dboolean flag);
 135   virtual void depthRange(blink::WGC3Dclampf zNear, blink::WGC3Dclampf zFar);
 136   virtual void detachShader(blink::WebGLId program, blink::WebGLId shader);
 137   virtual void disable(blink::WGC3Denum cap);
 138   virtual void disableVertexAttribArray(blink::WGC3Duint index);
 139   virtual void drawArrays(blink::WGC3Denum mode,
 140                           blink::WGC3Dint first,
 141                           blink::WGC3Dsizei count);
 142   virtual void drawElements(blink::WGC3Denum mode,
 143                             blink::WGC3Dsizei count,
 144                             blink::WGC3Denum type,
 145                             blink::WGC3Dintptr offset);
 146
 147   virtual void enable(blink::WGC3Denum cap);
 148   virtual void enableVertexAttribArray(blink::WGC3Duint index);
 149   virtual void finish();
 150   virtual void flush();
 151   virtual void framebufferRenderbuffer(blink::WGC3Denum target,
 152                                        blink::WGC3Denum attachment,
 153                                        blink::WGC3Denum renderbuffertarget,
 154                                        blink::WebGLId renderbuffer);
 155   virtual void framebufferTexture2D(blink::WGC3Denum target,
 156                                     blink::WGC3Denum attachment,
 157                                     blink::WGC3Denum textarget,
 158                                     blink::WebGLId texture,
 159                                     blink::WGC3Dint level);
 160   virtual void frontFace(blink::WGC3Denum mode);
 161   virtual void generateMipmap(blink::WGC3Denum target);
 162
 163   virtual bool getActiveAttrib(blink::WebGLId program,
 164                                blink::WGC3Duint index,
 165                                ActiveInfo&);
 166   virtual bool getActiveUniform(blink::WebGLId program,
 167                                 blink::WGC3Duint index,
 168                                 ActiveInfo&);
 169
 170   virtual void getAttachedShaders(blink::WebGLId program,
 171                                   blink::WGC3Dsizei maxCount,
 172                                   blink::WGC3Dsizei* count,
 173                                   blink::WebGLId* shaders);
 174
 175   virtual blink::WGC3Dint getAttribLocation(blink::WebGLId program,
 176                                             const blink::WGC3Dchar* name);
 177
 178   virtual void getBooleanv(blink::WGC3Denum pname, blink::WGC3Dboolean* value);
 179
 180   virtual void getBufferParameteriv(blink::WGC3Denum target,
 181                                     blink::WGC3Denum pname,
 182                                     blink::WGC3Dint* value);
 183
 184   virtual blink::WGC3Denum getError();
 185
 186   virtual void getFloatv(blink::WGC3Denum pname, blink::WGC3Dfloat* value);
 187
 188   virtual void getFramebufferAttachmentParameteriv(blink::WGC3Denum target,
 189                                                    blink::WGC3Denum attachment,
 190                                                    blink::WGC3Denum pname,
 191                                                    blink::WGC3Dint* value);
 192
 193   virtual void getIntegerv(blink::WGC3Denum pname, blink::WGC3Dint* value);
 194
 195   virtual void getInteger64v(blink::WGC3Denum pname, blink::WGC3Dint64* value);
 196
 197   virtual void getProgramiv(blink::WebGLId program,
 198                             blink::WGC3Denum pname,
 199                             blink::WGC3Dint* value);
 200
 201   virtual blink::WebString getProgramInfoLog(blink::WebGLId program);
 202
 203   virtual void getRenderbufferParameteriv(blink::WGC3Denum target,
 204                                           blink::WGC3Denum pname,
 205                                           blink::WGC3Dint* value);
 206
 207   virtual void getShaderiv(blink::WebGLId shader,
 208                            blink::WGC3Denum pname,
 209                            blink::WGC3Dint* value);
 210
 211   virtual blink::WebString getShaderInfoLog(blink::WebGLId shader);
 212
 213   virtual void getShaderPrecisionFormat(blink::WGC3Denum shadertype,
 214                                         blink::WGC3Denum precisiontype,
 215                                         blink::WGC3Dint* range,
 216                                         blink::WGC3Dint* precision);
 217
 218   virtual blink::WebString getShaderSource(blink::WebGLId shader);
 219   virtual blink::WebString getString(blink::WGC3Denum name);
 220
 221   virtual void getTexParameterfv(blink::WGC3Denum target,
 222                                  blink::WGC3Denum pname,
 223                                  blink::WGC3Dfloat* value);
 224   virtual void getTexParameteriv(blink::WGC3Denum target,
 225                                  blink::WGC3Denum pname,
 226                                  blink::WGC3Dint* value);
 227
 228   virtual void getUniformfv(blink::WebGLId program,
 229                             blink::WGC3Dint location,
 230                             blink::WGC3Dfloat* value);
 231   virtual void getUniformiv(blink::WebGLId program,
 232                             blink::WGC3Dint location,
 233                             blink::WGC3Dint* value);
 234
 235   virtual blink::WGC3Dint getUniformLocation(blink::WebGLId program,
 236                                              const blink::WGC3Dchar* name);
 237
 238   virtual void getVertexAttribfv(blink::WGC3Duint index,
 239                                  blink::WGC3Denum pname,
 240                                  blink::WGC3Dfloat* value);
 241   virtual void getVertexAttribiv(blink::WGC3Duint index,
 242                                  blink::WGC3Denum pname,
 243                                  blink::WGC3Dint* value);
 244
 245   virtual blink::WGC3Dsizeiptr getVertexAttribOffset(blink::WGC3Duint index,
 246                                                      blink::WGC3Denum pname);
 247
 248   virtual void hint(blink::WGC3Denum target, blink::WGC3Denum mode);
 249   virtual blink::WGC3Dboolean isBuffer(blink::WebGLId buffer);
 250   virtual blink::WGC3Dboolean isEnabled(blink::WGC3Denum cap);
 251   virtual blink::WGC3Dboolean isFramebuffer(blink::WebGLId framebuffer);
 252   virtual blink::WGC3Dboolean isProgram(blink::WebGLId program);
 253   virtual blink::WGC3Dboolean isRenderbuffer(blink::WebGLId renderbuffer);
 254   virtual blink::WGC3Dboolean isShader(blink::WebGLId shader);
 255   virtual blink::WGC3Dboolean isTexture(blink::WebGLId texture);
 256   virtual void lineWidth(blink::WGC3Dfloat);
 257   virtual void linkProgram(blink::WebGLId program);
 258   virtual void pixelStorei(blink::WGC3Denum pname, blink::WGC3Dint param);
 259   virtual void polygonOffset(blink::WGC3Dfloat factor, blink::WGC3Dfloat units);
 260
 261   virtual void readPixels(blink::WGC3Dint x,
 262                           blink::WGC3Dint y,
 263                           blink::WGC3Dsizei width,
 264                           blink::WGC3Dsizei height,
 265                           blink::WGC3Denum format,
 266                           blink::WGC3Denum type,
 267                           void* pixels);
 268
 269   virtual void releaseShaderCompiler();
 270   virtual void renderbufferStorage(blink::WGC3Denum target,
 271                                    blink::WGC3Denum internalformat,
 272                                    blink::WGC3Dsizei width,
 273                                    blink::WGC3Dsizei height);
 274   virtual void sampleCoverage(blink::WGC3Dfloat value,
 275                               blink::WGC3Dboolean invert);
 276   virtual void scissor(blink::WGC3Dint x,
 277                        blink::WGC3Dint y,
 278                        blink::WGC3Dsizei width,
 279                        blink::WGC3Dsizei height);
 280   virtual void shaderSource(blink::WebGLId shader,
 281                             const blink::WGC3Dchar* string);
 282   virtual void stencilFunc(blink::WGC3Denum func,
 283                            blink::WGC3Dint ref,
 284                            blink::WGC3Duint mask);
 285   virtual void stencilFuncSeparate(blink::WGC3Denum face,
 286                                    blink::WGC3Denum func,
 287                                    blink::WGC3Dint ref,
 288                                    blink::WGC3Duint mask);
 289   virtual void stencilMask(blink::WGC3Duint mask);
 290   virtual void stencilMaskSeparate(blink::WGC3Denum face,
 291                                    blink::WGC3Duint mask);
 292   virtual void stencilOp(blink::WGC3Denum fail,
 293                          blink::WGC3Denum zfail,
 294                          blink::WGC3Denum zpass);
 295   virtual void stencilOpSeparate(blink::WGC3Denum face,
 296                                  blink::WGC3Denum fail,
 297                                  blink::WGC3Denum zfail,
 298                                  blink::WGC3Denum zpass);
 299
 300   virtual void texImage2D(blink::WGC3Denum target,
 301                           blink::WGC3Dint level,
 302                           blink::WGC3Denum internalformat,
 303                           blink::WGC3Dsizei width,
 304                           blink::WGC3Dsizei height,
 305                           blink::WGC3Dint border,
 306                           blink::WGC3Denum format,
 307                           blink::WGC3Denum type,
 308                           const void* pixels);
 309
 310   virtual void texParameterf(blink::WGC3Denum target,
 311                              blink::WGC3Denum pname,
 312                              blink::WGC3Dfloat param);
 313   virtual void texParameteri(blink::WGC3Denum target,
 314                              blink::WGC3Denum pname,
 315                              blink::WGC3Dint param);
 316
 317   virtual void texSubImage2D(blink::WGC3Denum target,
 318                              blink::WGC3Dint level,
 319                              blink::WGC3Dint xoffset,
 320                              blink::WGC3Dint yoffset,
 321                              blink::WGC3Dsizei width,
 322                              blink::WGC3Dsizei height,
 323                              blink::WGC3Denum format,
 324                              blink::WGC3Denum type,
 325                              const void* pixels);
 326
 327   virtual void uniform1f(blink::WGC3Dint location, blink::WGC3Dfloat x);
 328   virtual void uniform1fv(blink::WGC3Dint location,
 329                           blink::WGC3Dsizei count,
 330                           const blink::WGC3Dfloat* v);
 331   virtual void uniform1i(blink::WGC3Dint location, blink::WGC3Dint x);
 332   virtual void uniform1iv(blink::WGC3Dint location,
 333                           blink::WGC3Dsizei count,
 334                           const blink::WGC3Dint* v);
 335   virtual void uniform2f(blink::WGC3Dint location,
 336                          blink::WGC3Dfloat x,
 337                          blink::WGC3Dfloat y);
 338   virtual void uniform2fv(blink::WGC3Dint location,
 339                           blink::WGC3Dsizei count,
 340                           const blink::WGC3Dfloat* v);
 341   virtual void uniform2i(blink::WGC3Dint location,
 342                          blink::WGC3Dint x,
 343                          blink::WGC3Dint y);
 344   virtual void uniform2iv(blink::WGC3Dint location,
 345                           blink::WGC3Dsizei count,
 346                           const blink::WGC3Dint* v);
 347   virtual void uniform3f(blink::WGC3Dint location,
 348                          blink::WGC3Dfloat x,
 349                          blink::WGC3Dfloat y,
 350                          blink::WGC3Dfloat z);
 351   virtual void uniform3fv(blink::WGC3Dint location,
 352                           blink::WGC3Dsizei count,
 353                           const blink::WGC3Dfloat* v);
 354   virtual void uniform3i(blink::WGC3Dint location,
 355                          blink::WGC3Dint x,
 356                          blink::WGC3Dint y,
 357                          blink::WGC3Dint z);
 358   virtual void uniform3iv(blink::WGC3Dint location,
 359                           blink::WGC3Dsizei count,
 360                           const blink::WGC3Dint* v);
 361   virtual void uniform4f(blink::WGC3Dint location,
 362                          blink::WGC3Dfloat x,
 363                          blink::WGC3Dfloat y,
 364                          blink::WGC3Dfloat z,
 365                          blink::WGC3Dfloat w);
 366   virtual void uniform4fv(blink::WGC3Dint location,
 367                           blink::WGC3Dsizei count,
 368                           const blink::WGC3Dfloat* v);
 369   virtual void uniform4i(blink::WGC3Dint location,
 370                          blink::WGC3Dint x,
 371                          blink::WGC3Dint y,
 372                          blink::WGC3Dint z,
 373                          blink::WGC3Dint w);
 374   virtual void uniform4iv(blink::WGC3Dint location,
 375                           blink::WGC3Dsizei count,
 376                           const blink::WGC3Dint* v);
 377   virtual void uniformMatrix2fv(blink::WGC3Dint location,
 378                                 blink::WGC3Dsizei count,
 379                                 blink::WGC3Dboolean transpose,
 380                                 const blink::WGC3Dfloat* value);
 381   virtual void uniformMatrix3fv(blink::WGC3Dint location,
 382                                 blink::WGC3Dsizei count,
 383                                 blink::WGC3Dboolean transpose,
 384                                 const blink::WGC3Dfloat* value);
 385   virtual void uniformMatrix4fv(blink::WGC3Dint location,
 386                                 blink::WGC3Dsizei count,
 387                                 blink::WGC3Dboolean transpose,
 388                                 const blink::WGC3Dfloat* value);
 389
 390   virtual void useProgram(blink::WebGLId program);
 391   virtual void validateProgram(blink::WebGLId program);
 392
 393   virtual void vertexAttrib1f(blink::WGC3Duint index, blink::WGC3Dfloat x);
 394   virtual void vertexAttrib1fv(blink::WGC3Duint index,
 395                                const blink::WGC3Dfloat* values);
 396   virtual void vertexAttrib2f(blink::WGC3Duint index,
 397                               blink::WGC3Dfloat x,
 398                               blink::WGC3Dfloat y);
 399   virtual void vertexAttrib2fv(blink::WGC3Duint index,
 400                                const blink::WGC3Dfloat* values);
 401   virtual void vertexAttrib3f(blink::WGC3Duint index,
 402                               blink::WGC3Dfloat x,
 403                               blink::WGC3Dfloat y,
 404                               blink::WGC3Dfloat z);
 405   virtual void vertexAttrib3fv(blink::WGC3Duint index,
 406                                const blink::WGC3Dfloat* values);
 407   virtual void vertexAttrib4f(blink::WGC3Duint index,
 408                               blink::WGC3Dfloat x,
 409                               blink::WGC3Dfloat y,
 410                               blink::WGC3Dfloat z,
 411                               blink::WGC3Dfloat w);
 412   virtual void vertexAttrib4fv(blink::WGC3Duint index,
 413                                const blink::WGC3Dfloat* values);
 414   virtual void vertexAttribPointer(blink::WGC3Duint index,
 415                                    blink::WGC3Dint size,
 416                                    blink::WGC3Denum type,
 417                                    blink::WGC3Dboolean normalized,
 418                                    blink::WGC3Dsizei stride,
 419                                    blink::WGC3Dintptr offset);
 420
 421   virtual void viewport(blink::WGC3Dint x,
 422                         blink::WGC3Dint y,
 423                         blink::WGC3Dsizei width,
 424                         blink::WGC3Dsizei height);
 425
 426   virtual blink::WebGLId createBuffer();
 427   virtual blink::WebGLId createFramebuffer();
 428   virtual blink::WebGLId createRenderbuffer();
 429   virtual blink::WebGLId createTexture();
 430
 431   virtual void deleteBuffer(blink::WebGLId);
 432   virtual void deleteFramebuffer(blink::WebGLId);
 433   virtual void deleteRenderbuffer(blink::WebGLId);
 434   virtual void deleteTexture(blink::WebGLId);
 435
 436   virtual blink::WebGLId createProgram();
 437   virtual blink::WebGLId createShader(blink::WGC3Denum);
 438
 439   virtual void deleteProgram(blink::WebGLId);
 440   virtual void deleteShader(blink::WebGLId);
 441
 442   virtual void synthesizeGLError(blink::WGC3Denum);
 443
 444   virtual void* mapBufferSubDataCHROMIUM(blink::WGC3Denum target,
 445                                          blink::WGC3Dintptr offset,
 446                                          blink::WGC3Dsizeiptr size,
 447                                          blink::WGC3Denum access);
 448   virtual void unmapBufferSubDataCHROMIUM(const void*);
 449   virtual void* mapTexSubImage2DCHROMIUM(blink::WGC3Denum target,
 450                                          blink::WGC3Dint level,
 451                                          blink::WGC3Dint xoffset,
 452                                          blink::WGC3Dint yoffset,
 453                                          blink::WGC3Dsizei width,
 454                                          blink::WGC3Dsizei height,
 455                                          blink::WGC3Denum format,
 456                                          blink::WGC3Denum type,
 457                                          blink::WGC3Denum access);
 458   virtual void unmapTexSubImage2DCHROMIUM(const void*);
 459
 460   virtual void setVisibilityCHROMIUM(bool visible);
 461
 462   virtual void discardFramebufferEXT(blink::WGC3Denum target,
 463                                      blink::WGC3Dsizei numAttachments,
 464                                      const blink::WGC3Denum* attachments);
 465   virtual void copyTextureToParentTextureCHROMIUM(blink::WebGLId texture,
 466                                                   blink::WebGLId parentTexture);
 467
 468   virtual blink::WebString getRequestableExtensionsCHROMIUM();
 469   virtual void requestExtensionCHROMIUM(const char*);
 470
 471   virtual void blitFramebufferCHROMIUM(blink::WGC3Dint srcX0,
 472                                        blink::WGC3Dint srcY0,
 473                                        blink::WGC3Dint srcX1,
 474                                        blink::WGC3Dint srcY1,
 475                                        blink::WGC3Dint dstX0,
 476                                        blink::WGC3Dint dstY0,
 477                                        blink::WGC3Dint dstX1,
 478                                        blink::WGC3Dint dstY1,
 479                                        blink::WGC3Dbitfield mask,
 480                                        blink::WGC3Denum filter);
 481   virtual void renderbufferStorageMultisampleCHROMIUM(
 482       blink::WGC3Denum target,
 483       blink::WGC3Dsizei samples,
 484       blink::WGC3Denum internalformat,
 485       blink::WGC3Dsizei width,
 486       blink::WGC3Dsizei height);
 487
 488   virtual blink::WebString getTranslatedShaderSourceANGLE(
 489       blink::WebGLId shader);
 490
 491   virtual void setContextLostCallback(
 492       WebGraphicsContext3D::WebGraphicsContextLostCallback* callback);
 493
 494   virtual void setErrorMessageCallback(
 495       WebGraphicsContext3D::WebGraphicsErrorMessageCallback* callback);
 496
 497   virtual void texImageIOSurface2DCHROMIUM(blink::WGC3Denum target,
 498                                            blink::WGC3Dint width,
 499                                            blink::WGC3Dint height,
 500                                            blink::WGC3Duint ioSurfaceId,
 501                                            blink::WGC3Duint plane);
 502
 503   virtual void texStorage2DEXT(blink::WGC3Denum target,
 504                                blink::WGC3Dint levels,
 505                                blink::WGC3Duint internalformat,
 506                                blink::WGC3Dint width,
 507                                blink::WGC3Dint height);
 508
 509   virtual blink::WebGLId createQueryEXT();
 510   virtual void deleteQueryEXT(blink::WebGLId query);
 511   virtual blink::WGC3Dboolean isQueryEXT(blink::WGC3Duint query);
 512   virtual void beginQueryEXT(blink::WGC3Denum target, blink::WebGLId query);
 513   virtual void endQueryEXT(blink::WGC3Denum target);
 514   virtual void getQueryivEXT(blink::WGC3Denum target,
 515                              blink::WGC3Denum pname,
 516                              blink::WGC3Dint* params);
 517   virtual void getQueryObjectuivEXT(blink::WebGLId query,
 518                                     blink::WGC3Denum pname,
 519                                     blink::WGC3Duint* params);
 520
 521   // TODO(zmo): Remove the following two functions when blink side switch
 522   // over to the correct version.
 523   void copyTextureCHROMIUM(blink::WGC3Denum target,
 524                            blink::WebGLId source_id,
 525                            blink::WebGLId dest_id,
 526                            blink::WGC3Denum internal_format,
 527                            blink::WGC3Denum dest_type);
 528
 529   void copySubTextureCHROMIUM(blink::WGC3Denum target,
 530                               blink::WebGLId source_id,
 531                               blink::WebGLId dest_id,
 532                               blink::WGC3Dint xoffset,
 533                               blink::WGC3Dint yoffset,
 534                               blink::WGC3Dint x,
 535                               blink::WGC3Dint y,
 536                               blink::WGC3Dsizei width,
 537                               blink::WGC3Dsizei height);
 538
 539   void copyTextureCHROMIUM(
 540       blink::WGC3Denum target,
 541       blink::WebGLId source_id,
 542       blink::WebGLId dest_id,
 543       blink::WGC3Denum internal_format,
 544       blink::WGC3Denum dest_type,
 545       blink::WGC3Dboolean unpack_flip_y,
 546       blink::WGC3Dboolean unpack_premultiply_alpha,
 547       blink::WGC3Dboolean unpack_unmultiply_alpha);
 548
 549   void copySubTextureCHROMIUM(
 550       blink::WGC3Denum target,
 551       blink::WebGLId source_id,
 552       blink::WebGLId dest_id,
 553       blink::WGC3Dint xoffset,
 554       blink::WGC3Dint yoffset,
 555       blink::WGC3Dint x,
 556       blink::WGC3Dint y,
 557       blink::WGC3Dsizei width,
 558       blink::WGC3Dsizei height,
 559       blink::WGC3Dboolean unpack_flip_y,
 560       blink::WGC3Dboolean unpack_premultiply_alpha,
 561       blink::WGC3Dboolean unpack_unmultiply_alpha);
 562
 563   virtual void bindUniformLocationCHROMIUM(blink::WebGLId program,
 564                                            blink::WGC3Dint location,
 565                                            const blink::WGC3Dchar* uniform);
 566
 567   virtual void shallowFlushCHROMIUM();
 568   virtual void shallowFinishCHROMIUM();
 569
 570   virtual void genMailboxCHROMIUM(blink::WGC3Dbyte* mailbox);
 571   virtual void produceTextureCHROMIUM(blink::WGC3Denum target,
 572                                       const blink::WGC3Dbyte* mailbox);
 573   virtual void produceTextureDirectCHROMIUM(blink::WebGLId texture,
 574                                             blink::WGC3Denum target,
 575                                             const blink::WGC3Dbyte* mailbox);
 576   virtual void consumeTextureCHROMIUM(blink::WGC3Denum target,
 577                                       const blink::WGC3Dbyte* mailbox);
 578   virtual blink::WebGLId createAndConsumeTextureCHROMIUM(
 579       blink::WGC3Denum target,
 580       const blink::WGC3Dbyte* mailbox);
 581
 582   virtual void genValuebuffersCHROMIUM(blink::WGC3Dsizei count,
 583                                        blink::WebGLId* ids);
 584   virtual blink::WebGLId createValuebufferCHROMIUM();
 585   virtual void deleteValuebuffersCHROMIUM(blink::WGC3Dsizei count,
 586                                           blink::WebGLId* ids);
 587   virtual void deleteValuebufferCHROMIUM(blink::WebGLId);
 588   virtual void bindValuebufferCHROMIUM(blink::WGC3Denum target,
 589                                        blink::WebGLId valuebuffer);
 590   virtual blink::WGC3Dboolean isValuebufferCHROMIUM(
 591       blink::WebGLId renderbuffer);
 592   virtual void subscribeValueCHROMIUM(blink::WGC3Denum target,
 593                                       blink::WGC3Denum subscription);
 594   virtual void populateSubscribedValuesCHROMIUM(blink::WGC3Denum target);
 595   virtual void uniformValuebufferCHROMIUM(blink::WGC3Dint location,
 596                                           blink::WGC3Denum target,
 597                                           blink::WGC3Denum subscription);
 598   virtual void traceBeginCHROMIUM(const blink::WGC3Dchar* category_name,
 599                                   const blink::WGC3Dchar* trace_name);
 600   virtual void traceEndCHROMIUM();
 601
 602   virtual void insertEventMarkerEXT(const blink::WGC3Dchar* marker);
 603   virtual void pushGroupMarkerEXT(const blink::WGC3Dchar* marker);
 604   virtual void popGroupMarkerEXT();
 605
 606   // GL_OES_vertex_array_object
 607   virtual blink::WebGLId createVertexArrayOES();
 608   virtual void deleteVertexArrayOES(blink::WebGLId array);
 609   virtual blink::WGC3Dboolean isVertexArrayOES(blink::WebGLId array);
 610   virtual void bindVertexArrayOES(blink::WebGLId array);
 611
 612   virtual void bindTexImage2DCHROMIUM(blink::WGC3Denum target,
 613                                       blink::WGC3Dint image_id);
 614   virtual void releaseTexImage2DCHROMIUM(blink::WGC3Denum target,
 615                                          blink::WGC3Dint image_id);
 616
 617   virtual void* mapBufferCHROMIUM(blink::WGC3Denum target,
 618                                   blink::WGC3Denum access);
 619   virtual blink::WGC3Dboolean unmapBufferCHROMIUM(blink::WGC3Denum target);
 620
 621   // Async pixel transfer functions.
 622   virtual void asyncTexImage2DCHROMIUM(blink::WGC3Denum target,
 623                                        blink::WGC3Dint level,
 624                                        blink::WGC3Denum internalformat,
 625                                        blink::WGC3Dsizei width,
 626                                        blink::WGC3Dsizei height,
 627                                        blink::WGC3Dint border,
 628                                        blink::WGC3Denum format,
 629                                        blink::WGC3Denum type,
 630                                        const void* pixels);
 631   virtual void asyncTexSubImage2DCHROMIUM(blink::WGC3Denum target,
 632                                           blink::WGC3Dint level,
 633                                           blink::WGC3Dint xoffset,
 634                                           blink::WGC3Dint yoffset,
 635                                           blink::WGC3Dsizei width,
 636                                           blink::WGC3Dsizei height,
 637                                           blink::WGC3Denum format,
 638                                           blink::WGC3Denum type,
 639                                           const void* pixels);
 640   virtual void waitAsyncTexImage2DCHROMIUM(blink::WGC3Denum target);
 641
 642   // GL_EXT_draw_buffers
 643   virtual void drawBuffersEXT(blink::WGC3Dsizei n,
 644                               const blink::WGC3Denum* bufs);
 645
 646   // GL_ANGLE_instanced_arrays
 647   virtual void drawArraysInstancedANGLE(blink::WGC3Denum mode,
 648                                         blink::WGC3Dint first,
 649                                         blink::WGC3Dsizei count,
 650                                         blink::WGC3Dsizei primcount);
 651   virtual void drawElementsInstancedANGLE(blink::WGC3Denum mode,
 652                                           blink::WGC3Dsizei count,
 653                                           blink::WGC3Denum type,
 654                                           blink::WGC3Dintptr offset,
 655                                           blink::WGC3Dsizei primcount);
 656   virtual void vertexAttribDivisorANGLE(blink::WGC3Duint index,
 657                                         blink::WGC3Duint divisor);
 658
 659   // GL_CHROMIUM_gpu_memory_buffer_image
 660   virtual blink::WGC3Duint createGpuMemoryBufferImageCHROMIUM(
 661       blink::WGC3Dsizei width,
 662       blink::WGC3Dsizei height,
 663       blink::WGC3Denum internalformat,
 664       blink::WGC3Denum usage);
 665   virtual void destroyImageCHROMIUM(blink::WGC3Duint image_id);
 666
 667   // GL_EXT_multisampled_render_to_texture
 668   virtual void framebufferTexture2DMultisampleEXT(blink::WGC3Denum target,
 669                                                   blink::WGC3Denum attachment,
 670                                                   blink::WGC3Denum textarget,
 671                                                   blink::WebGLId texture,
 672                                                   blink::WGC3Dint level,
 673                                                   blink::WGC3Dsizei samples);
 674   virtual void renderbufferStorageMultisampleEXT(
 675       blink::WGC3Denum target,
 676       blink::WGC3Dsizei samples,
 677       blink::WGC3Denum internalformat,
 678       blink::WGC3Dsizei width,
 679       blink::WGC3Dsizei height);
 680
 681   // OpenGL ES 3.0 functions not represented by pre-existing extensions
 682   virtual void beginTransformFeedback(blink::WGC3Denum primitiveMode);
 683   virtual void bindBufferBase(blink::WGC3Denum target,
 684                               blink::WGC3Duint index,
 685                               blink::WGC3Duint buffer);
 686   virtual void bindBufferRange(blink::WGC3Denum target,
 687                                blink::WGC3Duint index,
 688                                blink::WGC3Duint buffer,
 689                                blink::WGC3Dintptr offset,
 690                                blink::WGC3Dsizeiptr size);
 691   virtual void bindSampler(blink::WGC3Duint unit, blink::WebGLId sampler);
 692   virtual void bindTransformFeedback(blink::WGC3Denum target,
 693                                      blink::WebGLId transformfeedback);
 694   virtual void clearBufferfi(blink::WGC3Denum buffer,
 695                              blink::WGC3Dint drawbuffer,
 696                              blink::WGC3Dfloat depth,
 697                              blink::WGC3Dint stencil);
 698   virtual void clearBufferfv(blink::WGC3Denum buffer,
 699                              blink::WGC3Dint drawbuffer,
 700                              const blink::WGC3Dfloat* value);
 701   virtual void clearBufferiv(blink::WGC3Denum buffer,
 702                              blink::WGC3Dint drawbuffer,
 703                              const blink::WGC3Dint* value);
 704   virtual void clearBufferuiv(blink::WGC3Denum buffer,
 705                               blink::WGC3Dint drawbuffer,
 706                               const blink::WGC3Duint* value);
 707   virtual blink::WGC3Denum clientWaitSync(blink::WGC3Dsync sync,
 708                                           blink::WGC3Dbitfield flags,
 709                                           blink::WGC3Duint64 timeout);
 710   virtual void compressedTexImage3D(blink::WGC3Denum target,
 711                                     blink::WGC3Dint level,
 712                                     blink::WGC3Denum internalformat,
 713                                     blink::WGC3Dsizei width,
 714                                     blink::WGC3Dsizei height,
 715                                     blink::WGC3Dsizei depth,
 716                                     blink::WGC3Dint border,
 717                                     blink::WGC3Dsizei imageSize,
 718                                     const void *data);
 719   virtual void compressedTexSubImage3D(blink::WGC3Denum target,
 720                                        blink::WGC3Dint level,
 721                                        blink::WGC3Dint xoffset,
 722                                        blink::WGC3Dint yoffset,
 723                                        blink::WGC3Dint zoffset,
 724                                        blink::WGC3Dsizei width,
 725                                        blink::WGC3Dsizei height,
 726                                        blink::WGC3Dsizei depth,
 727                                        blink::WGC3Denum format,
 728                                        blink::WGC3Dsizei imageSize,
 729                                        const void *data);
 730   virtual void copyBufferSubData(blink::WGC3Denum readTarget,
 731                                  blink::WGC3Denum writeTarget,
 732                                  blink::WGC3Dintptr readOffset,
 733                                  blink::WGC3Dintptr writeOffset,
 734                                  blink::WGC3Dsizeiptr size);
 735   virtual void copyTexSubImage3D(blink::WGC3Denum target,
 736                                  blink::WGC3Dint level,
 737                                  blink::WGC3Dint xoffset,
 738                                  blink::WGC3Dint yoffset,
 739                                  blink::WGC3Dint zoffset,
 740                                  blink::WGC3Dint x,
 741                                  blink::WGC3Dint y,
 742                                  blink::WGC3Dsizei width,
 743                                  blink::WGC3Dsizei height);
 744   virtual blink::WebGLId createSampler();
 745   virtual blink::WebGLId createTransformFeedback();
 746   virtual void deleteSampler(blink::WebGLId sampler);
 747   virtual void deleteSync(blink::WGC3Dsync sync);
 748   virtual void deleteTransformFeedback(blink::WebGLId transformfeedback);
 749   virtual void drawRangeElements(blink::WGC3Denum mode,
 750                                  blink::WGC3Duint start,
 751                                  blink::WGC3Duint end,
 752                                  blink::WGC3Dsizei count,
 753                                  blink::WGC3Denum type,
 754                                  blink::WGC3Dintptr offset);
 755   virtual void endTransformFeedback(void);
 756   virtual blink::WGC3Dsync fenceSync(blink::WGC3Denum condition,
 757                                      blink::WGC3Dbitfield flags);
 758   virtual void framebufferTextureLayer(blink::WGC3Denum target,
 759                                        blink::WGC3Denum attachment,
 760                                        blink::WGC3Duint texture,
 761                                        blink::WGC3Dint level,
 762                                        blink::WGC3Dint layer);
 763   virtual void getActiveUniformBlockName(blink::WGC3Duint program,
 764                                          blink::WGC3Duint uniformBlockIndex,
 765                                          blink::WGC3Dsizei bufSize,
 766                                          blink::WGC3Dsizei* length,
 767                                          blink::WGC3Dchar* uniformBlockName);
 768   virtual void getActiveUniformBlockiv(blink::WGC3Duint program,
 769                                        blink::WGC3Duint uniformBlockIndex,
 770                                        blink::WGC3Denum pname,
 771                                        blink::WGC3Dint* params);
 772   virtual void getActiveUniformsiv(blink::WGC3Duint program,
 773                                    blink::WGC3Dsizei uniformCount,
 774                                    const blink::WGC3Duint *uniformIndices,
 775                                    blink::WGC3Denum pname,
 776                                    blink::WGC3Dint *params);
 777   virtual blink::WGC3Dint getFragDataLocation(blink::WGC3Duint program,
 778                                               const blink::WGC3Dchar* name);
 779   virtual void getInternalformativ(blink::WGC3Denum target,
 780                                    blink::WGC3Denum internalformat,
 781                                    blink::WGC3Denum pname,
 782                                    blink::WGC3Dsizei bufSize,
 783                                    blink::WGC3Dint* params);
 784   virtual void getSamplerParameterfv(blink::WGC3Duint sampler,
 785                                      blink::WGC3Denum pname,
 786                                      blink::WGC3Dfloat* params);
 787   virtual void getSamplerParameteriv(blink::WGC3Duint sampler,
 788                                      blink::WGC3Denum pname,
 789                                      blink::WGC3Dint* params);
 790   virtual void getTransformFeedbackVarying(blink::WGC3Duint program,
 791                                            blink::WGC3Duint index,
 792                                            blink::WGC3Dsizei bufSize,
 793                                            blink::WGC3Dsizei *length,
 794                                            blink::WGC3Dsizei *size,
 795                                            blink::WGC3Denum *type,
 796                                            blink::WGC3Dchar *name);
 797   virtual blink::WGC3Duint getUniformBlockIndex(
 798       blink::WGC3Duint program, const blink::WGC3Dchar* uniformBlockName);
 799   virtual void getUniformIndices(blink::WGC3Duint program,
 800                                  blink::WGC3Dsizei uniformCount,
 801                                  const blink::WGC3Dchar *const*uniformNames,
 802                                  blink::WGC3Duint *uniformIndices);
 803   virtual void getUniformuiv(blink::WGC3Duint program,
 804                              blink::WGC3Dint location,
 805                              blink::WGC3Duint *params);
 806   virtual void getVertexAttribIiv(blink::WGC3Duint index,
 807                                   blink::WGC3Denum pname,
 808                                   blink::WGC3Dint *params);
 809   virtual void getVertexAttribIuiv(blink::WGC3Duint index,
 810                                    blink::WGC3Denum pname,
 811                                    blink::WGC3Duint *params);
 812   virtual void invalidateFramebuffer(blink::WGC3Denum target,
 813                                      blink::WGC3Dsizei numAttachments,
 814                                      const blink::WGC3Denum* attachments);
 815   virtual void invalidateSubFramebuffer(blink::WGC3Denum target,
 816                                         blink::WGC3Dsizei numAttachments,
 817                                         const blink::WGC3Denum* attachments,
 818                                         blink::WGC3Dint x,
 819                                         blink::WGC3Dint y,
 820                                         blink::WGC3Dsizei width,
 821                                         blink::WGC3Dsizei height);
 822   virtual blink::WGC3Dboolean isSampler(blink::WebGLId sampler);
 823   virtual blink::WGC3Dboolean isSync(blink::WGC3Dsync sync);
 824   virtual blink::WGC3Dboolean isTransformFeedback(blink::WGC3Duint id);
 825   virtual void* mapBufferRange(blink::WGC3Denum target,
 826                                blink::WGC3Dintptr offset,
 827                                blink::WGC3Dsizeiptr length,
 828                                blink::WGC3Dbitfield access);
 829   virtual void pauseTransformFeedback(void);
 830   //virtual void programParameteri(blink::WGC3Duint program,
 831   //                               blink::WGC3Denum pname,
 832   //                               blink::WGC3Dint value);
 833   virtual void readBuffer(blink::WGC3Denum src);
 834   virtual void resumeTransformFeedback(void);
 835   virtual void samplerParameterf(blink::WGC3Duint sampler,
 836                                  blink::WGC3Denum pname,
 837                                  blink::WGC3Dfloat param);
 838   virtual void samplerParameterfv(blink::WGC3Duint sampler,
 839                                   blink::WGC3Denum pname,
 840                                   const blink::WGC3Dfloat* param);
 841   virtual void samplerParameteri(blink::WGC3Duint sampler,
 842                                  blink::WGC3Denum pname,
 843                                  blink::WGC3Dint param);
 844   virtual void samplerParameteriv(blink::WGC3Duint sampler,
 845                                   blink::WGC3Denum pname,
 846                                   const blink::WGC3Dint* param);
 847   virtual void texImage3D(blink::WGC3Denum target,
 848                           blink::WGC3Dint level,
 849                           blink::WGC3Dint internalformat,
 850                           blink::WGC3Dsizei width,
 851                           blink::WGC3Dsizei height,
 852                           blink::WGC3Dsizei depth,
 853                           blink::WGC3Dint border,
 854                           blink::WGC3Denum format,
 855                           blink::WGC3Denum type,
 856                           const void* pixels);
 857   virtual void texStorage3D(blink::WGC3Denum target,
 858                             blink::WGC3Dsizei levels,
 859                             blink::WGC3Denum internalformat,
 860                             blink::WGC3Dsizei width,
 861                             blink::WGC3Dsizei height,
 862                             blink::WGC3Dsizei depth);
 863   virtual void texSubImage3D(blink::WGC3Denum target,
 864                              blink::WGC3Dint level,
 865                              blink::WGC3Dint xoffset,
 866                              blink::WGC3Dint yoffset,
 867                              blink::WGC3Dint zoffset,
 868                              blink::WGC3Dsizei width,
 869                              blink::WGC3Dsizei height,
 870                              blink::WGC3Dsizei depth,
 871                              blink::WGC3Denum format,
 872                              blink::WGC3Denum type,
 873                              const void* pixels);
 874   virtual void transformFeedbackVaryings(
 875       blink::WGC3Duint program,
 876       blink::WGC3Dsizei count,
 877       const blink::WGC3Dchar* const* varyings,
 878       blink::WGC3Denum bufferMode);
 879   virtual void uniform1ui(blink::WGC3Dint location, blink::WGC3Duint x);
 880   virtual void uniform1uiv(blink::WGC3Dint location,
 881                            blink::WGC3Dsizei count,
 882                            const blink::WGC3Duint* value);
 883   virtual void uniform2ui(blink::WGC3Dint location,
 884                           blink::WGC3Duint x,
 885                           blink::WGC3Duint y);
 886   virtual void uniform2uiv(blink::WGC3Dint location,
 887                            blink::WGC3Dsizei count,
 888                            const blink::WGC3Duint* value);
 889   virtual void uniform3ui(blink::WGC3Dint location,
 890                           blink::WGC3Duint x,
 891                           blink::WGC3Duint y,
 892                           blink::WGC3Duint z);
 893   virtual void uniform3uiv(blink::WGC3Dint location,
 894                            blink::WGC3Dsizei count,
 895                            const blink::WGC3Duint* value);
 896   virtual void uniform4ui(blink::WGC3Dint location,
 897                           blink::WGC3Duint x,
 898                           blink::WGC3Duint y,
 899                           blink::WGC3Duint z,
 900                           blink::WGC3Duint w);
 901   virtual void uniform4uiv(blink::WGC3Dint location,
 902                            blink::WGC3Dsizei count,
 903                            const blink::WGC3Duint* value);
 904   virtual void uniformBlockBinding(blink::WGC3Duint program,
 905                                    blink::WGC3Duint uniformBlockIndex,
 906                                    blink::WGC3Duint uniformBlockBinding);
 907   virtual void uniformMatrix2x3fv(blink::WGC3Dint location,
 908                                   blink::WGC3Dsizei count,
 909                                   blink::WGC3Dboolean transpose,
 910                                   const blink::WGC3Dfloat* value);
 911   virtual void uniformMatrix2x4fv(blink::WGC3Dint location,
 912                                   blink::WGC3Dsizei count,
 913                                   blink::WGC3Dboolean transpose,
 914                                   const blink::WGC3Dfloat* value);
 915   virtual void uniformMatrix3x2fv(blink::WGC3Dint location,
 916                                   blink::WGC3Dsizei count,
 917                                   blink::WGC3Dboolean transpose,
 918                                   const blink::WGC3Dfloat* value);
 919   virtual void uniformMatrix3x4fv(blink::WGC3Dint location,
 920                                   blink::WGC3Dsizei count,
 921                                   blink::WGC3Dboolean transpose,
 922                                   const blink::WGC3Dfloat* value);
 923   virtual void uniformMatrix4x2fv(blink::WGC3Dint location,
 924                                   blink::WGC3Dsizei count,
 925                                   blink::WGC3Dboolean transpose,
 926                                   const blink::WGC3Dfloat* value);
 927   virtual void uniformMatrix4x3fv(blink::WGC3Dint location,
 928                                   blink::WGC3Dsizei count,
 929                                   blink::WGC3Dboolean transpose,
 930                                   const blink::WGC3Dfloat* value);
 931   virtual blink::WGC3Dboolean unmapBuffer(blink::WGC3Denum target);
 932   virtual void vertexAttribI4i(blink::WGC3Duint index,
 933                                blink::WGC3Dint x,
 934                                blink::WGC3Dint y,
 935                                blink::WGC3Dint z,
 936                                blink::WGC3Dint w);
 937   virtual void vertexAttribI4iv(blink::WGC3Duint index,
 938                                 const blink::WGC3Dint* v);
 939   virtual void vertexAttribI4ui(blink::WGC3Duint index,
 940                                 blink::WGC3Duint x,
 941                                 blink::WGC3Duint y,
 942                                 blink::WGC3Duint z,
 943                                 blink::WGC3Duint w);
 944   virtual void vertexAttribI4uiv(blink::WGC3Duint index,
 945                                  const blink::WGC3Duint* v);
 946   virtual void vertexAttribIPointer(blink::WGC3Duint index,
 947                                     blink::WGC3Dint size,
 948                                     blink::WGC3Denum type,
 949                                     blink::WGC3Dsizei stride,
 950                                     blink::WGC3Dintptr pointer);
 951   virtual void waitSync(blink::WGC3Dsync sync,
 952                         blink::WGC3Dbitfield flags,
 953                         blink::WGC3Duint64 timeout);
 954
 955   virtual bool isContextLost();
 956   virtual blink::WGC3Denum getGraphicsResetStatusARB();
 957
 958   virtual GrGLInterface* createGrGLInterface();
 959
 960   ::gpu::gles2::GLES2Interface* GetGLInterface() {
 961     return gl_;
 962   }
 963
 964   // Convert WebGL context creation attributes into command buffer / EGL size
 965   // requests.
 966   static void ConvertAttributes(
 967       const blink::WebGraphicsContext3D::Attributes& attributes,
 968       ::gpu::gles2::ContextCreationAttribHelper* output_attribs);
 969
 970  protected:
 971   friend class WebGraphicsContext3DErrorMessageCallback;
 972
 973   WebGraphicsContext3DImpl();
 974
 975   ::gpu::gles2::GLES2ImplementationErrorMessageCallback*
 976       getErrorMessageCallback();
 977   virtual void OnErrorMessage(const std::string& message, int id);
 978
 979   void setGLInterface(::gpu::gles2::GLES2Interface* gl) {
 980     gl_ = gl;
 981   }
 982
 983   bool initialized_;
 984   bool initialize_failed_;
 985
 986   WebGraphicsContext3D::WebGraphicsContextLostCallback* context_lost_callback_;
 987
 988   WebGraphicsContext3D::WebGraphicsErrorMessageCallback*
 989       error_message_callback_;
 990   scoped_ptr<WebGraphicsContext3DErrorMessageCallback>
 991       client_error_message_callback_;
 992
 993   // Errors raised by synthesizeGLError().
 994   std::vector<blink::WGC3Denum> synthetic_errors_;
 995
 996   ::gpu::gles2::GLES2Interface* gl_;
 997   bool lose_context_when_out_of_memory_;
 998   uint32_t flush_id_;
 999 };
1000
1001 }  // namespace gpu_blink
1002
1003 #endif  // GPU_BLINK_WEBGRAPHICSCONTEXT3D_IMPL_H_