Merged GraphicsContext3DPrivate into GraphicsContext3D

Source/core/platform/graphics/GraphicsContext3D.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 GraphicsContext3D_h
 #define GraphicsContext3D_h
 
+#include "SkBitmap.h"
 #include "core/platform/KURL.h"
+#include "core/platform/graphics/Extensions3D.h"
 #include "core/platform/graphics/GraphicsTypes3D.h"
 #include "core/platform/graphics/Image.h"
 #include "core/platform/graphics/IntRect.h"
 #include "core/platform/graphics/PlatformLayer.h"
-#include <wtf/HashMap.h>
-#include <wtf/ListHashSet.h>
-#include <wtf/Noncopyable.h>
-#include <wtf/OwnArrayPtr.h>
-#include <wtf/PassOwnArrayPtr.h>
-#include <wtf/RefCounted.h>
-#include <wtf/text/WTFString.h>
+#include "wtf/HashMap.h"
+#include "wtf/HashSet.h"
+#include "wtf/ListHashSet.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/OwnArrayPtr.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnArrayPtr.h"
+#include "wtf/RefCounted.h"
+#include "wtf/text/WTFString.h"
 
 // FIXME: Find a better way to avoid the name confliction for NO_ERROR.
 #if OS(WINDOWS)
 #undef NO_ERROR
 #endif
 
 class GrContext;
 
+namespace WebKit {
+class WebGraphicsContext3D;
+class WebGraphicsContext3DProvider;
+}
+
 namespace WebCore {
 class DrawingBuffer;
 class Extensions3D;
+class GraphicsContext3DContextLostCallbackAdapter;
+class GraphicsContext3DErrorMessageCallbackAdapter;
+class GrMemoryAllocationChangedCallbackAdapter;
 class Image;
 class ImageBuffer;
 class ImageData;
 class IntRect;
 class IntSize;
 
 struct ActiveInfo {
     String name;
     GC3Denum type;
     GC3Dint size;
 };
 
-class GraphicsContext3DPrivate;
-
 class GraphicsContext3D : public RefCounted<GraphicsContext3D> {
 public:
     enum {
         DEPTH_BUFFER_BIT = 0x00000100,
         STENCIL_BUFFER_BIT = 0x00000400,
         COLOR_BUFFER_BIT = 0x00004000,
         POINTS = 0x0000,
         LINES = 0x0001,
         LINE_LOOP = 0x0002,
         LINE_STRIP = 0x0003,
@@ skipping 339 matching lines @@
     class ErrorMessageCallback {
     public:
         virtual void onErrorMessage(const String& message, GC3Dint id) = 0;
         virtual ~ErrorMessageCallback() { }
     };
 
     void setContextLostCallback(PassOwnPtr<ContextLostCallback>);
     void setErrorMessageCallback(PassOwnPtr<ErrorMessageCallback>);
 
     static PassRefPtr<GraphicsContext3D> create(Attributes);
-    static PassRefPtr<GraphicsContext3D> createForCurrentGLContext();
+
+    // Callers must make the context current before using it AND check that the context was created successfully
+    // via ContextLost before using the context in any way. Once made current on a thread, the context cannot
+    // be used on any other thread.
+    static PassRefPtr<GraphicsContext3D> createGraphicsContextFromWebContext(PassOwnPtr<WebKit::WebGraphicsContext3D>, bool preserveDrawingBuffer = false);
+    static PassRefPtr<GraphicsContext3D> createGraphicsContextFromProvider(PassOwnPtr<WebKit::WebGraphicsContext3DProvider>, bool preserveDrawingBuffer = false);
+
     ~GraphicsContext3D();
 
     GrContext* grContext();
+    WebKit::WebGraphicsContext3D* webContext() const { return m_impl; }
+
+    // Helper function to provide access to the lower-level WebGraphicsContext3D,
+    // which is needed for subordinate contexts like WebGL's to share resources
+    // with the compositor's context.
+    static WebKit::WebGraphicsContext3D* extractWebGraphicsContext3D(GraphicsContext3D*);

[Zhenyao Mo, 2013/05/17 19:38:46]

This is no longer needed.  You can just use webContext().

+
     bool makeContextCurrent();
 
     // Helper to texImage2D with pixel==0 case: pixels are initialized to 0.
     // Return true if no GL error is synthesized.
     // By default, alignment is 4, the OpenGL default setting.
     bool texImage2DResourceSafe(GC3Denum target, GC3Dint level, GC3Denum internalformat, GC3Dsizei width, GC3Dsizei height, GC3Dint border, GC3Denum format, GC3Denum type, GC3Dint alignment = 4);
 
     //----------------------------------------------------------------------
     // Helpers for texture uploading and pixel readback.
     //
@@ skipping 232 matching lines @@
     void viewport(GC3Dint x, GC3Dint y, GC3Dsizei width, GC3Dsizei height);
 
     void reshape(int width, int height);
 
     void markContextChanged();
     void markLayerComposited();
     bool layerComposited() const;
 
     void paintRenderingResultsToCanvas(ImageBuffer*, DrawingBuffer*);
     PassRefPtr<ImageData> paintRenderingResultsToImageData(DrawingBuffer*);
-    bool paintCompositedResultsToCanvas(ImageBuffer*);
 
     // Support for buffer creation and deletion
     Platform3DObject createBuffer();
     Platform3DObject createFramebuffer();
     Platform3DObject createProgram();
     Platform3DObject createRenderbuffer();
     Platform3DObject createShader(GC3Denum);
     Platform3DObject createTexture();
 
     void deleteBuffer(Platform3DObject);
@@ skipping 82 matching lines @@
         bool m_extractSucceeded;
         const void* m_imagePixelData;
         unsigned m_imageWidth;
         unsigned m_imageHeight;
         DataFormat m_imageSourceFormat;
         AlphaOp m_alphaOp;
         unsigned m_imageSourceUnpackAlignment;
     };
 
 private:
-    GraphicsContext3D();
+    friend class Extensions3D;
+
+    GraphicsContext3D(PassOwnPtr<WebKit::WebGraphicsContext3D>, bool preserveDrawingBuffer);
+    GraphicsContext3D(PassOwnPtr<WebKit::WebGraphicsContext3DProvider>, bool preserveDrawingBuffer);
 
     // Helper for packImageData/extractImageData/extractTextureData which implement packing of pixel
     // data into the specified OpenGL destination format and type.
     // A sourceUnpackAlignment of zero indicates that the source
     // data is tightly packed. Non-zero values may take a slow path.
     // Destination data will have no gaps between rows.
     static bool packPixels(const uint8_t* sourceData, DataFormat sourceDataFormat, unsigned width, unsigned height, unsigned sourceUnpackAlignment, unsigned destinationFormat, unsigned destinationType, AlphaOp, void* destinationData, bool flipY);
 
+    void paintFramebufferToCanvas(int framebuffer, int width, int height, bool premultiplyAlpha, ImageBuffer*);
+
+    // Extensions3D support.
+    bool supportsExtension(const String& name);
+    bool ensureExtensionEnabled(const String& name);
+    bool isExtensionEnabled(const String& name);
+
+    void initializeExtensions();
+
     bool isResourceSafe();
 
-    friend class GraphicsContext3DPrivate;
-    OwnPtr<GraphicsContext3DPrivate> m_private;
+    bool preserveDrawingBuffer() const { return m_preserveDrawingBuffer; }
+
+    OwnPtr<WebKit::WebGraphicsContext3DProvider> m_provider;
+    WebKit::WebGraphicsContext3D* m_impl;
+    OwnPtr<WebKit::WebGraphicsContext3D> m_ownedWebContext;
+    OwnPtr<Extensions3D> m_extensions;
+    OwnPtr<GraphicsContext3DContextLostCallbackAdapter> m_contextLostCallbackAdapter;
+    OwnPtr<GraphicsContext3DErrorMessageCallbackAdapter> m_errorMessageCallbackAdapter;
+    OwnPtr<GrMemoryAllocationChangedCallbackAdapter> m_grContextMemoryAllocationCallbackAdapter;
+    bool m_initializedAvailableExtensions;
+    HashSet<String> m_enabledExtensions;
+    HashSet<String> m_requestableExtensions;
+    bool m_layerComposited;
+    bool m_preserveDrawingBuffer;
+
+    enum ResourceSafety {
+        ResourceSafetyUnknown,
+        ResourceSafe,
+        ResourceUnsafe
+    };
+    ResourceSafety m_resourceSafety;
+
+    // If the width and height of the Canvas's backing store don't
+    // match those that we were given in the most recent call to
+    // reshape(), then we need an intermediate bitmap to read back the
+    // frame buffer into. This seems to happen when CSS styles are
+    // used to resize the Canvas.
+    SkBitmap m_resizingBitmap;
+
+    GrContext* m_grContext;
+    SkAutoTUnref<GrContext> m_ownedGrContext;
 };
 
 } // namespace WebCore
 
 #endif // GraphicsContext3D_h