Changeset 266275 in webkit


Ignore:
Timestamp:
Aug 28, 2020 1:46:45 AM (4 years ago)
Author:
Chris Lord
Message:

Add WebGL(2) context support to OffscreenCanvas
​https://bugs.webkit.org/show_bug.cgi?id=209809

Reviewed by Dean Jackson.

LayoutTests/imported/w3c:

Rebaseline OffscreenCanvas tests after enabling WebGL contexts.

  • web-platform-tests/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext-expected.txt:
  • web-platform-tests/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext.worker-expected.txt:

Source/WebCore:

Enable WebGL contexts with OffscreenCanvas by making sure the required
settings are marshalled to workers and that any functionality that
doesn't require an HTMLCanvasElement uses CanvasBase instead.

No new tests, rebaselined existing test.

  • html/CanvasBase.h:
  • html/CustomPaintCanvas.cpp:

(WebCore::CustomPaintCanvas::clearCopiedImage const):

  • html/CustomPaintCanvas.h:
  • html/HTMLCanvasElement.cpp:

(WebCore::HTMLCanvasElement::clearCopiedImage const):

  • html/HTMLCanvasElement.h:
  • html/OffscreenCanvas.cpp:

(WebCore::requiresAcceleratedCompositingForWebGL):
(WebCore::shouldEnableWebGL):
(WebCore::OffscreenCanvas::createContextWebGL):
(WebCore::OffscreenCanvas::getContext):

  • html/OffscreenCanvas.h:
  • html/OffscreenCanvas.idl:
  • html/canvas/WebGL2RenderingContext.idl:
  • html/canvas/WebGLRenderingContext.idl:
  • html/canvas/WebGLRenderingContextBase.cpp:

(WebCore::WebGLRenderingContextBase::WebGLRenderingContextBase):
(WebCore::WebGLRenderingContextBase::markContextChanged):
(WebCore::WebGLRenderingContextBase::paintRenderingResultsToCanvas):

  • workers/WorkerGlobalScope.cpp:

(WebCore::WorkerGlobalScope::WorkerGlobalScope):

  • workers/WorkerGlobalScope.h:

(WebCore::WorkerGlobalScope::acceleratedCompositingEnabled const):
(WebCore::WorkerGlobalScope::webGLEnabled const):

  • workers/WorkerMessagingProxy.cpp:

(WebCore::WorkerMessagingProxy::startWorkerGlobalScope):

  • workers/WorkerThread.cpp:

(WebCore::WorkerParameters::isolatedCopy const):

  • workers/WorkerThread.h:
  • workers/service/context/ServiceWorkerThread.cpp:

(WebCore::ServiceWorkerThread::ServiceWorkerThread):

Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r266269 r266275  
     12020-08-28  Chris Lord  <clord@igalia.com>
     2
     3        Add WebGL(2) context support to OffscreenCanvas
     4        https://bugs.webkit.org/show_bug.cgi?id=209809
     5
     6        Reviewed by Dean Jackson.
     7
     8        Rebaseline OffscreenCanvas tests after enabling WebGL contexts.
     9
     10        * web-platform-tests/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext-expected.txt:
     11        * web-platform-tests/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext.worker-expected.txt:
     12
    1132020-08-27  Ryosuke Niwa  <rniwa@webkit.org>
    214

  • trunk/LayoutTests/imported/w3c/web-platform-tests/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext-expected.txt

    r265543 r266275  
    11
    22PASS Test that getContext with un-supported string throws a TypeError.
    3 FAIL Test that getContext with supported string returns correct results Argument 1 ('contextType') to OffscreenCanvas.getContext must be one of: "2d", "webgl"
     3FAIL Test that getContext with supported string returns correct results Can't find variable: WebGL2RenderingContext
    44PASS Test that getContext twice with different context type returns null the second time
    55PASS Test that 2dcontext.canvas should return the original OffscreenCanvas

  • trunk/LayoutTests/imported/w3c/web-platform-tests/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext.worker-expected.txt

    r265543 r266275  
    11
    22PASS Test that getContext with un-supported string throws a TypeError.
    3 FAIL Test that getContext with supported string returns correct results Can't find variable: WebGLRenderingContext
     3FAIL Test that getContext with supported string returns correct results Can't find variable: WebGL2RenderingContext
    44PASS Test that getContext twice with different context type returns null the second time
    55PASS Test that 2dcontext.canvas should return the original OffscreenCanvas

  • trunk/Source/WebCore/ChangeLog

    r266271 r266275  
     12020-08-28  Chris Lord  <clord@igalia.com>
     2
     3        Add WebGL(2) context support to OffscreenCanvas
     4        https://bugs.webkit.org/show_bug.cgi?id=209809
     5
     6        Reviewed by Dean Jackson.
     7
     8        Enable WebGL contexts with OffscreenCanvas by making sure the required
     9        settings are marshalled to workers and that any functionality that
     10        doesn't require an HTMLCanvasElement uses CanvasBase instead.
     11
     12        No new tests, rebaselined existing test.
     13
     14        * html/CanvasBase.h:
     15        * html/CustomPaintCanvas.cpp:
     16        (WebCore::CustomPaintCanvas::clearCopiedImage const):
     17        * html/CustomPaintCanvas.h:
     18        * html/HTMLCanvasElement.cpp:
     19        (WebCore::HTMLCanvasElement::clearCopiedImage const):
     20        * html/HTMLCanvasElement.h:
     21        * html/OffscreenCanvas.cpp:
     22        (WebCore::requiresAcceleratedCompositingForWebGL):
     23        (WebCore::shouldEnableWebGL):
     24        (WebCore::OffscreenCanvas::createContextWebGL):
     25        (WebCore::OffscreenCanvas::getContext):
     26        * html/OffscreenCanvas.h:
     27        * html/OffscreenCanvas.idl:
     28        * html/canvas/WebGL2RenderingContext.idl:
     29        * html/canvas/WebGLRenderingContext.idl:
     30        * html/canvas/WebGLRenderingContextBase.cpp:
     31        (WebCore::WebGLRenderingContextBase::WebGLRenderingContextBase):
     32        (WebCore::WebGLRenderingContextBase::markContextChanged):
     33        (WebCore::WebGLRenderingContextBase::paintRenderingResultsToCanvas):
     34        * workers/WorkerGlobalScope.cpp:
     35        (WebCore::WorkerGlobalScope::WorkerGlobalScope):
     36        * workers/WorkerGlobalScope.h:
     37        (WebCore::WorkerGlobalScope::acceleratedCompositingEnabled const):
     38        (WebCore::WorkerGlobalScope::webGLEnabled const):
     39        * workers/WorkerMessagingProxy.cpp:
     40        (WebCore::WorkerMessagingProxy::startWorkerGlobalScope):
     41        * workers/WorkerThread.cpp:
     42        (WebCore::WorkerParameters::isolatedCopy const):
     43        * workers/WorkerThread.h:
     44        * workers/service/context/ServiceWorkerThread.cpp:
     45        (WebCore::ServiceWorkerThread::ServiceWorkerThread):
     46
    1472020-08-27  Zalan Bujtas  <zalan@apple.com>
    248

  • trunk/Source/WebCore/html/CanvasBase.h

    r255315 r266275  
    102102
    103103    virtual Image* copiedImage() const = 0;
     104    virtual void clearCopiedImage() const = 0;
     105
    104106    bool callTracingActive() const;
    105107

  • trunk/Source/WebCore/html/CustomPaintCanvas.cpp

    r258219 r266275  
    106106}
    107107
     108void CustomPaintCanvas::clearCopiedImage() const
     109{
     110    m_copiedImage = nullptr;
     111}
     112
    108113GraphicsContext* CustomPaintCanvas::drawingContext() const
    109114{

  • trunk/Source/WebCore/html/CustomPaintCanvas.h

    r251874 r266275  
    6464    AffineTransform baseTransform() const final { ASSERT(m_destinationGraphicsContext && m_copiedBuffer); return m_copiedBuffer->baseTransform(); }
    6565    Image* copiedImage() const final;
     66    void clearCopiedImage() const final;
     67
    6668    void replayDisplayList(GraphicsContext*) const;
    6769

  • trunk/Source/WebCore/html/HTMLCanvasElement.cpp

    r266168 r266275  
    10031003}
    10041004
    1005 void HTMLCanvasElement::clearCopiedImage()
     1005void HTMLCanvasElement::clearCopiedImage() const
    10061006{
    10071007    m_copiedImage = nullptr;

  • trunk/Source/WebCore/html/HTMLCanvasElement.h

    r265543 r266275  
    114114
    115115    Image* copiedImage() const final;
    116     void clearCopiedImage();
     116    void clearCopiedImage() const final;
    117117    RefPtr<ImageData> getImageData();
    118118    void makePresentationCopy();

  • trunk/Source/WebCore/html/OffscreenCanvas.cpp

    r266168 r266275  
    4040#include "OffscreenCanvasRenderingContext2D.h"
    4141#include "PlaceholderRenderingContext.h"
    42 #include "WebGLRenderingContext.h"
    4342#include "WorkerGlobalScope.h"
    4443#include <wtf/IsoMallocInlines.h>
     44
     45#if ENABLE(WEBGL)
     46#include "Settings.h"
     47#include "WebGLRenderingContext.h"
     48
     49#if ENABLE(WEBGL2)
     50#include "WebGL2RenderingContext.h"
     51#endif
     52#endif // ENABLE(WEBGL)
    4553
    4654namespace WebCore {
    … …  
    141149    reset();
    142150}
     151
     152#if ENABLE(WEBGL)
     153static bool requiresAcceleratedCompositingForWebGL()
     154{
     155#if PLATFORM(GTK) || PLATFORM(WIN_CAIRO)
     156    return false;
     157#else
     158    return true;
     159#endif
     160}
     161
     162static bool shouldEnableWebGL(bool webGLEnabled, bool acceleratedCompositingEnabled)
     163{
     164    if (!webGLEnabled)
     165        return false;
     166
     167    if (!requiresAcceleratedCompositingForWebGL())
     168        return true;
     169
     170    return acceleratedCompositingEnabled;
     171}
     172
     173void OffscreenCanvas::createContextWebGL(RenderingContextType contextType, WebGLContextAttributes&& attrs)
     174{
     175    ASSERT(!m_context);
     176
     177    auto context = scriptExecutionContext();
     178    if (context->isWorkerGlobalScope()) {
     179        WorkerGlobalScope& workerGlobalScope = downcast<WorkerGlobalScope>(*context);
     180        if (!shouldEnableWebGL(workerGlobalScope.webGLEnabled(), workerGlobalScope.acceleratedCompositingEnabled()))
     181            return;
     182    } else if (context->isDocument()) {
     183        auto& settings = downcast<Document>(*context).settings();
     184        if (!shouldEnableWebGL(settings.webGLEnabled(), settings.acceleratedCompositingEnabled()))
     185            return;
     186    } else
     187        return;
     188
     189    m_context = WebGLRenderingContextBase::create(*this, attrs, (contextType == RenderingContextType::Webgl) ? "webgl" : "webgl2");
     190}
     191
     192#endif // ENABLE(WEBGL)
    143193
    144194ExceptionOr<Optional<OffscreenRenderingContext>> OffscreenCanvas::getContext(JSC::JSGlobalObject& state, RenderingContextType contextType, Vector<JSC::Strong<JSC::Unknown>>&& arguments)
    … …  
    161211    }
    162212#if ENABLE(WEBGL)
    163     if (contextType == RenderingContextType::Webgl) {
     213    else {
    164214        if (m_context) {
    165215            if (is<WebGLRenderingContext>(*m_context))
    166216                return { { RefPtr<WebGLRenderingContext> { &downcast<WebGLRenderingContext>(*m_context) } } };
     217#if ENABLE(WEBGL2)
     218            if (is<WebGL2RenderingContext>(*m_context))
     219                return { { RefPtr<WebGL2RenderingContext> { &downcast<WebGL2RenderingContext>(*m_context) } } };
     220#endif
    167221            return { { WTF::nullopt } };
    168222        }
    … …  
    172226        RETURN_IF_EXCEPTION(scope, Exception { ExistingExceptionError });
    173227
    174         m_context = WebGLRenderingContextBase::create(*this, attributes, "webgl");
     228        createContextWebGL(contextType, WTFMove(attributes));
    175229        if (!m_context)
    176230            return { { WTF::nullopt } };
    177231
     232#if ENABLE(WEBGL2)
     233        if (is<WebGL2RenderingContext>(*m_context))
     234            return { { RefPtr<WebGL2RenderingContext> { &downcast<WebGL2RenderingContext>(*m_context) } } };
     235#endif
    178236        return { { RefPtr<WebGLRenderingContext> { &downcast<WebGLRenderingContext>(*m_context) } } };
    179237    }

  • trunk/Source/WebCore/html/OffscreenCanvas.h

    r265543 r266275  
    4141#include <wtf/WeakPtr.h>
    4242#include <wtf/text/WTFString.h>
     43#if ENABLE(WEBGL)
     44#include "WebGLContextAttributes.h"
     45#endif
     46
    4347
    4448namespace WebCore {
    … …  
    5155class ImageData;
    5256class OffscreenCanvasRenderingContext2D;
     57class WebGL2RenderingContext;
    5358class WebGLRenderingContext;
    54 
     59class WebGLRenderingContextBase;
     60
     61using OffscreenRenderingContext = Variant<
    5562#if ENABLE(WEBGL)
    56 using OffscreenRenderingContext = Variant<RefPtr<OffscreenCanvasRenderingContext2D>, RefPtr<WebGLRenderingContext>>;
    57 #else
    58 using OffscreenRenderingContext = Variant<RefPtr<OffscreenCanvasRenderingContext2D>>;
    59 #endif
     63    RefPtr<WebGLRenderingContext>,
     64#endif
     65#if ENABLE(WEBGL2)
     66    RefPtr<WebGL2RenderingContext>,
     67#endif
     68    RefPtr<OffscreenCanvasRenderingContext2D>
     69>;
    6070
    6171class DetachedOffscreenCanvas {
    … …  
    97107    enum class RenderingContextType {
    98108        _2d,
    99         Webgl
     109        Webgl,
     110        Webgl2
    100111    };
    101112
    … …  
    119130
    120131    Image* copiedImage() const final;
     132    void clearCopiedImage() const final;
     133
    121134    bool hasCreatedImageBuffer() const final { return m_hasCreatedImageBuffer; }
    122135
    … …  
    150163
    151164    void setSize(const IntSize&) final;
     165
     166#if ENABLE(WEBGL)
     167    void createContextWebGL(RenderingContextType, WebGLContextAttributes&& = { });
     168#endif
     169
    152170    void createImageBuffer() const final;
    153171    std::unique_ptr<ImageBuffer> takeImageBuffer() const;
    154172
    155173    void reset();
    156 
    157     void clearCopiedImage() const;
    158174
    159175    void setPlaceholderCanvas(HTMLCanvasElement&);

  • trunk/Source/WebCore/html/OffscreenCanvas.idl

    r263160 r266275  
    2424*/
    2525
     26typedef (
    2627#if defined(ENABLE_WEBGL) && ENABLE_WEBGL
    27 typedef (OffscreenCanvasRenderingContext2D or WebGLRenderingContext) OffscreenRenderingContext;
    28 #else
    29 typedef (OffscreenCanvasRenderingContext2D) OffscreenRenderingContext;
     28    WebGLRenderingContext or
    3029#endif
     30#if defined(ENABLE_WEBGL2) && ENABLE_WEBGL2
     31    WebGL2RenderingContext or
     32#endif
     33    OffscreenCanvasRenderingContext2D) OffscreenRenderingContext;
    3134
    3235dictionary ImageEncodeOptions
    … …  
    3942{
    4043   "2d",
    41    "webgl"
     44   "webgl",
     45   "webgl2"
    4246};
    4347

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.idl

    r265833 r266275  
    5959    JSGenerateToJSObject,
    6060    DoNotCheckConstants,
     61    Exposed=(Window,Worker),
    6162    CallTracingCallback=recordCanvasAction,
    6263] interface WebGL2RenderingContext {

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContext.idl

    r265833 r266275  
    4242    DoNotCheckConstants,
    4343    ExportMacro=WEBCORE_EXPORT,
     44    Exposed=(Window,Worker),
    4445    CallTracingCallback=recordCanvasAction,
    4546] interface WebGLRenderingContext {

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r266189 r266275  
    752752
    753753    registerWithWebGLStateTracker();
    754     m_checkForContextLossHandlingTimer.startOneShot(checkContextLossHandlingDelay);
     754    if (canvas.isHTMLCanvasElement())
     755        m_checkForContextLossHandlingTimer.startOneShot(checkContextLossHandlingDelay);
    755756}
    756757
    … …  
    779780
    780781    registerWithWebGLStateTracker();
    781     m_checkForContextLossHandlingTimer.startOneShot(checkContextLossHandlingDelay);
     782    if (canvas.isHTMLCanvasElement())
     783        m_checkForContextLossHandlingTimer.startOneShot(checkContextLossHandlingDelay);
    782784
    783785    addActivityStateChangeObserverIfNecessary();
    … …  
    10681070    m_layerCleared = false;
    10691071
    1070     auto* canvas = htmlCanvas();
    1071     if (!canvas)
    1072         return;
    1073 
    1074     RenderBox* renderBox = canvas->renderBox();
    1075     if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {
     1072    if (auto* canvas = htmlCanvas()) {
     1073        RenderBox* renderBox = canvas->renderBox();
     1074        if (isAccelerated() && renderBox && renderBox->hasAcceleratedCompositing()) {
     1075            m_markedCanvasDirty = true;
     1076            canvas->clearCopiedImage();
     1077            renderBox->contentChanged(CanvasPixelsChanged);
     1078            return;
     1079        }
     1080    }
     1081
     1082    if (!m_markedCanvasDirty) {
    10761083        m_markedCanvasDirty = true;
    1077         htmlCanvas()->clearCopiedImage();
    1078         renderBox->contentChanged(CanvasPixelsChanged);
    1079     } else {
    1080         if (!m_markedCanvasDirty) {
    1081             m_markedCanvasDirty = true;
    1082             canvas->didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
    1083         }
     1084        canvasBase().didDraw(FloatRect(FloatPoint(0, 0), clampedCanvasSize()));
    10841085    }
    10851086}
    … …  
    11931194        return;
    11941195
    1195     auto* canvas = htmlCanvas();
    1196     if (!canvas)
    1197         return;
    1198 
    1199     if (canvas->document().printing() || (canvas->isSnapshotting() && canvas->document().page()->isVisible()))
    1200         canvas->clearPresentationCopy();
    1201 
    1202     // Until the canvas is written to by the application, the clear that
    1203     // happened after it was composited should be ignored by the compositor.
    1204     if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {
    1205         m_context->paintRenderingResultsToCanvas(canvas->buffer());
    1206 
    1207         canvas->makePresentationCopy();
    1208     } else
    1209         canvas->clearPresentationCopy();
     1196    if (auto* canvas = htmlCanvas()) {
     1197        if (canvas->document().printing() || (canvas->isSnapshotting() && canvas->document().page()->isVisible()))
     1198            canvas->clearPresentationCopy();
     1199
     1200        // Until the canvas is written to by the application, the clear that
     1201        // happened after it was composited should be ignored by the compositor.
     1202        if (m_context->layerComposited() && !m_attributes.preserveDrawingBuffer) {
     1203            m_context->paintRenderingResultsToCanvas(canvas->buffer());
     1204
     1205            canvas->makePresentationCopy();
     1206        } else
     1207            canvas->clearPresentationCopy();
     1208    }
     1209
    12101210    clearIfComposited();
    12111211
    … …  
    12131213        return;
    12141214
    1215     canvas->clearCopiedImage();
     1215    auto& base = canvasBase();
     1216    base.clearCopiedImage();
     1217
    12161218    m_markedCanvasDirty = false;
    12171219
    1218     m_context->paintRenderingResultsToCanvas(canvas->buffer());
     1220    m_context->paintRenderingResultsToCanvas(base.buffer());
    12191221}
    12201222

  • trunk/Source/WebCore/workers/WorkerGlobalScope.cpp

    r263422 r266275  
    8080    , m_referrerPolicy(params.referrerPolicy)
    8181    , m_requestAnimationFrameEnabled(params.requestAnimationFrameEnabled)
     82    , m_acceleratedCompositingEnabled(params.acceleratedCompositingEnabled)
     83    , m_webGLEnabled(params.webGLEnabled)
    8284{
    8385#if !ENABLE(INDEXED_DATABASE)

  • trunk/Source/WebCore/workers/WorkerGlobalScope.h

    r259298 r266275  
    143143
    144144    bool requestAnimationFrameEnabled() const { return m_requestAnimationFrameEnabled; }
     145    bool acceleratedCompositingEnabled() const { return m_acceleratedCompositingEnabled; }
     146    bool webGLEnabled() const { return m_webGLEnabled; }
    145147
    146148protected:
    … …  
    224226    ReferrerPolicy m_referrerPolicy;
    225227    bool m_requestAnimationFrameEnabled;
     228    bool m_acceleratedCompositingEnabled;
     229    bool m_webGLEnabled;
    226230};
    227231

  • trunk/Source/WebCore/workers/WorkerMessagingProxy.cpp

    r261104 r266275  
    9090    SocketProvider* socketProvider = document.socketProvider();
    9191
    92     WorkerParameters params = { scriptURL, name, identifier, userAgent, isOnline, contentSecurityPolicyResponseHeaders, shouldBypassMainWorldContentSecurityPolicy, timeOrigin, referrerPolicy, document.settings().requestAnimationFrameEnabled() };
     92    WorkerParameters params = { scriptURL, name, identifier, userAgent, isOnline, contentSecurityPolicyResponseHeaders, shouldBypassMainWorldContentSecurityPolicy, timeOrigin, referrerPolicy, document.settings().requestAnimationFrameEnabled(), document.settings().acceleratedCompositingEnabled(), document.settings().webGLEnabled() };
    9393    auto thread = DedicatedWorkerThread::create(params, sourceCode, *this, *this, *this, startMode, document.topOrigin(), proxy, socketProvider, runtimeFlags);
    9494

  • trunk/Source/WebCore/workers/WorkerThread.cpp

    r259298 r266275  
    8383        referrerPolicy,
    8484        requestAnimationFrameEnabled,
     85        acceleratedCompositingEnabled,
     86        webGLEnabled,
    8587    };
    8688}

  • trunk/Source/WebCore/workers/WorkerThread.h

    r259298 r266275  
    7070    ReferrerPolicy referrerPolicy;
    7171    bool requestAnimationFrameEnabled;
     72    bool acceleratedCompositingEnabled;
     73    bool webGLEnabled;
    7274
    7375    WorkerParameters isolatedCopy() const;

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThread.cpp

    r263422 r266275  
    7575
    7676ServiceWorkerThread::ServiceWorkerThread(const ServiceWorkerContextData& data, String&& userAgent, WorkerLoaderProxy& loaderProxy, WorkerDebuggerProxy& debuggerProxy, IDBClient::IDBConnectionProxy* idbConnectionProxy, SocketProvider* socketProvider)
    77     : WorkerThread({ data.scriptURL, emptyString(), "serviceworker:" + Inspector::IdentifiersFactory::createIdentifier(), WTFMove(userAgent), platformStrategies()->loaderStrategy()->isOnLine(), data.contentSecurityPolicy, false, MonotonicTime::now(), { }, true }, data.script, loaderProxy, debuggerProxy, DummyServiceWorkerThreadProxy::shared(), WorkerThreadStartMode::Normal, data.registration.key.topOrigin().securityOrigin().get(), idbConnectionProxy, socketProvider, JSC::RuntimeFlags::createAllEnabled())
     77    : WorkerThread({ data.scriptURL, emptyString(), "serviceworker:" + Inspector::IdentifiersFactory::createIdentifier(), WTFMove(userAgent), platformStrategies()->loaderStrategy()->isOnLine(), data.contentSecurityPolicy, false, MonotonicTime::now(), { }, true, true, true }, data.script, loaderProxy, debuggerProxy, DummyServiceWorkerThreadProxy::shared(), WorkerThreadStartMode::Normal, data.registration.key.topOrigin().securityOrigin().get(), idbConnectionProxy, socketProvider, JSC::RuntimeFlags::createAllEnabled())
    7878    , m_data(data.isolatedCopy())
    7979    , m_workerObjectProxy(DummyServiceWorkerThreadProxy::shared())
Note: See TracChangeset for help on using the changeset viewer.