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 346 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&);
 
     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;
 
@@ skipping 114 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<EXTDrawBuffers> m_extDrawBuffers;
-    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<WebGLCompressedTextureATC> m_webglCompressedTextureATC;
-    OwnPtr<WebGLCompressedTexturePVRTC> m_webglCompressedTexturePVRTC;
-    OwnPtr<WebGLCompressedTextureS3TC> m_webglCompressedTextureS3TC;
-    OwnPtr<WebGLDepthTexture> m_webglDepthTexture;
+    EXTDrawBuffers* m_extDrawBuffers;
+    EXTTextureFilterAnisotropic* m_extTextureFilterAnisotropic;
+    OESTextureFloat* m_oesTextureFloat;
+    OESTextureFloatLinear* m_oesTextureFloatLinear;
+    OESTextureHalfFloat* m_oesTextureHalfFloat;
+    OESTextureHalfFloatLinear* m_oesTextureHalfFloatLinear;
+    OESStandardDerivatives* m_oesStandardDerivatives;
+    OESVertexArrayObject* m_oesVertexArrayObject;
+    OESElementIndexUint* m_oesElementIndexUint;
+    WebGLLoseContext* m_webglLoseContext;
+    WebGLDebugRendererInfo* m_webglDebugRendererInfo;
+    WebGLDebugShaders* m_webglDebugShaders;
+    WebGLCompressedTextureATC* m_webglCompressedTextureATC;
+    WebGLCompressedTexturePVRTC* m_webglCompressedTexturePVRTC;
+    WebGLCompressedTextureS3TC* m_webglCompressedTextureS3TC;
+    WebGLDepthTexture* m_webglDepthTexture;
 
     class ExtensionTracker {
     public:
         ExtensionTracker(bool privileged, bool prefixed, const char** prefixes)
             : m_privileged(privileged)
             , m_prefixed(prefixed)
             , m_prefixes(prefixes)
         {
         }
 
+        virtual ~ExtensionTracker()
+        {
+        }
+
         bool getPrefixed() const
         {
             return m_prefixed;
         }
 
         bool getPrivileged() const
         {
             return m_privileged;
         }
 
         bool matchesNameWithPrefixes(const String&) const;
 
-        virtual WebGLExtension* getExtension(WebGLRenderingContext*) const = 0;
+        virtual WebGLExtension* getExtension(WebGLRenderingContext*) = 0;
         virtual bool supported(WebGLRenderingContext*) const = 0;
         virtual const char* getExtensionName() const = 0;
+        virtual void loseExtension() = 0;
 
     private:
         bool m_privileged;
         bool m_prefixed;
         const char** m_prefixes;
     };
 
+    // This class owns the extension and keeps a reference to the
+    // WebGLRenderingContext field the same extension.
     template <typename T>
     class TypedExtensionTracker : public ExtensionTracker {
     public:
-        TypedExtensionTracker(OwnPtr<T>& extensionField, bool privileged, bool prefixed, const char** prefixes)
+        TypedExtensionTracker(T*& extensionField, bool privileged, bool prefixed, const char** prefixes)
             : ExtensionTracker(privileged, prefixed, prefixes)
             , m_extensionField(extensionField)
         {
+            m_extensionField = 0;
         }
 
-        virtual WebGLExtension* getExtension(WebGLRenderingContext* context) const
+        virtual WebGLExtension* getExtension(WebGLRenderingContext* context)
         {
-            if (!m_extensionField)
-                m_extensionField = T::create(context);
+            if (!m_extension)
+                m_extension = T::create(context);

[Ken Russell (switch to Gerrit), 2013/06/05 00:46:38]

Should this also call m_extension->enable()? That would avoid calling enable()
in the constructors of all of the extensions. Calling virtual functions from a
constructor is dangerous in general.

 
-            return m_extensionField.get();
+            if (m_extension->isLost())
+                m_extension->restore();
+
+            m_extensionField = m_extension.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()
+        {
+            m_extensionField = 0; // removes the extension's field from WebGLRenderingContext
+            if (m_extension)
+                m_extension->lose();
+        }
+
     private:
-        OwnPtr<T>& m_extensionField;
+        T*& m_extensionField; // reference to the typed field in WebGLRenderingContext
+        OwnPtr<T> m_extension;
     };
 
     Vector<ExtensionTracker*> m_extensions;
 
     template <typename T>
-    void registerExtension(OwnPtr<T>& extensionPtr, bool privileged, bool prefixed, const char** prefixes)
+    void registerExtension(T*& extensionPtr, bool privileged, bool prefixed, const char** prefixes)
     {
         m_extensions.append(new TypedExtensionTracker<T>(extensionPtr, privileged, 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