Implement WEBGL_shared_resources

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 62 matching lines @@
 class WebGLDebugShaders;
 class WebGLDepthTexture;
 class WebGLExtension;
 class WebGLFramebuffer;
 class WebGLLoseContext;
 class WebGLObject;
 class WebGLProgram;
 class WebGLRenderbuffer;
 class WebGLShader;
 class WebGLSharedObject;
+class WebGLSharedResources;
 class WebGLShaderPrecisionFormat;
 class WebGLTexture;
 class WebGLUniformLocation;
 class WebGLVertexArrayObjectOES;
 
 typedef int ExceptionCode;
 
 class WebGLRenderingContext : public CanvasRenderingContext, public ActiveDOMObject, private Page::MultisamplingChangedObserver {
 public:
     static PassOwnPtr<WebGLRenderingContext> create(HTMLCanvasElement*, WebGLContextAttributes*);
     virtual ~WebGLRenderingContext();
 
     virtual bool is3d() const { return true; }
     virtual bool isAccelerated() const { return true; }
 
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
+    unsigned contextIndex() const;
+    unsigned resourceSyncCount() const;
+    void flushResourceChanges();
+
     void activeTexture(GC3Denum texture, ExceptionCode&);
     void attachShader(WebGLProgram*, WebGLShader*, ExceptionCode&);
     void bindAttribLocation(WebGLProgram*, GC3Duint index, const String& name, ExceptionCode&);
     void bindBuffer(GC3Denum target, WebGLBuffer*, ExceptionCode&);
     void bindFramebuffer(GC3Denum target, WebGLFramebuffer*, ExceptionCode&);
     void bindRenderbuffer(GC3Denum target, WebGLRenderbuffer*, ExceptionCode&);
     void bindTexture(GC3Denum target, WebGLTexture*, ExceptionCode&);
     void blendColor(GC3Dfloat red, GC3Dfloat green, GC3Dfloat blue, GC3Dfloat alpha);
     void blendEquation(GC3Denum mode);
     void blendEquationSeparate(GC3Denum modeRGB, GC3Denum modeAlpha);
@@ skipping 78 matching lines @@
     String getShaderSource(WebGLShader*, ExceptionCode&);
     Vector<String> getSupportedExtensions();
     WebGLGetInfo getTexParameter(GC3Denum target, GC3Denum pname, ExceptionCode&);
     WebGLGetInfo getUniform(WebGLProgram*, const WebGLUniformLocation*, ExceptionCode&);
     PassRefPtr<WebGLUniformLocation> getUniformLocation(WebGLProgram*, const String&, ExceptionCode&);
     WebGLGetInfo getVertexAttrib(GC3Duint index, GC3Denum pname, ExceptionCode&);
     long long getVertexAttribOffset(GC3Duint index, GC3Denum pname);
 
     void hint(GC3Denum target, GC3Denum mode);
     GC3Dboolean isBuffer(WebGLBuffer*);
-    bool isContextLost();
+    bool isContextLost() const;
     GC3Dboolean isEnabled(GC3Denum cap);
     GC3Dboolean isFramebuffer(WebGLFramebuffer*);
     GC3Dboolean isProgram(WebGLProgram*);
     GC3Dboolean isRenderbuffer(WebGLRenderbuffer*);
     GC3Dboolean isShader(WebGLShader*);
     GC3Dboolean isTexture(WebGLTexture*);
 
     void lineWidth(GC3Dfloat);
     void linkProgram(WebGLProgram*, ExceptionCode&);
     void pixelStorei(GC3Denum pname, GC3Dint param);
@@ skipping 83 matching lines @@
     void vertexAttrib4f(GC3Duint index, GC3Dfloat x, GC3Dfloat y, GC3Dfloat z, GC3Dfloat w);
     void vertexAttrib4fv(GC3Duint index, Float32Array* values);
     void vertexAttrib4fv(GC3Duint index, GC3Dfloat* values, GC3Dsizei size);
     void vertexAttribPointer(GC3Duint index, GC3Dint size, GC3Denum type, GC3Dboolean normalized,
                              GC3Dsizei stride, long long offset, ExceptionCode&);
 
     void vertexAttribDivisorANGLE(GC3Duint index, GC3Duint divisor);
 
     void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
 
+    long acquireSharedResource(WebGLSharedObject*, WebGLSharedObject::AcquireMode, PassRefPtr<WebGLAcquireSharedResourceCallback>, ExceptionCode&);
+    void releaseSharedResource(WebGLSharedObject*, ExceptionCode&);
+    void cancelAcquireSharedResource(long);
+
     // WEBKIT_lose_context support
     enum LostContextMode {
         // Lost context occurred at the graphics system level.
         RealLostContext,
 
         // Lost context provoked by WEBKIT_lose_context.
         SyntheticLostContext,
 
         // A synthetic lost context that should attempt to recover automatically
         AutoRecoverSyntheticLostContext
@@ skipping 14 matching lines @@
 
     void removeSharedObject(WebGLSharedObject*);
     void removeContextObject(WebGLContextObject*);
     
     unsigned getMaxVertexAttribs() const { return m_maxVertexAttribs; }
 
     // ActiveDOMObject notifications
     virtual bool hasPendingActivity() const;
     virtual void stop();
 
+    enum ConsoleDisplayPreference {
+        DisplayInConsole,
+        DontDisplayInConsole
+    };
+
+    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message
+    // to the JavaScript console.
+    void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
+
   private:
     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);
+    WebGLRenderingContext(HTMLCanvasElement*, PassRefPtr<GraphicsContext3D>, GraphicsContext3D::Attributes, GraphicsContext3D::Attributes, PassRefPtr<WebGLContextGroup>);
     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);
 
     // Check if each enabled vertex attribute is bound to a buffer.
-    bool validateRenderingState();
+    bool validateRenderingState(const char*);
 
-    bool validateWebGLObject(const char*, WebGLObject*);
+    bool validateWebGLContextObject(const char*, WebGLContextObject*);
+    bool validateWebGLSharedObject(const char*, WebGLSharedObject*, WebGLSharedObject::AcquireMode);
 
     // Adds a compressed texture format.
     void addCompressedTextureFormat(GC3Denum);
     void removeAllCompressedTextureFormats();
 
+    WebGLBuffer* getBufferForTarget(const char* functionName, GC3Denum target);
+
     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.
     RefPtr<DrawingBuffer> m_drawingBuffer;
@@ skipping 132 matching lines @@
     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;
+    RefPtr<WebGLSharedResources> m_webglSharedResources;
 
     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)
         {
         }
@@ skipping 92 matching lines @@
 
     // 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);
 
+    bool isAcquiredForModification(const char*, WebGLSharedObject*);
+    bool isAcquiredForReading(const char*, WebGLSharedObject*);
+
     // 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, ExceptionCode&);
     void texImage2DImpl(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
     void texSubImage2DBase(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Dsizei width, GC3Dsizei height, GC3Denum format, GC3Denum type, const void* pixels, ExceptionCode&);
     void texSubImage2DImpl(GC3Denum target, GC3Dint level, GC3Dint xoffset, GC3Dint yoffset, GC3Denum format, GC3Denum type, Image*, GraphicsContext3D::ImageHtmlDomSource, bool flipY, bool premultiplyAlpha, ExceptionCode&);
 
-    void handleTextureCompleteness(const char*, bool);
+    bool handleTextureCompleteness(const char*, bool, 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);
 
     // Helper function to get the bound framebuffer's color buffer format.
     GC3Denum getBoundFramebufferColorFormat();
@@ skipping 11 matching lines @@
     // 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.
-    WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap);
+    WebGLTexture* validateTextureBinding(const char* functionName, GC3Denum target, bool useSixEnumsForCubeMap, WebGLSharedObject::AcquireMode);
 
     // 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);
 
     enum TexFuncValidationFunctionType {
@@ skipping 88 matching lines @@
     // Helper function to validate blend equation mode.
     bool validateBlendEquation(const char* functionName, GC3Denum);
 
     // Helper function to validate blend func factors.
     bool validateBlendFuncFactors(const char* functionName, GC3Denum src, GC3Denum dst);
 
     // Helper function to validate a GL capability.
     bool validateCapability(const char* functionName, GC3Denum);
 
     // Helper function to validate input parameters for uniform functions.
+    bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*);
     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Float32Array*, GC3Dsizei mod);
     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, Int32Array*, GC3Dsizei mod);
     bool validateUniformParameters(const char* functionName, const WebGLUniformLocation*, void*, GC3Dsizei, GC3Dsizei mod);
     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, Float32Array*, GC3Dsizei mod);
     bool validateUniformMatrixParameters(const char* functionName, const WebGLUniformLocation*, GC3Dboolean transpose, void*, GC3Dsizei, GC3Dsizei mod);
 
     // Helper function to validate parameters for bufferData.
     // Return the current bound buffer to target, or 0 if parameters are invalid.
     WebGLBuffer* validateBufferDataParameters(const char* functionName, GC3Denum target, GC3Denum usage);
 
@@ skipping 15 matching lines @@
     // Helper function to validate draw*Instanced calls
     bool validateDrawInstanced(const char* functionName, GC3Dsizei primcount);
 
     // Helper functions for vertexAttribNf{v}.
     void vertexAttribfImpl(const char* functionName, GC3Duint index, GC3Dsizei expectedSize, GC3Dfloat, GC3Dfloat, GC3Dfloat, GC3Dfloat);
     void vertexAttribfvImpl(const char* functionName, GC3Duint index, Float32Array*, GC3Dsizei expectedSize);
     void vertexAttribfvImpl(const char* functionName, GC3Duint index, GC3Dfloat*, GC3Dsizei, GC3Dsizei expectedSize);
 
     // Helper function for delete* (deleteBuffer, deleteProgram, etc) functions.
     // Return false if caller should return without further processing.
-    bool deleteObject(WebGLObject*);
+    bool deleteContextObject(const char* functionName, WebGLContextObject*);
+    bool deleteSharedObject(const char* functionName, WebGLSharedObject*);
 
     // 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);
+    bool checkContextObjectToBeBound(const char* functionName, WebGLContextObject*, bool& deleted);
+    bool checkSharedObjectToBeBound(const char* functionName, WebGLSharedObject*, bool& deleted, bool& boundSinceLastAcquire);
 
     void dispatchContextLostEvent(Timer<WebGLRenderingContext>*);
     // Helper for restoration after context lost.
     void maybeRestoreContext(Timer<WebGLRenderingContext>*);
 
     // Determine if we are running privileged code in the browser, for example,
     // a Safari or Chrome extension.
     bool allowPrivilegedExtensions() const;
 
-    enum ConsoleDisplayPreference {
-        DisplayInConsole,
-        DontDisplayInConsole
-    };
-
-    // Wrapper for GraphicsContext3D::synthesizeGLError that sends a message
-    // to the JavaScript console.
-    void synthesizeGLError(GC3Denum, const char* functionName, const char* description, ConsoleDisplayPreference = DisplayInConsole);
-
     String ensureNotNull(const String&) const;
 
     // Enable or disable stencil test based on user setting and
     // whether the current FBO has a stencil buffer.
     void applyStencilTest();
 
     // Helper for enabling or disabling a capability.
     void enableOrDisable(GC3Denum capability, bool enable);
 
     // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.
@@ skipping 22 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