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.
- */
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
 
-#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/WebGLExtensionName.h"
 #include "core/html/canvas/WebGLGetInfo.h"
 #include "core/page/Page.h"
 #include "platform/Timer.h"
 #include "platform/graphics/GraphicsTypes3D.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/graphics/gpu/WebGLImageConversion.h"
 #include "public/platform/WebGraphicsContext3D.h"
 #include "wtf/Float32Array.h"
 #include "wtf/Int32Array.h"
@@ skipping 44 matching lines @@
 class WebGLShader;
 class WebGLShaderPrecisionFormat;
 class WebGLSharedObject;
 class WebGLTexture;
 class WebGLUniformLocation;
 class WebGLVertexArrayObjectOES;
 
 class WebGLRenderingContextLostCallback;
 class WebGLRenderingContextErrorMessageCallback;
 
-class WebGLRenderingContext FINAL : 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 OVERRIDE { return true; }
     virtual bool isAccelerated() const OVERRIDE { return true; }
+    virtual unsigned version() const = 0;
+    virtual String contextName() const = 0;
+    virtual void registerContextExtensions() = 0;
+
+    static unsigned getWebGLVersion(CanvasRenderingContext*);
 
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
     void activeTexture(GLenum texture);
     void attachShader(WebGLProgram*, WebGLShader*);
     void bindAttribLocation(WebGLProgram*, GLuint index, const String& name);
     void bindBuffer(GLenum target, WebGLBuffer*);
     void bindFramebuffer(GLenum target, WebGLFramebuffer*);
     void bindRenderbuffer(GLenum target, WebGLRenderbuffer*);
@@ skipping 219 matching lines @@
 
     void removeSharedObject(WebGLSharedObject*);
     void removeContextObject(WebGLContextObject*);
 
     unsigned maxVertexAttribs() const { return m_maxVertexAttribs; }
 
     // ActiveDOMObject notifications
     virtual bool hasPendingActivity() const OVERRIDE;
     virtual void stop() OVERRIDE;
 
-  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*, PassOwnPtr<blink::WebGraphicsContext3D>, WebGLContextAttributes*);
+    WebGLRenderingContextBase(HTMLCanvasElement*, PassOwnPtr<blink::WebGraphicsContext3D>, WebGLContextAttributes*);
     void initializeNewContext();
     void setupFlags();
 
     void addSharedObject(WebGLSharedObject*);
     void addContextObject(WebGLContextObject*);
     void detachAndRemoveAllObjects();
 
     void destroyContext();
     void markContextChanged();
 
@@ skipping 26 matching lines @@
 
     // 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;
 
     OwnPtr<WebGLRenderingContextLostCallback> m_contextLostCallbackAdapter;
     OwnPtr<WebGLRenderingContextErrorMessageCallback> m_errorMessageCallbackAdapter;
 
     // 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;
@@ skipping 105 matching lines @@
 
     bool m_multisamplingAllowed;
     bool m_multisamplingObserverRegistered;
 
     GLuint m_onePlusMaxEnabledAttribIndex;
     unsigned long m_onePlusMaxNonDefaultTextureUnit;
 
     bool m_preserveDrawingBuffer;
     OwnPtr<Extensions3DUtil> m_extensionsUtil;
 
-    // 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,
         WebGLDebugRendererInfoExtension = 0x08,
     };
 
     class ExtensionTracker {
     public:
@@ skipping 25 matching lines @@
             return m_draft;
         }
 
         bool webglDebugRendererInfo() const
         {
             return m_webglDebugRendererInfo;
         }
 
         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* extensionName() const = 0;
         virtual void loseExtension() = 0;
 
     private:
         bool m_privileged;
         bool m_draft;
         bool m_prefixed;
         bool m_webglDebugRendererInfo;
         const char* const* m_prefixes;
     };
 
     template <typename T>
     class TypedExtensionTracker FINAL : public ExtensionTracker {
     public:
         TypedExtensionTracker(RefPtr<T>& extensionField, ExtensionFlags flags, const char* const* 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 OVERRIDE
+        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContextBase* context) OVERRIDE
         {
-            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 OVERRIDE
+        virtual bool supported(WebGLRenderingContextBase* context) const OVERRIDE
         {
             return T::supported(context);
         }
 
         virtual const char* extensionName() const OVERRIDE
         {
             return T::extensionName();
         }
 
         virtual void loseExtension() OVERRIDE
         {
-            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* const* prefixes = 0)
     {
         m_extensions.append(new TypedExtensionTracker<T>(extensionPtr, flags, prefixes));
     }
 
+    inline bool extensionEnabled(WebGLExtensionName name)
+    {
+        return m_extensionEnabled[name];
+    }
+
     // Errors raised by synthesizeGLError() while the context is lost.
     Vector<GLenum> m_lostContextErrors;
 
     // Helpers for getParameter and others
     WebGLGetInfo getBooleanParameter(GLenum);
     WebGLGetInfo getBooleanArrayParameter(GLenum);
     WebGLGetInfo getFloatParameter(GLenum);
     WebGLGetInfo getIntParameter(GLenum);
     WebGLGetInfo getUnsignedIntParameter(GLenum);
     WebGLGetInfo getWebGLFloatArrayParameter(GLenum);
@@ skipping 181 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;
 
     // Determine if WEBGL_debug_renderer_info extension is enabled. For the
     // moment it can be enabled either through a chromium finch experiment
     // or for privileged code in the browser.
     bool allowWebGLDebugRendererInfo() const;
 
@@ skipping 30 matching lines @@
     void restoreCurrentTexture2D();
 
     virtual void multisamplingChanged(bool) OVERRIDE;
 
     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);
     // Return the least recently used context's position in the active context vector.
     // If the vector is empty, return the maximum allowed active context number.
     static size_t oldestContextIndex();
     static IntSize oldestContextSize();
 };
 
-DEFINE_TYPE_CASTS(WebGLRenderingContext, CanvasRenderingContext, context, context->is3d(), context.is3d());
+DEFINE_TYPE_CASTS(WebGLRenderingContextBase, CanvasRenderingContext, context, context->is3d(), context.is3d());
 
 } // namespace WebCore
 
-#endif
+#endif // WebGLRenderingContextBase_h