Make WebGL extensions get lost when context is lost.

Source/core/html/canvas/WebGLRenderingContext.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
@@ skipping 155 matching lines @@
     void frontFace(GC3Denum mode);
     void generateMipmap(GC3Denum target);
 
     PassRefPtr<WebGLActiveInfo> getActiveAttrib(WebGLProgram*, GC3Duint index, ExceptionCode&);
     PassRefPtr<WebGLActiveInfo> getActiveUniform(WebGLProgram*, GC3Duint index, ExceptionCode&);
     bool getAttachedShaders(WebGLProgram*, Vector<RefPtr<WebGLShader> >&, ExceptionCode&);
     GC3Dint getAttribLocation(WebGLProgram*, const String& name);
     WebGLGetInfo getBufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
     PassRefPtr<WebGLContextAttributes> getContextAttributes();
     GC3Denum getError();
-    WebGLExtension* getExtension(const String& name);
+    PassRefPtr<WebGLExtension> getExtension(const String& name);
     WebGLGetInfo getFramebufferAttachmentParameter(GC3Denum target, GC3Denum attachment, GC3Denum pname, ExceptionCode&);
     WebGLGetInfo getParameter(GC3Denum pname, ExceptionCode&);
     WebGLGetInfo getProgramParameter(WebGLProgram*, GC3Denum pname, ExceptionCode&);
     String getProgramInfoLog(WebGLProgram*, ExceptionCode&);
     WebGLGetInfo getRenderbufferParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
     WebGLGetInfo getShaderParameter(WebGLShader*, GC3Denum pname, ExceptionCode&);
     String getShaderInfoLog(WebGLShader*, ExceptionCode&);
     PassRefPtr<WebGLShaderPrecisionFormat> getShaderPrecisionFormat(GC3Denum shaderType, GC3Denum precisionType, ExceptionCode&);
     String getShaderSource(WebGLShader*, ExceptionCode&);
     Vector<String> getSupportedExtensions();
@@ skipping 173 matching lines @@
     // like GL_FLOAT, GL_INT, etc.
     unsigned int 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, ExceptionCode&);
 
     WebGLRenderbuffer* ensureEmulatedStencilBuffer(GC3Denum target, WebGLRenderbuffer*);
 
     RefPtr<GraphicsContext3D> m_context;
     RefPtr<WebGLContextGroup> m_contextGroup;
 
     // Structure for rendering to a DrawingBuffer, instead of directly
     // to the back-buffer of m_context.
@@ skipping 116 matching lines @@
     GC3Duint m_stencilFuncMask, m_stencilFuncMaskBack;
 
     bool m_isGLES2NPOTStrict;
     bool m_isDepthStencilSupported;
     bool m_isRobustnessEXTSupported;
 
     bool m_synthesizedErrorsToConsole;
     int m_numGLErrorsToConsoleAllowed;
 
     // Enabled extension objects.
-    OwnPtr<EXTFragDepth> m_extFragDepth;
-    OwnPtr<EXTTextureFilterAnisotropic> m_extTextureFilterAnisotropic;
-    OwnPtr<OESTextureFloat> m_oesTextureFloat;
-    OwnPtr<OESTextureFloatLinear> m_oesTextureFloatLinear;
-    OwnPtr<OESTextureHalfFloat> m_oesTextureHalfFloat;
-    OwnPtr<OESTextureHalfFloatLinear> m_oesTextureHalfFloatLinear;
-    OwnPtr<OESStandardDerivatives> m_oesStandardDerivatives;
-    OwnPtr<OESVertexArrayObject> m_oesVertexArrayObject;
-    OwnPtr<OESElementIndexUint> m_oesElementIndexUint;
-    OwnPtr<WebGLLoseContext> m_webglLoseContext;
-    OwnPtr<WebGLDebugRendererInfo> m_webglDebugRendererInfo;
-    OwnPtr<WebGLDebugShaders> m_webglDebugShaders;
-    OwnPtr<WebGLDrawBuffers> m_webglDrawBuffers;
-    OwnPtr<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
-    OwnPtr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
-    OwnPtr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
-    OwnPtr<WebGLDepthTexture> m_webglDepthTexture;
+    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;
 
     class ExtensionTracker {
     public:
         ExtensionTracker(bool privileged, bool draft, bool prefixed, const char** prefixes)
             : m_privileged(privileged)
             , m_draft(draft)
             , m_prefixed(prefixed)
             , m_prefixes(prefixes)
         {
         }
 
+        virtual ~ExtensionTracker()
+        {
+        }
+
         bool getPrefixed() const
         {
             return m_prefixed;
         }
 
         bool getPrivileged() const
         {
             return m_privileged;
         }
 
         bool getDraft() const
         {
             return m_draft;
         }
 
         bool matchesNameWithPrefixes(const String&) const;
 
-        virtual WebGLExtension* getExtension(WebGLRenderingContext*) const = 0;
+        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContext*) const = 0;
         virtual bool supported(WebGLRenderingContext*) 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(OwnPtr<T>& extensionField, bool privileged, bool draft, bool prefixed, const char** prefixes)
+        TypedExtensionTracker(RefPtr<T>& extensionField, bool privileged, bool draft, bool prefixed, const char** prefixes)
             : ExtensionTracker(privileged, draft, prefixed, prefixes)
             , m_extensionField(extensionField)
         {
         }
 
-        virtual WebGLExtension* getExtension(WebGLRenderingContext* context) const
+        ~TypedExtensionTracker()
+        {
+            if (m_extensionField) {
+                m_extensionField->lose(true);
+                m_extensionField = 0;
+            }
+        }
+
+        virtual PassRefPtr<WebGLExtension> getExtension(WebGLRenderingContext* context) const
         {
             if (!m_extensionField)
                 m_extensionField = T::create(context);
 
-            return m_extensionField.get();
+            return m_extensionField;
         }
 
         virtual bool supported(WebGLRenderingContext* 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;
+            }
+        }
+
     private:
-        OwnPtr<T>& m_extensionField;
+        RefPtr<T>& m_extensionField;
     };
 
     Vector<ExtensionTracker*> m_extensions;
 
     template <typename T>
-    void registerExtension(OwnPtr<T>& extensionPtr, bool privileged, bool draft, bool prefixed, const char** prefixes)
+    void registerExtension(RefPtr<T>& extensionPtr, bool privileged, bool draft, bool prefixed, const char** prefixes)
     {
         m_extensions.append(new TypedExtensionTracker<T>(extensionPtr, privileged, draft, prefixed, prefixes));
     }
 
     // Errors raised by synthesizeGLError() while the context is lost.
     Vector<GC3Denum> lost_context_errors_;
 
     // Helpers for getParameter and others
     WebGLGetInfo getBooleanParameter(GC3Denum);
     WebGLGetInfo getBooleanArrayParameter(GC3Denum);
@@ skipping 242 matching lines @@
     static void activateContext(WebGLRenderingContext*);
     static void deactivateContext(WebGLRenderingContext*, bool addToInactiveList);
     static void willDestroyContext(WebGLRenderingContext*);
     static void forciblyLoseOldestContext(const String& reason);
     static IntSize oldestContextSize();
 };
 
 } // namespace WebCore
 
 #endif