Implement OffscreenCanvas.getContext('webgl')

third_party/WebKit/Source/modules/webgl/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
@@ skipping 17 matching lines @@
 
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/CoreExport.h"
 #include "core/dom/DOMTypedArray.h"
 #include "core/dom/TypedFlexibleArrayBufferView.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
 #include "core/layout/LayoutBoxModelObject.h"
+#include "modules/offscreencanvas/OffscreenCanvasRenderingContext.h"
 #include "modules/webgl/WebGLContextAttributes.h"
 #include "modules/webgl/WebGLExtensionName.h"
 #include "modules/webgl/WebGLTexture.h"
 #include "modules/webgl/WebGLVertexArrayObjectBase.h"
 #include "platform/Timer.h"
 #include "platform/graphics/GraphicsTypes3D.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/graphics/gpu/WebGLImageConversion.h"
@@ skipping 86 matching lines @@
         // Restore DrawingBuffer if needed
         if (!m_readFramebufferBinding && m_drawingBuffer)
             m_drawingBuffer->restoreFramebufferBindings();
     }
 
 private:
     DrawingBuffer* m_drawingBuffer;
     Member<WebGLFramebuffer> m_readFramebufferBinding;
 };
 
-class MODULES_EXPORT WebGLRenderingContextBase : public CanvasRenderingContext {
+class MODULES_EXPORT WebGLRenderingContextBase : public CanvasRenderingContext, public OffscreenCanvasRenderingContext, public ScriptWrappable {

[xlai (Olivia), 2016/04/20 20:42:16]

[continued from previous comment] But then why is ScriptWrappable in WebGLBase,
instead of being in WebGL2 and WebGL separately? Are they sharing the same
interface in scripts?

[xidachen, 2016/04/20 20:52:09]

WebGLBase has a idl and it is the actual interface for WebGLRenderingContext.
WebGL2RenderingContext just extend the WebGLBase.

[Ken Russell (switch to Gerrit), 2016/04/21 01:05:24]

Based on past experience with multiple inheritance I think that making
WebGLRenderingContextBase inherit from both CanvasRenderingContext and
OffscreenCanvasRenderingContext is not a good direction to take.

The introduction of OffscreenCanvasRenderingContext as a concept does not appear
necessary to me. All that needs to happen is:

 - The few methods that deal with the HTMLCanvasElement in
CanvasRenderingContext2D, WebGLRenderingContext, etc. and their base classes
need to be considered optional.

 - Methods need to be added to the base class (CanvasRenderingContext) allowing
it to be used with OffscreenCanvas.

 - CanvasRenderingContextFactory needs to be extended with a new factory method
taking OffscreenCanvas instead of HTMLCanvasElement as the owner of the context.

Fundamentally, the context classes will have to understand their two modes of
operation -- rendering to either an on-screen or off-screen canvas. Using
multiple inheritance to achieve this is deeply problematic. Pointers to the
objects change value depending on which area of the code is touching it.
Accidental diamond inheritance causes behaviors that can't be easily explained.
Interaction with the JavaScript layer is made more confusing. There are many
other reasons for preferring single inheritance.

Please make this change. I think that using multiple inheritance for the WebGL
contexts is not a good design decision and I can't support moving the code in
this direction.

[xlai (Olivia), 2016/04/21 15:31:54]

First, I agree with merging OffscreenCanvasRenderingContext and
CanvasRenderingContext into one class (so does the merging of non-offscreen and
offscreen factory classes into one). It is also possible to implement by:
- Adding one more create function in Factory that takes in OffscreenCanvas* and
returns CanvasRenderingContext*. This create function is invoked by
OffscreenCanvas.getContext() only.
- From what I see, CanvasRenderingContext only interacts with HTMLCanvasElement
by having a member instance m_canvas; we can set it null in the case of
OffscreenCanvas and have one more member instance called m_offscreencanvas.
- Adding all out offscreen context types to the list of enum in
CanvasRenderingContext.ContextType with prefix "Offscreen" to distinguish them
with the existing rendering context types.

Second, I disagree with changing the status quo in
OffscreenCanvasRenderingContext2D and CanvasRenderingContext2D. I think attempts
to merge these two classes will make things messy. Right now,
BaseRenderingContext2D is parent of 3 classes--PaintRenderingContext2D,
CanvasRenderingContext2D, OffscreenCanvasRenderingContext2D. It is problematic
to adapt BaseRC2D for only the canvas cases, without affecting the PaintRC2D.
Also, there is no reason to let OffCRC2D and CRC2D to become one class, as many
functions that solely exist in CRC2D (hitregion, focus) are not applicable to
OffscreenCanvas.

[Ken Russell (switch to Gerrit), 2016/04/21 19:52:00]

OK. Please do as you see fit with CanvasRenderingContext2D and
OffscreenCanvasRenderingContext2D, but please merge the base class so that
CanvasRenderingContext is the sole base class for all of the derived classes.
Thanks.

Also please note that https://wiki.whatwg.org/wiki/OffscreenCanvas doesn't
define an OffscreenCanvasRenderingContext2D type. The behavior of these methods
that make no sense on OffscreenCanvases needs to be specified, or a
CanvasRenderingContext2DBase needs to be defined with the common methods, and
CanvasRenderingContext2D specified to add the methods that only make sense with
on-screen canvases.

+    USING_GARBAGE_COLLECTED_MIXIN(WebGLRenderingContextBase);
 public:
     ~WebGLRenderingContextBase() override;
 
     virtual unsigned version() const = 0;
     virtual String contextName() const = 0;
     virtual void registerContextExtensions() = 0;
 
     virtual void initializeNewContext();
 
     static unsigned getWebGLVersion(const CanvasRenderingContext*);
 
     static PassOwnPtr<WebGraphicsContext3DProvider> createWebGraphicsContext3DProvider(HTMLCanvasElement*, WebGLContextAttributes, unsigned webGLVersion);
+    static PassOwnPtr<WebGraphicsContext3DProvider> createWebGraphicsContext3DProvider(ScriptState*, WebGLContextAttributes, unsigned webGLVersion);
     static void forceNextWebGLContextCreationToFail();
 
     int drawingBufferWidth() const;
     int drawingBufferHeight() const;
 
     void activeTexture(GLenum texture);
     void attachShader(ScriptState*, WebGLProgram*, WebGLShader*);
     void bindAttribLocation(WebGLProgram*, GLuint index, const String& name);
     void bindBuffer(ScriptState*, GLenum target, WebGLBuffer*);
     virtual void bindFramebuffer(ScriptState*, GLenum target, WebGLFramebuffer*);
@@ skipping 235 matching lines @@
     GLboolean isValuebufferCHROMIUM(CHROMIUMValuebuffer*);
     void bindValuebufferCHROMIUM(GLenum target, CHROMIUMValuebuffer*);
     void subscribeValueCHROMIUM(GLenum target, GLenum subscription);
     void populateSubscribedValuesCHROMIUM(GLenum target);
     void uniformValuebufferCHROMIUM(const WebGLUniformLocation*, GLenum target, GLenum subscription);
 
     // Eagerly finalize WebGLRenderingContextBase in order for it
     // to (first) be able to detach its WebGLContextObjects, before
     // they're later swept and finalized.
     EAGERLY_FINALIZE();
-    DECLARE_EAGER_FINALIZATION_OPERATOR_NEW();
     DECLARE_VIRTUAL_TRACE();
 
     // Returns approximate gpu memory allocated per pixel.
     int externallyAllocatedBytesPerPixel() override;
 
     class TextureUnitState {
         DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     public:
         Member<WebGLTexture> m_texture2DBinding;
         Member<WebGLTexture> m_textureCubeMapBinding;
@@ skipping 18 matching lines @@
     friend class WebGLCompressedTextureATC;
     friend class WebGLCompressedTextureETC1;
     friend class WebGLCompressedTexturePVRTC;
     friend class WebGLCompressedTextureS3TC;
     friend class WebGLRenderingContextErrorMessageCallback;
     friend class WebGLVertexArrayObjectBase;
     friend class ScopedTexture2DRestorer;
     friend class ScopedFramebufferRestorer;
 
     WebGLRenderingContextBase(HTMLCanvasElement*, PassOwnPtr<WebGraphicsContext3DProvider>, const WebGLContextAttributes&);
+    WebGLRenderingContextBase(OffscreenCanvas*, PassOwnPtr<WebGraphicsContext3DProvider>, const WebGLContextAttributes&);
     PassRefPtr<DrawingBuffer> createDrawingBuffer(PassOwnPtr<WebGraphicsContext3DProvider>);
     void setupFlags();
 
     // CanvasRenderingContext implementation.
     bool is3d() const override { return true; }
     bool isAccelerated() const override { return true; }
     void setIsHidden(bool) override;
     bool paintRenderingResultsToCanvas(SourceDrawingBuffer) override;
     WebLayer* platformLayer() const override;
     void stop() override;
@@ skipping 612 matching lines @@
     static void addToEvictedList(WebGLRenderingContextBase*);
     static void removeFromEvictedList(WebGLRenderingContextBase*);
     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 WebGLRenderingContextBase* oldestContext();
     static WebGLRenderingContextBase* oldestEvictedContext();
 
     CrossThreadWeakPersistentThisPointer<WebGLRenderingContextBase> createWeakThisPointer() { return CrossThreadWeakPersistentThisPointer<WebGLRenderingContextBase>(this); }
+
+private:
+    WebGLRenderingContextBase(HTMLCanvasElement*, OffscreenCanvas*, PassOwnPtr<WebGraphicsContext3DProvider>, const WebGLContextAttributes&);
 };
 
 DEFINE_TYPE_CASTS(WebGLRenderingContextBase, CanvasRenderingContext, context, context->is3d(), context.is3d());
 
 } // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif // WebGLRenderingContextBase_h