src/third_party/WebKit/Source/core/html/canvas/WebGLRenderingContextBase.h

   1 /*
   2  * Copyright (C) 2009 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef WebGLRenderingContextBase_h
  27 #define WebGLRenderingContextBase_h
  28
  29 #include "bindings/core/v8/Nullable.h"
  30 #include "core/dom/ActiveDOMObject.h"
  31 #include "core/html/canvas/CanvasRenderingContext.h"
  32 #include "core/html/canvas/WebGLExtensionName.h"
  33 #include "core/html/canvas/WebGLGetInfo.h"
  34 #include "core/page/Page.h"
  35 #include "core/rendering/RenderBoxModelObject.h"
  36 #include "platform/Timer.h"
  37 #include "platform/graphics/GraphicsTypes3D.h"
  38 #include "platform/graphics/ImageBuffer.h"
  39 #include "platform/graphics/gpu/DrawingBuffer.h"
  40 #include "platform/graphics/gpu/Extensions3DUtil.h"
  41 #include "platform/graphics/gpu/WebGLImageConversion.h"
  42 #include "public/platform/WebGraphicsContext3D.h"
  43 #include "wtf/Float32Array.h"
  44 #include "wtf/Int32Array.h"
  45 #include "wtf/OwnPtr.h"
  46 #include "wtf/text/WTFString.h"
  47
  48 namespace blink {
  49 class WebLayer;
  50 }
  51
  52 namespace blink {
  53
  54 class ANGLEInstancedArrays;
  55 class EXTBlendMinMax;
  56 class EXTFragDepth;
  57 class EXTShaderTextureLOD;
  58 class EXTTextureFilterAnisotropic;
  59 class ExceptionState;
  60 class HTMLImageElement;
  61 class HTMLVideoElement;
  62 class ImageBuffer;
  63 class ImageData;
  64 class IntSize;
  65 class OESElementIndexUint;
  66 class OESStandardDerivatives;
  67 class OESTextureFloat;
  68 class OESTextureFloatLinear;
  69 class OESTextureHalfFloat;
  70 class OESTextureHalfFloatLinear;
  71 class OESVertexArrayObject;
  72 class WebGLActiveInfo;
  73 class WebGLBuffer;
  74 class WebGLCompressedTextureATC;
  75 class WebGLCompressedTextureETC1;
  76 class WebGLCompressedTexturePVRTC;
  77 class WebGLCompressedTextureS3TC;
  78 class WebGLContextAttributes;
  79 class WebGLContextGroup;
  80 class WebGLContextObject;
  81 class WebGLDebugRendererInfo;
  82 class WebGLDebugShaders;
  83 class WebGLDepthTexture;
  84 class WebGLDrawBuffers;
  85 class WebGLExtension;
  86 class WebGLFramebuffer;
  87 class WebGLLoseContext;
  88 class WebGLObject;
  89 class WebGLProgram;
  90 class WebGLRenderbuffer;
  91 class WebGLShader;
  92 class WebGLShaderPrecisionFormat;
  93 class WebGLSharedObject;
  94 class WebGLSharedWebGraphicsContext3D;
  95 class WebGLTexture;
  96 class WebGLUniformLocation;
  97 class WebGLVertexArrayObjectOES;
  98
  99 class WebGLRenderingContextLostCallback;
 100 class WebGLRenderingContextErrorMessageCallback;
 101
 102 class WebGLRenderingContextBase: public CanvasRenderingContext, public ActiveDOMObject, public Page::MultisamplingChangedObserver {
 103     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(WebGLRenderingContextBase);
 104 public:
 105     virtual ~WebGLRenderingContextBase();
 106
 107     virtual unsigned version() const = 0;
 108     virtual String contextName() const = 0;
 109     virtual void registerContextExtensions() = 0;
 110
 111     static unsigned getWebGLVersion(const CanvasRenderingContext*);
 112
 113     int drawingBufferWidth() const;
 114     int drawingBufferHeight() const;
 115
 116     void activeTexture(GLenum texture);
 117     void attachShader(WebGLProgram*, WebGLShader*);
 118     void bindAttribLocation(WebGLProgram*, GLuint index, const String& name);
 119     void bindBuffer(GLenum target, WebGLBuffer*);
 120     void bindFramebuffer(GLenum target, WebGLFramebuffer*);
 121     void bindRenderbuffer(GLenum target, WebGLRenderbuffer*);
 122     void bindTexture(GLenum target, WebGLTexture*);
 123     void blendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
 124     void blendEquation(GLenum mode);
 125     void blendEquationSeparate(GLenum modeRGB, GLenum modeAlpha);
 126     void blendFunc(GLenum sfactor, GLenum dfactor);
 127     void blendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
 128
 129     void bufferData(GLenum target, long long size, GLenum usage);
 130     void bufferData(GLenum target, ArrayBuffer* data, GLenum usage);
 131     void bufferData(GLenum target, ArrayBufferView* data, GLenum usage);
 132     void bufferSubData(GLenum target, long long offset, ArrayBuffer* data);
 133     void bufferSubData(GLenum target, long long offset, ArrayBufferView* data);
 134
 135     GLenum checkFramebufferStatus(GLenum target);
 136     void clear(GLbitfield mask);
 137     void clearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
 138     void clearDepth(GLfloat);
 139     void clearStencil(GLint);
 140     void colorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
 141     void compileShader(WebGLShader*);
 142
 143     void compressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, ArrayBufferView* data);
 144     void compressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, ArrayBufferView* data);
 145
 146     void copyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
 147     void copyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
 148
 149     PassRefPtrWillBeRawPtr<WebGLBuffer> createBuffer();
 150     PassRefPtrWillBeRawPtr<WebGLFramebuffer> createFramebuffer();
 151     PassRefPtrWillBeRawPtr<WebGLProgram> createProgram();
 152     PassRefPtrWillBeRawPtr<WebGLRenderbuffer> createRenderbuffer();
 153     PassRefPtrWillBeRawPtr<WebGLShader> createShader(GLenum type);
 154     PassRefPtrWillBeRawPtr<WebGLTexture> createTexture();
 155
 156     void cullFace(GLenum mode);
 157
 158     void deleteBuffer(WebGLBuffer*);
 159     void deleteFramebuffer(WebGLFramebuffer*);
 160     void deleteProgram(WebGLProgram*);
 161     void deleteRenderbuffer(WebGLRenderbuffer*);
 162     void deleteShader(WebGLShader*);
 163     void deleteTexture(WebGLTexture*);
 164
 165     void depthFunc(GLenum);
 166     void depthMask(GLboolean);
 167     void depthRange(GLfloat zNear, GLfloat zFar);
 168     void detachShader(WebGLProgram*, WebGLShader*);
 169     void disable(GLenum cap);
 170     void disableVertexAttribArray(GLuint index);
 171     void drawArrays(GLenum mode, GLint first, GLsizei count);
 172     void drawElements(GLenum mode, GLsizei count, GLenum type, long long offset);
 173
 174     void drawArraysInstancedANGLE(GLenum mode, GLint first, GLsizei count, GLsizei primcount);
 175     void drawElementsInstancedANGLE(GLenum mode, GLsizei count, GLenum type, long long offset, GLsizei primcount);
 176
 177     void enable(GLenum cap);
 178     void enableVertexAttribArray(GLuint index);
 179     void finish();
 180     void flush();
 181     void framebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, WebGLRenderbuffer*);
 182     void framebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, WebGLTexture*, GLint level);
 183     void frontFace(GLenum mode);
 184     void generateMipmap(GLenum target);
 185
 186     PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GLuint index);
 187     PassRefPtrWillBeRawPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GLuint index);
 188     bool getAttachedShaders(WebGLProgram*, WillBeHeapVector<RefPtrWillBeMember<WebGLShader> >&);
 189     Nullable<WillBeHeapVector<RefPtrWillBeMember<WebGLShader> > > getAttachedShaders(WebGLProgram*);
 190     GLint getAttribLocation(WebGLProgram*, const String& name);
 191     WebGLGetInfo getBufferParameter(GLenum target, GLenum pname);
 192     PassRefPtrWillBeRawPtr<WebGLContextAttributes> getContextAttributes();
 193     GLenum getError();
 194     PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(const String& name);
 195     WebGLGetInfo getFramebufferAttachmentParameter(GLenum target, GLenum attachment, GLenum pname);
 196     WebGLGetInfo getParameter(GLenum pname);
 197     WebGLGetInfo getProgramParameter(WebGLProgram*, GLenum pname);
 198     String getProgramInfoLog(WebGLProgram*);
 199     WebGLGetInfo getRenderbufferParameter(GLenum target, GLenum pname);
 200     WebGLGetInfo getShaderParameter(WebGLShader*, GLenum pname);
 201     String getShaderInfoLog(WebGLShader*);
 202     PassRefPtrWillBeRawPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GLenum shaderType, GLenum precisionType);
 203     String getShaderSource(WebGLShader*);
 204     Nullable<Vector<String> > getSupportedExtensions();
 205     WebGLGetInfo getTexParameter(GLenum target, GLenum pname);
 206     WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*);
 207     PassRefPtrWillBeRawPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&);
 208     WebGLGetInfo getVertexAttrib(GLuint index, GLenum pname);
 209     long long getVertexAttribOffset(GLuint index, GLenum pname);
 210
 211     void hint(GLenum target, GLenum mode);
 212     GLboolean isBuffer(WebGLBuffer*);
 213     bool isContextLost() const;
 214     GLboolean isEnabled(GLenum cap);
 215     GLboolean isFramebuffer(WebGLFramebuffer*);
 216     GLboolean isProgram(WebGLProgram*);
 217     GLboolean isRenderbuffer(WebGLRenderbuffer*);
 218     GLboolean isShader(WebGLShader*);
 219     GLboolean isTexture(WebGLTexture*);
 220
 221     void lineWidth(GLfloat);
 222     void linkProgram(WebGLProgram*);
 223     void pixelStorei(GLenum pname, GLint param);
 224     void polygonOffset(GLfloat factor, GLfloat units);
 225     void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView* pixels);
 226     void renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
 227     void sampleCoverage(GLfloat value, GLboolean invert);
 228     void scissor(GLint x, GLint y, GLsizei width, GLsizei height);
 229     void shaderSource(WebGLShader*, const String&);
 230     void stencilFunc(GLenum func, GLint ref, GLuint mask);
 231     void stencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask);
 232     void stencilMask(GLuint);
 233     void stencilMaskSeparate(GLenum face, GLuint mask);
 234     void stencilOp(GLenum fail, GLenum zfail, GLenum zpass);
 235     void stencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
 236
 237     void texImage2D(GLenum target, GLint level, GLenum internalformat,
 238         GLsizei width, GLsizei height, GLint border,
 239         GLenum format, GLenum type, ArrayBufferView*, ExceptionState&);
 240     void texImage2D(GLenum target, GLint level, GLenum internalformat,
 241         GLenum format, GLenum type, ImageData*, ExceptionState&);
 242     void texImage2D(GLenum target, GLint level, GLenum internalformat,
 243         GLenum format, GLenum type, HTMLImageElement*, ExceptionState&);
 244     void texImage2D(GLenum target, GLint level, GLenum internalformat,
 245         GLenum format, GLenum type, HTMLCanvasElement*, ExceptionState&);
 246     void texImage2D(GLenum target, GLint level, GLenum internalformat,
 247         GLenum format, GLenum type, HTMLVideoElement*, ExceptionState&);
 248
 249     void texParameterf(GLenum target, GLenum pname, GLfloat param);
 250     void texParameteri(GLenum target, GLenum pname, GLint param);
 251
 252     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 253         GLsizei width, GLsizei height,
 254         GLenum format, GLenum type, ArrayBufferView*, ExceptionState&);
 255     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 256         GLenum format, GLenum type, ImageData*, ExceptionState&);
 257     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 258         GLenum format, GLenum type, HTMLImageElement*, ExceptionState&);
 259     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 260         GLenum format, GLenum type, HTMLCanvasElement*, ExceptionState&);
 261     void texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
 262         GLenum format, GLenum type, HTMLVideoElement*, ExceptionState&);
 263
 264     void uniform1f(const WebGLUniformLocation*, GLfloat x);
 265     void uniform1fv(const WebGLUniformLocation*, Float32Array* v);
 266     void uniform1fv(const WebGLUniformLocation*, GLfloat* v, GLsizei);
 267     void uniform1i(const WebGLUniformLocation*, GLint x);
 268     void uniform1iv(const WebGLUniformLocation*, Int32Array* v);
 269     void uniform1iv(const WebGLUniformLocation*, GLint* v, GLsizei);
 270     void uniform2f(const WebGLUniformLocation*, GLfloat x, GLfloat y);
 271     void uniform2fv(const WebGLUniformLocation*, Float32Array* v);
 272     void uniform2fv(const WebGLUniformLocation*, GLfloat* v, GLsizei);
 273     void uniform2i(const WebGLUniformLocation*, GLint x, GLint y);
 274     void uniform2iv(const WebGLUniformLocation*, Int32Array* v);
 275     void uniform2iv(const WebGLUniformLocation*, GLint* v, GLsizei);
 276     void uniform3f(const WebGLUniformLocation*, GLfloat x, GLfloat y, GLfloat z);
 277     void uniform3fv(const WebGLUniformLocation*, Float32Array* v);
 278     void uniform3fv(const WebGLUniformLocation*, GLfloat* v, GLsizei);
 279     void uniform3i(const WebGLUniformLocation*, GLint x, GLint y, GLint z);
 280     void uniform3iv(const WebGLUniformLocation*, Int32Array* v);
 281     void uniform3iv(const WebGLUniformLocation*, GLint* v, GLsizei);
 282     void uniform4f(const WebGLUniformLocation*, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 283     void uniform4fv(const WebGLUniformLocation*, Float32Array* v);
 284     void uniform4fv(const WebGLUniformLocation*, GLfloat* v, GLsizei);
 285     void uniform4i(const WebGLUniformLocation*, GLint x, GLint y, GLint z, GLint w);
 286     void uniform4iv(const WebGLUniformLocation*, Int32Array* v);
 287     void uniform4iv(const WebGLUniformLocation*, GLint* v, GLsizei);
 288     void uniformMatrix2fv(const WebGLUniformLocation*, GLboolean transpose, Float32Array* value);
 289     void uniformMatrix2fv(const WebGLUniformLocation*, GLboolean transpose, GLfloat* value, GLsizei);
 290     void uniformMatrix3fv(const WebGLUniformLocation*, GLboolean transpose, Float32Array* value);
 291     void uniformMatrix3fv(const WebGLUniformLocation*, GLboolean transpose, GLfloat* value, GLsizei);
 292     void uniformMatrix4fv(const WebGLUniformLocation*, GLboolean transpose, Float32Array* value);
 293     void uniformMatrix4fv(const WebGLUniformLocation*, GLboolean transpose, GLfloat* value, GLsizei);
 294
 295     void useProgram(WebGLProgram*);
 296     void validateProgram(WebGLProgram*);
 297
 298     void vertexAttrib1f(GLuint index, GLfloat x);
 299     void vertexAttrib1fv(GLuint index, Float32Array* values);
 300     void vertexAttrib1fv(GLuint index, GLfloat* values, GLsizei);
 301     void vertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
 302     void vertexAttrib2fv(GLuint index, Float32Array* values);
 303     void vertexAttrib2fv(GLuint index, GLfloat* values, GLsizei);
 304     void vertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
 305     void vertexAttrib3fv(GLuint index, Float32Array* values);
 306     void vertexAttrib3fv(GLuint index, GLfloat* values, GLsizei);
 307     void vertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 308     void vertexAttrib4fv(GLuint index, Float32Array* values);
 309     void vertexAttrib4fv(GLuint index, GLfloat* values, GLsizei);
 310     void vertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized,
 311         GLsizei stride, long long offset);
 312
 313     void vertexAttribDivisorANGLE(GLuint index, GLuint divisor);
 314
 315     void viewport(GLint x, GLint y, GLsizei width, GLsizei height);
 316
 317     // WEBGL_lose_context support
 318     enum LostContextMode {
 319         NotLostContext,
 320
 321         // Lost context occurred at the graphics system level.
 322         RealLostContext,
 323
 324         // Lost context provoked by WEBGL_lose_context.
 325         WebGLLoseContextLostContext,
 326
 327         // Lost context occurred due to internal implementation reasons.
 328         SyntheticLostContext,
 329     };
 330     enum AutoRecoveryMethod {
 331         // Don't restore automatically.
 332         Manual,
 333
 334         // Restore when resources are available.
 335         WhenAvailable,
 336
 337         // Restore as soon as possible.
 338         Auto
 339     };
 340     void forceLostContext(LostContextMode, AutoRecoveryMethod);
 341     void forceRestoreContext();
 342     void loseContextImpl(LostContextMode, AutoRecoveryMethod);
 343
 344     blink::WebGraphicsContext3D* webContext() const { return drawingBuffer()->context(); }
 345     WebGLContextGroup* contextGroup() const { return m_contextGroup.get(); }
 346     Extensions3DUtil* extensionsUtil();
 347
 348     void reshape(int width, int height);
 349
 350     void markLayerComposited();
 351     PassRefPtrWillBeRawPtr<ImageData> paintRenderingResultsToImageData();
 352
 353     void removeSharedObject(WebGLSharedObject*);
 354     void removeContextObject(WebGLContextObject*);
 355
 356     unsigned maxVertexAttribs() const { return m_maxVertexAttribs; }
 357
 358     // ActiveDOMObject notifications
 359     virtual bool hasPendingActivity() const OVERRIDE;
 360     virtual void stop() OVERRIDE;
 361
 362     void setSavingImage(bool isSaving) { m_savingImage = isSaving; }
 363
 364     virtual void trace(Visitor*) OVERRIDE;
 365
 366     class TextureUnitState {
 367         ALLOW_ONLY_INLINE_ALLOCATION();
 368     public:
 369         RefPtrWillBeMember<WebGLTexture> m_texture2DBinding;
 370         RefPtrWillBeMember<WebGLTexture> m_textureCubeMapBinding;
 371
 372         void trace(Visitor*);
 373     };
 374
 375 protected:
 376     friend class WebGLDrawBuffers;
 377     friend class WebGLFramebuffer;
 378     friend class WebGLObject;
 379     friend class WebGLContextObject;
 380     friend class OESVertexArrayObject;
 381     friend class WebGLDebugShaders;
 382     friend class WebGLCompressedTextureATC;
 383     friend class WebGLCompressedTextureETC1;
 384     friend class WebGLCompressedTexturePVRTC;
 385     friend class WebGLCompressedTextureS3TC;
 386     friend class WebGLRenderingContextErrorMessageCallback;
 387     friend class WebGLVertexArrayObjectOES;
 388     friend class ScopedTexture2DRestorer;
 389
 390     WebGLRenderingContextBase(HTMLCanvasElement*, PassOwnPtr<blink::WebGraphicsContext3D>, WebGLContextAttributes*);
 391     PassRefPtr<DrawingBuffer> createDrawingBuffer(PassOwnPtr<blink::WebGraphicsContext3D>);
 392     void initializeNewContext();
 393     void setupFlags();
 394
 395 #if ENABLE(OILPAN)
 396     PassRefPtr<WebGLSharedWebGraphicsContext3D> sharedWebGraphicsContext3D() const;
 397 #endif
 398
 399     // CanvasRenderingContext implementation.
 400     virtual bool is3d() const OVERRIDE { return true; }
 401     virtual bool isAccelerated() const OVERRIDE { return true; }
 402     virtual void setIsHidden(bool) OVERRIDE;
 403     virtual void paintRenderingResultsToCanvas() OVERRIDE;
 404     virtual blink::WebLayer* platformLayer() const OVERRIDE;
 405
 406     void addSharedObject(WebGLSharedObject*);
 407     void addContextObject(WebGLContextObject*);
 408     void detachAndRemoveAllObjects();
 409
 410     void destroyContext();
 411     void markContextChanged(ContentChangeType);
 412
 413     // Query if the GL implementation is NPOT strict.
 414     bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
 415     // Query if depth_stencil buffer is supported.
 416     bool isDepthStencilSupported() { return m_isDepthStencilSupported; }
 417
 418     // Helper to return the size in bytes of OpenGL data types
 419     // like GL_FLOAT, GL_INT, etc.
 420     unsigned sizeInBytes(GLenum type);
 421
 422     // Check if each enabled vertex attribute is bound to a buffer.
 423     bool validateRenderingState(const char*);
 424
 425     bool validateWebGLObject(const char*, WebGLObject*);
 426
 427     // Adds a compressed texture format.
 428     void addCompressedTextureFormat(GLenum);
 429     void removeAllCompressedTextureFormats();
 430
 431     PassRefPtr<Image> drawImageIntoBuffer(Image*, int width, int height, const char* functionName);
 432
 433     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy);
 434
 435     WebGLRenderbuffer* ensureEmulatedStencilBuffer(GLenum target, WebGLRenderbuffer*);
 436
 437     // Structure for rendering to a DrawingBuffer, instead of directly
 438     // to the back-buffer of m_context.
 439 #if ENABLE(OILPAN)
 440     RefPtr<WebGLSharedWebGraphicsContext3D> m_sharedWebGraphicsContext3D;
 441 #else
 442     RefPtr<DrawingBuffer> m_drawingBuffer;
 443 #endif
 444     DrawingBuffer* drawingBuffer() const;
 445
 446     RefPtr<WebGLContextGroup> m_contextGroup;
 447
 448     LostContextMode m_contextLostMode;
 449     AutoRecoveryMethod m_autoRecoveryMethod;
 450     // Dispatches a context lost event once it is determined that one is needed.
 451     // This is used for synthetic, WEBGL_lose_context and real context losses. For real ones, it's
 452     // likely that there's no JavaScript on the stack, but that might be dependent
 453     // on how exactly the platform discovers that the context was lost. For better
 454     // portability we always defer the dispatch of the event.
 455     Timer<WebGLRenderingContextBase> m_dispatchContextLostEventTimer;
 456     bool m_restoreAllowed;
 457     Timer<WebGLRenderingContextBase> m_restoreTimer;
 458
 459     bool m_needsUpdate;
 460     bool m_markedCanvasDirty;
 461     WillBeHeapHashSet<RawPtrWillBeWeakMember<WebGLContextObject> > m_contextObjects;
 462
 463     OwnPtrWillBeMember<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
 464     OwnPtrWillBeMember<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
 465
 466     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
 467     RefPtrWillBeMember<WebGLBuffer> m_boundArrayBuffer;
 468
 469     RefPtrWillBeMember<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;
 470     RefPtrWillBeMember<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;
 471     void setBoundVertexArrayObject(PassRefPtrWillBeRawPtr<WebGLVertexArrayObjectOES> arrayObject)
 472     {
 473         if (arrayObject)
 474             m_boundVertexArrayObject = arrayObject;
 475         else
 476             m_boundVertexArrayObject = m_defaultVertexArrayObject;
 477     }
 478
 479     class VertexAttribValue {
 480     public:
 481         VertexAttribValue()
 482         {
 483             initValue();
 484         }
 485
 486         void initValue()
 487         {
 488             value[0] = 0.0f;
 489             value[1] = 0.0f;
 490             value[2] = 0.0f;
 491             value[3] = 1.0f;
 492         }
 493
 494         GLfloat value[4];
 495     };
 496     Vector<VertexAttribValue> m_vertexAttribValue;
 497     unsigned m_maxVertexAttribs;
 498     RefPtrWillBeMember<WebGLBuffer> m_vertexAttrib0Buffer;
 499     long m_vertexAttrib0BufferSize;
 500     GLfloat m_vertexAttrib0BufferValue[4];
 501     bool m_forceAttrib0BufferRefill;
 502     bool m_vertexAttrib0UsedBefore;
 503
 504     RefPtrWillBeMember<WebGLProgram> m_currentProgram;
 505     RefPtrWillBeMember<WebGLFramebuffer> m_framebufferBinding;
 506     RefPtrWillBeMember<WebGLRenderbuffer> m_renderbufferBinding;
 507
 508     WillBeHeapVector<TextureUnitState> m_textureUnits;
 509     unsigned long m_activeTextureUnit;
 510
 511     RefPtrWillBeMember<WebGLTexture> m_blackTexture2D;
 512     RefPtrWillBeMember<WebGLTexture> m_blackTextureCubeMap;
 513
 514     Vector<GLenum> m_compressedTextureFormats;
 515
 516     // Fixed-size cache of reusable image buffers for video texImage2D calls.
 517     class LRUImageBufferCache {
 518     public:
 519         LRUImageBufferCache(int capacity);
 520         // The pointer returned is owned by the image buffer map.
 521         ImageBuffer* imageBuffer(const IntSize& size);
 522     private:
 523         void bubbleToFront(int idx);
 524         OwnPtr<OwnPtr<ImageBuffer>[]> m_buffers;
 525         int m_capacity;
 526     };
 527     LRUImageBufferCache m_generatedImageCache;
 528
 529     GLint m_maxTextureSize;
 530     GLint m_maxCubeMapTextureSize;
 531     GLint m_maxRenderbufferSize;
 532     GLint m_maxViewportDims[2];
 533     GLint m_maxTextureLevel;
 534     GLint m_maxCubeMapTextureLevel;
 535
 536     GLint m_maxDrawBuffers;
 537     GLint m_maxColorAttachments;
 538     GLenum m_backDrawBuffer;
 539     bool m_drawBuffersWebGLRequirementsChecked;
 540     bool m_drawBuffersSupported;
 541
 542     GLint m_packAlignment;
 543     GLint m_unpackAlignment;
 544     bool m_unpackFlipY;
 545     bool m_unpackPremultiplyAlpha;
 546     GLenum m_unpackColorspaceConversion;
 547     RefPtrWillBeMember<WebGLContextAttributes> m_requestedAttributes;
 548
 549     bool m_layerCleared;
 550     GLfloat m_clearColor[4];
 551     bool m_scissorEnabled;
 552     GLfloat m_clearDepth;
 553     GLint m_clearStencil;
 554     GLboolean m_colorMask[4];
 555     GLboolean m_depthMask;
 556
 557     bool m_stencilEnabled;
 558     GLuint m_stencilMask, m_stencilMaskBack;
 559     GLint m_stencilFuncRef, m_stencilFuncRefBack; // Note that these are the user specified values, not the internal clamped value.
 560     GLuint m_stencilFuncMask, m_stencilFuncMaskBack;
 561
 562     bool m_isGLES2NPOTStrict;
 563     bool m_isDepthStencilSupported;
 564
 565     bool m_synthesizedErrorsToConsole;
 566     int m_numGLErrorsToConsoleAllowed;
 567
 568     bool m_multisamplingAllowed;
 569     bool m_multisamplingObserverRegistered;
 570
 571     unsigned long m_onePlusMaxNonDefaultTextureUnit;
 572
 573     OwnPtr<Extensions3DUtil> m_extensionsUtil;
 574
 575     bool m_savingImage;
 576
 577     enum ExtensionFlags {
 578         ApprovedExtension               = 0x00,
 579         // Extension that is behind the draft extensions runtime flag:
 580         DraftExtension                  = 0x01,
 581     };
 582
 583     class ExtensionTracker : public NoBaseWillBeGarbageCollected<ExtensionTracker> {
 584     public:
 585         ExtensionTracker(ExtensionFlags flags, const char* const* prefixes)
 586             : m_draft(flags & DraftExtension)
 587             , m_prefixes(prefixes)
 588         {
 589         }
 590
 591 #if !ENABLE(OILPAN)
 592         virtual ~ExtensionTracker()
 593         {
 594         }
 595 #endif
 596
 597         bool draft() const
 598         {
 599             return m_draft;
 600         }
 601
 602         const char* const* prefixes() const;
 603         bool matchesNameWithPrefixes(const String&) const;
 604
 605         virtual PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(WebGLRenderingContextBase*) = 0;
 606         virtual bool supported(WebGLRenderingContextBase*) const = 0;
 607         virtual const char* extensionName() const = 0;
 608         virtual void loseExtension() = 0;
 609
 610         virtual void trace(Visitor*) { }
 611
 612     private:
 613         bool m_draft;
 614         const char* const* m_prefixes;
 615     };
 616
 617     template <typename T>
 618     class TypedExtensionTracker FINAL : public ExtensionTracker {
 619     public:
 620         static PassOwnPtrWillBeRawPtr<TypedExtensionTracker<T> > create(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
 621         {
 622             return adoptPtrWillBeNoop(new TypedExtensionTracker<T>(extensionField, flags, prefixes));
 623         }
 624
 625 #if !ENABLE(OILPAN)
 626         virtual ~TypedExtensionTracker()
 627         {
 628             if (m_extension) {
 629                 m_extension->lose(true);
 630                 m_extension = nullptr;
 631             }
 632         }
 633 #endif
 634
 635         virtual PassRefPtrWillBeRawPtr<WebGLExtension> getExtension(WebGLRenderingContextBase* context) OVERRIDE
 636         {
 637             if (!m_extension) {
 638                 m_extension = T::create(context);
 639                 m_extensionField = m_extension;
 640             }
 641
 642             return m_extension;
 643         }
 644
 645         virtual bool supported(WebGLRenderingContextBase* context) const OVERRIDE
 646         {
 647             return T::supported(context);
 648         }
 649
 650         virtual const char* extensionName() const OVERRIDE
 651         {
 652             return T::extensionName();
 653         }
 654
 655         virtual void loseExtension() OVERRIDE
 656         {
 657             if (m_extension) {
 658                 m_extension->lose(false);
 659                 if (m_extension->isLost())
 660                     m_extension = nullptr;
 661             }
 662         }
 663
 664         virtual void trace(Visitor* visitor) OVERRIDE
 665         {
 666             visitor->trace(m_extension);
 667             ExtensionTracker::trace(visitor);
 668         }
 669
 670     private:
 671         TypedExtensionTracker(RefPtrWillBeMember<T>& extensionField, ExtensionFlags flags, const char* const* prefixes)
 672             : ExtensionTracker(flags, prefixes)
 673             , m_extensionField(extensionField)
 674         {
 675         }
 676
 677         RefPtrWillBeMember<T>& m_extensionField;
 678         // ExtensionTracker holds it's own reference to the extension to ensure
 679         // that it is not deleted before this object's destructor is called
 680         RefPtrWillBeMember<T> m_extension;
 681     };
 682
 683     bool m_extensionEnabled[WebGLExtensionNameCount];
 684     WillBeHeapVector<OwnPtrWillBeMember<ExtensionTracker> > m_extensions;
 685
 686     template <typename T>
 687     void registerExtension(RefPtrWillBeMember<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char* const* prefixes = 0)
 688     {
 689         m_extensions.append(TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes));
 690     }
 691
 692     bool extensionSupportedAndAllowed(const ExtensionTracker*);
 693
 694     inline bool extensionEnabled(WebGLExtensionName name)
 695     {
 696         return m_extensionEnabled[name];
 697     }
 698
 699     // Errors raised by synthesizeGLError() while the context is lost.
 700     Vector<GLenum> m_lostContextErrors;
 701
 702     // Helpers for getParameter and others
 703     WebGLGetInfo getBooleanParameter(GLenum);
 704     WebGLGetInfo getBooleanArrayParameter(GLenum);
 705     WebGLGetInfo getFloatParameter(GLenum);
 706     WebGLGetInfo getIntParameter(GLenum);
 707     WebGLGetInfo getUnsignedIntParameter(GLenum);
 708     WebGLGetInfo getWebGLFloatArrayParameter(GLenum);
 709     WebGLGetInfo getWebGLIntArrayParameter(GLenum);
 710
 711     // Clear the backbuffer if it was composited since the last operation.
 712     // clearMask is set to the bitfield of any clear that would happen anyway at this time
 713     // and the function returns true if that clear is now unnecessary.
 714     bool clearIfComposited(GLbitfield clearMask = 0);
 715
 716     // Helper to restore state that clearing the framebuffer may destroy.
 717     void restoreStateAfterClear();
 718
 719     // Convert texture internal format.
 720     GLenum convertTexInternalFormat(GLenum internalformat, GLenum type);
 721
 722     void texImage2DBase(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels, ExceptionState&);
 723     void texImage2DImpl(GLenum target, GLint level, GLenum internalformat, GLenum format, GLenum type, Image*, WebGLImageConversion::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionState&);
 724     void texSubImage2DBase(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels, ExceptionState&);
 725     void texSubImage2DImpl(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLenum format, GLenum type, Image*, WebGLImageConversion::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionState&);
 726
 727     void handleTextureCompleteness(const char*, bool);
 728     void createFallbackBlackTextures1x1();
 729
 730     // Helper function for copyTex{Sub}Image, check whether the internalformat
 731     // and the color buffer format of the current bound framebuffer combination
 732     // is valid.
 733     bool isTexInternalFormatColorBufferCombinationValid(GLenum texInternalFormat, GLenum colorBufferFormat);
 734
 735     // Helper function to get the bound framebuffer's color buffer format.
 736     GLenum boundFramebufferColorFormat();
 737
 738     // Helper function to verify limits on the length of uniform and attribute locations.
 739     bool validateLocationLength(const char* functionName, const String&);
 740
 741     // Helper function to check if size is non-negative.
 742     // Generate GL error and return false for negative inputs; otherwise, return true.
 743     bool validateSize(const char* functionName, GLint x, GLint y);
 744
 745     // Helper function to check if all characters in the string belong to the
 746     // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.
 747     bool validateString(const char* functionName, const String&);
 748
 749     // Helper function to check target and texture bound to the target.
 750     // Generate GL errors and return 0 if target is invalid or texture bound is
 751     // null.  Otherwise, return the texture bound to the target.
 752     WebGLTexture* validateTextureBinding(const char* functionName, GLenum target, bool useSixEnumsForCubeMap);
 753
 754     // Helper function to check input format/type for functions {copy}Tex{Sub}Image.
 755     // Generates GL error and returns false if parameters are invalid.
 756     bool validateTexFuncFormatAndType(const char* functionName, GLenum format, GLenum type, GLint level);
 757
 758     // Helper function to check input level for functions {copy}Tex{Sub}Image.
 759     // Generates GL error and returns false if level is invalid.
 760     bool validateTexFuncLevel(const char* functionName, GLenum target, GLint level);
 761
 762     // Helper function to check if a 64-bit value is non-negative and can fit into a 32-bit integer.
 763     // Generates GL error and returns false if not.
 764     bool validateValueFitNonNegInt32(const char* functionName, const char* paramName, long long value);
 765
 766     enum TexFuncValidationFunctionType {
 767         NotTexSubImage2D,
 768         TexSubImage2D,
 769     };
 770
 771     enum TexFuncValidationSourceType {
 772         SourceArrayBufferView,
 773         SourceImageData,
 774         SourceHTMLImageElement,
 775         SourceHTMLCanvasElement,
 776         SourceHTMLVideoElement,
 777     };
 778
 779     // Helper function for tex{Sub}Image2D to check if the input format/type/level/target/width/height/border/xoffset/yoffset are valid.
 780     // Otherwise, it would return quickly without doing other work.
 781     bool validateTexFunc(const char* functionName, TexFuncValidationFunctionType, TexFuncValidationSourceType, GLenum target, GLint level, GLenum internalformat, GLsizei width,
 782         GLsizei height, GLint border, GLenum format, GLenum type, GLint xoffset, GLint yoffset);
 783
 784     // Helper function to check input width and height for functions {copy, compressed}Tex{Sub}Image.
 785     // Generates GL error and returns false if width or height is invalid.
 786     bool validateTexFuncDimensions(const char* functionName, TexFuncValidationFunctionType, GLenum target, GLint level, GLsizei width, GLsizei height);
 787
 788     // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
 789     // Generates GL error and returns false if parameters are invalid.
 790     bool validateTexFuncParameters(const char* functionName, TexFuncValidationFunctionType, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type);
 791
 792     enum NullDisposition {
 793         NullAllowed,
 794         NullNotAllowed
 795     };
 796
 797     // Helper function to validate that the given ArrayBufferView
 798     // is of the correct type and contains enough data for the texImage call.
 799     // Generates GL error and returns false if parameters are invalid.
 800     bool validateTexFuncData(const char* functionName, GLint level, GLsizei width, GLsizei height, GLenum format, GLenum type, ArrayBufferView* pixels, NullDisposition);
 801
 802     // Helper function to validate a given texture format is settable as in
 803     // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and
 804     // copyTexSubImage2D.
 805     // Generates GL error and returns false if the format is not settable.
 806     bool validateSettableTexFormat(const char* functionName, GLenum format);
 807
 808     // Helper function to validate compressed texture data is correct size
 809     // for the given format and dimensions.
 810     bool validateCompressedTexFuncData(const char* functionName, GLsizei width, GLsizei height, GLenum format, ArrayBufferView* pixels);
 811
 812     // Helper function for validating compressed texture formats.
 813     bool validateCompressedTexFormat(GLenum format);
 814
 815     // Helper function to validate compressed texture dimensions are valid for
 816     // the given format.
 817     bool validateCompressedTexDimensions(const char* functionName, TexFuncValidationFunctionType, GLenum target, GLint level, GLsizei width, GLsizei height, GLenum format);
 818
 819     // Helper function to validate compressed texture dimensions are valid for
 820     // the given format.
 821     bool validateCompressedTexSubDimensions(const char* functionName, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, WebGLTexture*);
 822
 823     // Helper function to validate mode for draw{Arrays/Elements}.
 824     bool validateDrawMode(const char* functionName, GLenum);
 825
 826     // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.
 827     bool validateStencilSettings(const char* functionName);
 828
 829     // Helper function to validate stencil or depth func.
 830     bool validateStencilOrDepthFunc(const char* functionName, GLenum);
 831
 832     // Helper function for texParameterf and texParameteri.
 833     void texParameter(GLenum target, GLenum pname, GLfloat parami, GLint paramf, bool isFloat);
 834
 835     // Helper function to print GL errors to console.
 836     void printGLErrorToConsole(const String&);
 837
 838     // Helper function to print warnings to console. Currently
 839     // used only to warn about use of obsolete functions.
 840     void printWarningToConsole(const String&);
 841
 842     // Helper function to validate input parameters for framebuffer functions.
 843     // Generate GL error if parameters are illegal.
 844     bool validateFramebufferFuncParameters(const char* functionName, GLenum target, GLenum attachment);
 845
 846     // Helper function to validate blend equation mode.
 847     bool validateBlendEquation(const char* functionName, GLenum);
 848
 849     // Helper function to validate blend func factors.
 850     bool validateBlendFuncFactors(const char* functionName, GLenum src, GLenum dst);
 851
 852     // Helper function to validate a GL capability.
 853     bool validateCapability(const char* functionName, GLenum);
 854
 855     // Helper function to validate input parameters for uniform functions.
 856     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GLsizei mod);
 857     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GLsizei mod);
 858     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GLsizei, GLsizei mod);
 859     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GLboolean transpose, Float32Array*, GLsizei mod);
 860     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GLboolean transpose, void*, GLsizei, GLsizei mod);
 861
 862     // Helper function to validate the target for bufferData.
 863     // Return the current bound buffer to target, or 0 if the target is invalid.
 864     WebGLBuffer* validateBufferDataTarget(const char* functionName, GLenum target);
 865
 866     // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.
 867     bool validateHTMLImageElement(const char* functionName, HTMLImageElement*, ExceptionState&);
 868
 869     // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.
 870     bool validateHTMLCanvasElement(const char* functionName, HTMLCanvasElement*, ExceptionState&);
 871
 872     // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.
 873     bool validateHTMLVideoElement(const char* functionName, HTMLVideoElement*, ExceptionState&);
 874
 875     // Helper function to validate drawArrays(Instanced) calls
 876     bool validateDrawArrays(const char* functionName, GLenum mode, GLint first, GLsizei count);
 877
 878     // Helper function to validate drawElements(Instanced) calls
 879     bool validateDrawElements(const char* functionName, GLenum mode, GLsizei count, GLenum type, long long offset);
 880
 881     // Helper function to validate draw*Instanced calls
 882     bool validateDrawInstanced(const char* functionName, GLsizei primcount);
 883
 884     // Helper functions for vertexAttribNf{v}.
 885     void vertexAttribfImpl(const char* functionName, GLuint index, GLsizei expectedSize, GLfloat, GLfloat, GLfloat, GLfloat);
 886     void vertexAttribfvImpl(const char* functionName, GLuint index, Float32Array*, GLsizei expectedSize);
 887     void vertexAttribfvImpl(const char* functionName, GLuint index, GLfloat*, GLsizei, GLsizei expectedSize);
 888
 889     // Helper functions to bufferData() and bufferSubData().
 890     void bufferDataImpl(GLenum target, long long size, const void* data, GLenum usage);
 891     void bufferSubDataImpl(GLenum target, long long offset, GLsizeiptr size, const void* data);
 892
 893     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
 894     // Return false if caller should return without further processing.
 895     bool deleteObject(WebGLObject*);
 896
 897     // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.
 898     // If the object has already been deleted, set deleted to true upon return.
 899     // Return false if caller should return without further processing.
 900     bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);
 901
 902     void dispatchContextLostEvent(Timer<WebGLRenderingContextBase>*);
 903     // Helper for restoration after context lost.
 904     void maybeRestoreContext(Timer<WebGLRenderingContextBase>*);
 905
 906     enum ConsoleDisplayPreference {
 907         DisplayInConsole,
 908         DontDisplayInConsole
 909     };
 910
 911     // Wrapper for WebGraphicsContext3D::synthesizeGLError that sends a message
 912     // to the JavaScript console.
 913     void synthesizeGLError(GLenum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
 914     void emitGLWarning(const char* function, const char* reason);
 915
 916     String ensureNotNull(const String&) const;
 917
 918     // Enable or disable stencil test based on user setting and
 919     // whether the current FBO has a stencil buffer.
 920     void applyStencilTest();
 921
 922     // Helper for enabling or disabling a capability.
 923     void enableOrDisable(GLenum capability, bool enable);
 924
 925     // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.
 926     IntSize clampedCanvasSize();
 927
 928     // First time called, if EXT_draw_buffers is supported, query the value; otherwise return 0.
 929     // Later, return the cached value.
 930     GLint maxDrawBuffers();
 931     GLint maxColorAttachments();
 932
 933     void setBackDrawBuffer(GLenum);
 934
 935     void restoreCurrentFramebuffer();
 936     void restoreCurrentTexture2D();
 937
 938     virtual void multisamplingChanged(bool) OVERRIDE;
 939
 940     void findNewMaxNonDefaultTextureUnit();
 941
 942     friend class WebGLStateRestorer;
 943     friend class WebGLRenderingContextEvictionManager;
 944
 945     static Vector<WebGLRenderingContextBase*>& activeContexts();
 946     static Vector<WebGLRenderingContextBase*>& forciblyEvictedContexts();
 947
 948     static void activateContext(WebGLRenderingContextBase*);
 949     static void deactivateContext(WebGLRenderingContextBase*);
 950     static void addToEvictedList(WebGLRenderingContextBase*);
 951     static void removeFromEvictedList(WebGLRenderingContextBase*);
 952     static void willDestroyContext(WebGLRenderingContextBase*);
 953     static void forciblyLoseOldestContext(const String& reason);
 954     // Return the least recently used context's position in the active context vector.
 955     // If the vector is empty, return the maximum allowed active context number.
 956     static size_t oldestContextIndex();
 957     static IntSize oldestContextSize();
 958 };
 959
 960 DEFINE_TYPE_CASTS(WebGLRenderingContextBase, CanvasRenderingContext, context, context->is3d(), context.is3d());
 961
 962 } // namespace blink
 963
 964 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(blink::WebGLRenderingContextBase::TextureUnitState);
 965
 966 #endif // WebGLRenderingContextBase_h