Moved the majority of WebGL functionality into WebGLRenderingContextBase

Source/core/html/canvas/WebGLRenderingContextBase.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef WebGLRenderingContext_h
-#define WebGLRenderingContext_h
+#ifndef WebGLRenderingContextBase_h
+#define WebGLRenderingContextBase_h
 
 #include "core/dom/ActiveDOMObject.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
+#include "core/html/canvas/WebGLExtensionNames.h"
 #include "core/html/canvas/WebGLGetInfo.h"
 #include "core/page/Page.h"
 #include "core/platform/Timer.h"
 #include "core/platform/graphics/GraphicsContext3D.h"
 #include "core/platform/graphics/ImageBuffer.h"
 
 #include "wtf/Float32Array.h"
 #include "wtf/Int32Array.h"
 #include "wtf/OwnArrayPtr.h"
 #include "wtf/text/WTFString.h"
@@ skipping 37 matching lines @@
 class WebGLObject;
 class WebGLProgram;
 class WebGLRenderbuffer;
 class WebGLShader;
 class WebGLShaderPrecisionFormat;
 class WebGLSharedObject;
 class WebGLTexture;
 class WebGLUniformLocation;
 class WebGLVertexArrayObjectOES;
 
-class WebGLRenderingContext : public CanvasRenderingContext, public ActiveDOMObject, private Page::MultisamplingChangedObserver {
+class WebGLRenderingContextBase : public CanvasRenderingContext, public ActiveDOMObject, private Page::MultisamplingChangedObserver {
 public:
-    static PassOwnPtr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);
-    virtual ~WebGLRenderingContext();
+    virtual ~WebGLRenderingContextBase();
 
     virtual bool is3d() const { return true; }
     virtual bool isAccelerated() const { return true; }
 
+    virtual void registerContextExtensions() = 0;
+
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
     void activeTexture(GC3Denum texture);
     void attachShader(WebGLProgram*, WebGLShader*);
     void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name);
     void bindBuffer(GC3Denum target, WebGLBuffer*);
     void bindFramebuffer(GC3Denum target, WebGLFramebuffer*);
     void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*);
     void bindTexture(GC3Denum target, WebGLTexture*);
@@ skipping 11 matching lines @@
 
     GC3Denum checkFramebufferStatus(GC3Denum target);
     void clear(GC3Dbitfield mask);
     void clearColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
     void clearDepth(GC3Dfloat);
     void clearStencil(GC3Dint);
     void colorMask(GC3Dboolean red, GC3Dboolean green, GC3Dboolean blue, GC3Dboolean alpha);
     void compileShader(WebGLShader*);
 
     void compressedTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width,
-                              GC3Dsizei height, GC3Dint border, ArrayBufferView* data);
+        GC3Dsizei height, GC3Dint border, ArrayBufferView* data);
     void compressedTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-                                 GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);
+        GC3Dsizei width, GC3Dsizei height, GC3Denum format, ArrayBufferView* data);
 
     void copyTexImage2D(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height, GC3Dint border);
     void copyTexSubImage2D(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
 
     PassRefPtr<WebGLBuffer> createBuffer();
     PassRefPtr<WebGLFramebuffer> createFramebuffer();
     PassRefPtr<WebGLProgram> createProgram();
     PassRefPtr<WebGLRenderbuffer> createRenderbuffer();
     PassRefPtr<WebGLShader> createShader(GC3Denum type);
     PassRefPtr<WebGLTexture> createTexture();
@@ skipping 185 matching lines @@
 
     void removeSharedObject(WebGLSharedObject*);
     void removeContextObject(WebGLContextObject*);
 
     unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
 
     // ActiveDOMObject notifications
     virtual bool hasPendingActivity() const;
     virtual void stop();
 
-  private:
+protected:
     friend class WebGLDrawBuffers;
     friend class WebGLFramebuffer;
     friend class WebGLObject;
     friend class OESVertexArrayObject;
     friend class WebGLDebugShaders;
     friend class WebGLCompressedTextureATC;
     friend class WebGLCompressedTexturePVRTC;
     friend class WebGLCompressedTextureS3TC;
     friend class WebGLRenderingContextErrorMessageCallback;
     friend class WebGLVertexArrayObjectOES;
 
-    WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes, GraphicsContext3D::Attributes);
+    WebGLRenderingContextBase(const String&, unsigned featureLevel, HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes, GraphicsContext3D::Attributes);
     void initializeNewContext();
     void setupFlags();
 
     void addSharedObject(WebGLSharedObject*);
     void addContextObject(WebGLContextObject*);
     void detachAndRemoveAllObjects();
 
     void destroyGraphicsContext3D();
     void markContextChanged();
 
     // Query if the GL implementation is NPOT strict.
     bool isGLES2NPOTStrict() { return m_isGLES2NPOTStrict; }
     // Query if depth_stencil buffer is supported.
     bool isDepthStencilSupported() { return m_isDepthStencilSupported; }
 
     // Helper to return the size in bytes of OpenGL data types
     // like GL_FLOAT, GL_INT, etc.
-    unsigned int sizeInBytes(GC3Denum type);
+    unsigned sizeInBytes(GC3Denum type);
 
     // Check if each enabled vertex attribute is bound to a buffer.
     bool validateRenderingState();
 
     bool validateWebGLObject(const char*, WebGLObject*);
 
     // Adds a compressed texture format.
     void addCompressedTextureFormat(GC3Denum);
     void removeAllCompressedTextureFormats();
 
     PassRefPtr<Image> videoFrameToImage(HTMLVideoElement*, BackingStoreCopy);
 
     WebGLRenderbuffer* ensureEmulatedStencilBuffer(GC3Denum target, WebGLRenderbuffer*);
 
+    const String m_contextName;
+    unsigned m_featureLevel;
     RefPtr<GraphicsContext3D> m_context;
     RefPtr<WebGLContextGroup> m_contextGroup;
 
     // Structure for rendering to a DrawingBuffer, instead of directly
     // to the back-buffer of m_context.
     RefPtr<DrawingBuffer> m_drawingBuffer;
 
     // Dispatches a context lost event once it is determined that one is needed.
     // This is used both for synthetic and real context losses. For real ones, it's
     // likely that there's no JavaScript on the stack, but that might be dependent
     // on how exactly the platform discovers that the context was lost. For better
     // portability we always defer the dispatch of the event.
-    Timer<WebGLRenderingContext> m_dispatchContextLostEventTimer;
+    Timer<WebGLRenderingContextBase> m_dispatchContextLostEventTimer;
     bool m_restoreAllowed;
-    Timer<WebGLRenderingContext> m_restoreTimer;
+    Timer<WebGLRenderingContextBase> m_restoreTimer;
 
     bool m_needsUpdate;
     bool m_markedCanvasDirty;
     HashSet<WebGLContextObject*> m_contextObjects;
 
     // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
     RefPtr<WebGLBuffer> m_boundArrayBuffer;
 
     RefPtr<WebGLVertexArrayObjectOES> m_defaultVertexArrayObject;
     RefPtr<WebGLVertexArrayObjectOES> m_boundVertexArrayObject;
@@ skipping 44 matching lines @@
     RefPtr<WebGLTexture> m_blackTexture2D;
     RefPtr<WebGLTexture> m_blackTextureCubeMap;
 
     Vector<GC3Denum> m_compressedTextureFormats;
 
     // Fixed-size cache of reusable image buffers for video texImage2D calls.
     class LRUImageBufferCache {
     public:
         LRUImageBufferCache(int capacity);
         // The pointer returned is owned by the image buffer map.
-        ImageBuffer* imageBuffer(const IntSize& size);
+        ImageBuffer* imageBuffer(const IntSize&);
     private:
         void bubbleToFront(int idx);
         OwnArrayPtr<OwnPtr<ImageBuffer> > m_buffers;
         int m_capacity;
     };
     LRUImageBufferCache m_videoCache;
 
     GC3Dint m_maxTextureSize;
     GC3Dint m_maxCubeMapTextureSize;
     GC3Dint m_maxRenderbufferSize;
@@ skipping 35 matching lines @@
 
     bool m_synthesizedErrorsToConsole;
     int m_numGLErrorsToConsoleAllowed;
 
     bool m_multisamplingAllowed;
     bool m_multisamplingObserverRegistered;
 
     GC3Duint m_onePlusMaxEnabledAttribIndex;
     unsigned long m_onePlusMaxNonDefaultTextureUnit;
 
-    // Enabled extension objects.
-    RefPtr<ANGLEInstancedArrays> m_angleInstancedArrays;
-    RefPtr<EXTFragDepth> m_extFragDepth;
-    RefPtr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;
-    RefPtr<OESTextureFloat> m_oesTextureFloat;
-    RefPtr<OESTextureFloatLinear> m_oesTextureFloatLinear;
-    RefPtr<OESTextureHalfFloat> m_oesTextureHalfFloat;
-    RefPtr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;
-    RefPtr<OESStandardDerivatives> m_oesStandardDerivatives;
-    RefPtr<OESVertexArrayObject> m_oesVertexArrayObject;
-    RefPtr<OESElementIndexUint> m_oesElementIndexUint;
-    RefPtr<WebGLLoseContext> m_webglLoseContext;
-    RefPtr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;
-    RefPtr<WebGLDebugShaders> m_webglDebugShaders;
-    RefPtr<WebGLDrawBuffers> m_webglDrawBuffers;
-    RefPtr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
-    RefPtr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
-    RefPtr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
-    RefPtr<WebGLDepthTexture> m_webglDepthTexture;
-
     enum ExtensionFlags {
         ApprovedExtension   = 0x00,
         DraftExtension      = 0x01,
         PrivilegedExtension = 0x02,
         PrefixedExtension   = 0x04,
     };
 
     class ExtensionTracker {
     public:
         ExtensionTracker(ExtensionFlags flags, const char** prefixes)
@@ skipping 18 matching lines @@
             return m_privileged;
         }
 
         bool getDraft() const
         {
             return m_draft;
         }
 
         bool matchesNameWithPrefixes(const String&) const;
 
-        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContext*) const = 0;
-        virtual bool supported(WebGLRenderingContext*) const = 0;
+        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContextBase*) = 0;
+        virtual bool supported(WebGLRenderingContextBase*) const = 0;
         virtual const char* getExtensionName() const = 0;
         virtual void loseExtension() = 0;
 
     private:
         bool m_privileged;
         bool m_draft;
         bool m_prefixed;
         const char** m_prefixes;
     };
 
     template <typename T>
     class TypedExtensionTracker : public ExtensionTracker {
     public:
         TypedExtensionTracker(RefPtr<T>& extensionField, ExtensionFlags flags, const char** prefixes)
             : ExtensionTracker(flags, prefixes)
             , m_extensionField(extensionField)
+            , m_extension(0)
         {
         }
 
         ~TypedExtensionTracker()
         {
-            if (m_extensionField) {
-                m_extensionField->lose(true);
-                m_extensionField = 0;
+            if (m_extension) {
+                m_extension->lose(true);
+                m_extension = 0;
             }
         }
 
-        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContext* context) const
+        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContextBase* context)
         {
-            if (!m_extensionField)
-                m_extensionField = T::create(context);
+            if (!m_extension) {
+                m_extension = T::create(context);
+                m_extensionField = m_extension;
+            }
 
-            return m_extensionField;
+            return m_extension;
         }
 
-        virtual bool supported(WebGLRenderingContext* context) const
+        virtual bool supported(WebGLRenderingContextBase* context) const
         {
             return T::supported(context);
         }
 
         virtual const char* getExtensionName() const
         {
             return T::getExtensionName();
         }
 
         virtual void loseExtension()
         {
-            if (m_extensionField) {
-                m_extensionField->lose(false);
-                if (m_extensionField->isLost())
-                    m_extensionField = 0;
+            if (m_extension) {
+                m_extension->lose(false);
+                if (m_extension->isLost())
+                    m_extension = 0;
             }
         }
 
     private:
         RefPtr<T>& m_extensionField;
+        // ExtensionTracker holds it's own reference to the extension to ensure
+        // that it is not deleted before this object's destructor is called
+        RefPtr<T> m_extension;
     };
 
+    bool m_extensionEnabled[WebGLExtensionNameCount];
     Vector<ExtensionTracker*> m_extensions;
 
     template <typename T>
     void registerExtension(RefPtr<T>& extensionPtr, ExtensionFlags flags = ApprovedExtension, const char** prefixes = 0)
     {
         m_extensions.append(new TypedExtensionTracker<T>(extensionPtr, flags, prefixes));
     }
 
+    inline bool extensionEnabled(WebGLExtensionName name)

[bajones, 2013/09/24 00:12:01]

It turns out that every single use of the WebGL extension objects in the context
were nothing more than tests to see if the extension had been queried. As such
we can replace the extension objects in the base with a simple boolean check.
The extension objects now reside on WebGLRenderingContext where they arguably
belong.

+    {
+        return m_extensionEnabled[name];
+    }
+
     // Errors raised by synthesizeGLError() while the context is lost.
-    Vector<GC3Denum> lost_context_errors_;
+    Vector<GC3Denum> m_lostContextErrors;
 
     // Helpers for getParameter and others
     WebGLGetInfo getBooleanParameter(GC3Denum);
     WebGLGetInfo getBooleanArrayParameter(GC3Denum);
     WebGLGetInfo getFloatParameter(GC3Denum);
     WebGLGetInfo getIntParameter(GC3Denum);
     WebGLGetInfo getUnsignedIntParameter(GC3Denum);
     WebGLGetInfo getWebGLFloatArrayParameter(GC3Denum);
     WebGLGetInfo getWebGLIntArrayParameter(GC3Denum);
 
     // Clear the backbuffer if it was composited since the last operation.
     // clearMask is set to the bitfield of any clear that would happen anyway at this time
     // and the function returns true if that clear is now unnecessary.
     bool clearIfComposited(GC3Dbitfield clearMask = 0);
 
     // Helper to restore state that clearing the framebuffer may destroy.
     void restoreStateAfterClear();
 
     void texImage2DBase(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, const void* pixels, ExceptionState&);
     void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionState&);
     void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionState&);
     void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionState&);
 
     void handleTextureCompleteness(const char*, bool);
     void createFallbackBlackTextures1x1();
 
     // Helper function for copyTex{Sub}Image, check whether the internalformat
     // and the color buffer format of the current bound framebuffer combination
     // is valid.
-    bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat,
-                                                        GC3Denum colorBufferFormat);
+    bool isTexInternalFormatColorBufferCombinationValid(GC3Denum texInternalFormat, GC3Denum colorBufferFormat);
 
     // Helper function to get the bound framebuffer's color buffer format.
     GC3Denum getBoundFramebufferColorFormat();
 
     // Helper function to get the bound framebuffer's width.
     int getBoundFramebufferWidth();
 
     // Helper function to get the bound framebuffer's height.
     int getBoundFramebufferHeight();
 
     // Helper function to verify limits on the length of uniform and attribute locations.
     bool validateLocationLength(const char* functionName, const String&);
 
     // Helper function to check if size is non-negative.
     // Generate GL error and return false for negative inputs; otherwise, return true.
     bool validateSize(const char* functionName, GC3Dint x, GC3Dint y);
 
     // Helper function to check if all characters in the string belong to the
     // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.
     bool validateString(const char* functionName, const String&);
 
     // Helper function to check target and texture bound to the target.
     // Generate GL errors and return 0 if target is invalid or texture bound is
-    // null.  Otherwise, return the texture bound to the target.
+    // null. Otherwise, return the texture bound to the target.
     WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);
 
     // Helper function to check input format/type for functions {copy}Tex{Sub}Image.
     // Generates GL error and returns false if parameters are invalid.
     bool validateTexFuncFormatAndType(const char* functionName, GC3Denum format, GC3Denum type, GC3Dint level);
 
     // Helper function to check input level for functions {copy}Tex{Sub}Image.
     // Generates GL error and returns false if level is invalid.
     bool validateTexFuncLevel(const char* functionName, GC3Denum target, GC3Dint level);
 
@@ skipping 16 matching lines @@
         GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint xoffset, GC3Dint yoffset);
 
     // Helper function to check input width and height for functions {copy, compressed}Tex{Sub}Image.
     // Generates GL error and returns false if width or height is invalid.
     bool validateTexFuncDimensions(const char* functionName, TexFuncValidationFunctionType,
         GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height);
 
     // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
     // Generates GL error and returns false if parameters are invalid.
     bool validateTexFuncParameters(const char* functionName,
-                                   TexFuncValidationFunctionType,
-                                   GC3Denum target, GC3Dint level,
-                                   GC3Denum internalformat,
-                                   GC3Dsizei width, GC3Dsizei height, GC3Dint border,
-                                   GC3Denum format, GC3Denum type);
+        TexFuncValidationFunctionType,
+        GC3Denum target, GC3Dint level,
+        GC3Denum internalformat,
+        GC3Dsizei width, GC3Dsizei height, GC3Dint border,
+        GC3Denum format, GC3Denum type);
 
     enum NullDisposition {
         NullAllowed,
         NullNotAllowed
     };
 
     // Helper function to validate that the given ArrayBufferView
     // is of the correct type and contains enough data for the texImage call.
     // Generates GL error and returns false if parameters are invalid.
     bool validateTexFuncData(const char* functionName, GC3Dint level,
-                             GC3Dsizei width, GC3Dsizei height,
-                             GC3Denum format, GC3Denum type,
-                             ArrayBufferView* pixels,
-                             NullDisposition);
+        GC3Dsizei width, GC3Dsizei height,
+        GC3Denum format, GC3Denum type,
+        ArrayBufferView* pixels,
+        NullDisposition);
 
     // Helper function to validate a given texture format is settable as in
     // you can supply data to texImage2D, or call texImage2D, copyTexImage2D and
     // copyTexSubImage2D.
     // Generates GL error and returns false if the format is not settable.
     bool validateSettableTexFormat(const char* functionName, GC3Denum format);
 
     // Helper function to validate compressed texture data is correct size
     // for the given format and dimensions.
     bool validateCompressedTexFuncData(const char* functionName,
-                                       GC3Dsizei width, GC3Dsizei height,
-                                       GC3Denum format, ArrayBufferView* pixels);
+        GC3Dsizei width, GC3Dsizei height,
+        GC3Denum format, ArrayBufferView* pixels);
 
     // Helper function for validating compressed texture formats.
     bool validateCompressedTexFormat(GC3Denum format);
 
     // Helper function to validate compressed texture dimensions are valid for
     // the given format.
     bool validateCompressedTexDimensions(const char* functionName, TexFuncValidationFunctionType, GC3Denum target, GC3Dint level, GC3Dsizei width, GC3Dsizei height, GC3Denum format);
 
     // Helper function to validate compressed texture dimensions are valid for
     // the given format.
     bool validateCompressedTexSubDimensions(const char* functionName, GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset,
-                                            GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);
+        GC3Dsizei width, GC3Dsizei height, GC3Denum format, WebGLTexture*);
 
     // Helper function to validate mode for draw{Arrays/Elements}.
     bool validateDrawMode(const char* functionName, GC3Denum);
 
     // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.
     bool validateStencilSettings(const char* functionName);
 
     // Helper function to validate stencil or depth func.
     bool validateStencilOrDepthFunc(const char* functionName, GC3Denum);
 
@@ skipping 56 matching lines @@
 
     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
     // Return false if caller should return without further processing.
     bool deleteObject(WebGLObject*);
 
     // Helper function for bind* (bindBuffer, bindTexture, etc) and useProgram.
     // If the object has already been deleted, set deleted to true upon return.
     // Return false if caller should return without further processing.
     bool checkObjectToBeBound(const char* functionName, WebGLObject*, bool& deleted);
 
-    void dispatchContextLostEvent(Timer<WebGLRenderingContext>*);
+    void dispatchContextLostEvent(Timer<WebGLRenderingContextBase>*);
     // Helper for restoration after context lost.
-    void maybeRestoreContext(Timer<WebGLRenderingContext>*);
+    void maybeRestoreContext(Timer<WebGLRenderingContextBase>*);
 
     // Determine if we are running privileged code in the browser, for example,
     // a Safari or Chrome extension.
     bool allowPrivilegedExtensions() const;
 
     enum ConsoleDisplayPreference {
         DisplayInConsole,
         DontDisplayInConsole
     };
 
@@ skipping 25 matching lines @@
     void restoreCurrentTexture2D();
 
     virtual void multisamplingChanged(bool);
 
     void findNewMaxEnabledAttribIndex();
     void findNewMaxNonDefaultTextureUnit();
 
     friend class WebGLStateRestorer;
     friend class WebGLRenderingContextEvictionManager;
 
-    static Vector<WebGLRenderingContext*>& activeContexts();
-    static Vector<WebGLRenderingContext*>& forciblyEvictedContexts();
+    static Vector<WebGLRenderingContextBase*>& activeContexts();
+    static Vector<WebGLRenderingContextBase*>& forciblyEvictedContexts();
 
-    static void activateContext(WebGLRenderingContext*);
-    static void deactivateContext(WebGLRenderingContext*, bool addToInactiveList);
-    static void willDestroyContext(WebGLRenderingContext*);
+    static void activateContext(WebGLRenderingContextBase*);
+    static void deactivateContext(WebGLRenderingContextBase*, bool addToInactiveList);
+    static void willDestroyContext(WebGLRenderingContextBase*);
     static void forciblyLoseOldestContext(const String& reason);
     static IntSize oldestContextSize();
+
+    static GraphicsContext3D::Attributes adjustAttributes(const GraphicsContext3D::Attributes&, Settings*);
 };
 
 } // namespace WebCore
 
 #endif