Make OffscreenCanvas an EventTarget

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * 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 954 matching lines @@
       return false;
   }
 }
 
 }  // namespace
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(
     OffscreenCanvas* passedOffscreenCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes,
+    ExecutionContext* executionContext,
     unsigned version)
     : WebGLRenderingContextBase(nullptr,
                                 passedOffscreenCanvas,
                                 std::move(contextProvider),
                                 requestedAttributes,
+                                executionContext,
                                 version) {}
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(
     HTMLCanvasElement* passedCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes,
     unsigned version)
     : WebGLRenderingContextBase(passedCanvas,
                                 nullptr,
                                 std::move(contextProvider),
                                 requestedAttributes,
+                                nullptr,
                                 version) {}
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(
     HTMLCanvasElement* passedCanvas,
     OffscreenCanvas* passedOffscreenCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes,
+    ExecutionContext* executionContext,
     unsigned version)
     : CanvasRenderingContext(passedCanvas,
                              passedOffscreenCanvas,
                              requestedAttributes),
       m_isHidden(false),
       m_contextLostMode(NotLostContext),
       m_autoRecoveryMethod(Manual),
       m_dispatchContextLostEventTimer(
           this,
           &WebGLRenderingContextBase::dispatchContextLostEvent),
       m_restoreAllowed(false),
       m_restoreTimer(this, &WebGLRenderingContextBase::maybeRestoreContext),
       m_boundArrayBuffer(this, nullptr),
       m_boundVertexArrayObject(this, nullptr),
       m_currentProgram(this, nullptr),
       m_framebufferBinding(this, nullptr),
       m_renderbufferBinding(this, nullptr),
       m_generatedImageCache(4),
       m_synthesizedErrorsToConsole(true),
       m_numGLErrorsToConsoleAllowed(maxGLErrorsAllowedToConsole),
       m_onePlusMaxNonDefaultTextureUnit(0),
       m_isWebGL2FormatsTypesAdded(false),
       m_isWebGL2TexImageSourceFormatsTypesAdded(false),
       m_isWebGL2InternalFormatsCopyTexImageAdded(false),
       m_isOESTextureFloatFormatsTypesAdded(false),
       m_isOESTextureHalfFloatFormatsTypesAdded(false),
       m_isWebGLDepthTextureFormatsTypesAdded(false),
       m_isEXTsRGBFormatsTypesAdded(false),
-      m_version(version) {
+      m_version(version),
+      m_executionContext(executionContext) {
   ASSERT(contextProvider);
 
   m_contextGroup = WebGLContextGroup::create();
   m_contextGroup->addContext(this);
 
   m_maxViewportDims[0] = m_maxViewportDims[1] = 0;
   contextProvider->contextGL()->GetIntegerv(GL_MAX_VIEWPORT_DIMS,
                                             m_maxViewportDims);
 
   RefPtr<DrawingBuffer> buffer;
@@ skipping 6253 matching lines @@
     synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, functionName, reason);
     return false;
   }
 
   return true;
 }
 
 void WebGLRenderingContextBase::dispatchContextLostEvent(TimerBase*) {
   WebGLContextEvent* event = WebGLContextEvent::create(
       EventTypeNames::webglcontextlost, false, true, "");
-  canvas()->dispatchEvent(event);
+  if (getOffscreenCanvas())
+    getOffscreenCanvas()->dispatchEvent(event);
+  else
+    canvas()->dispatchEvent(event);
   m_restoreAllowed = event->defaultPrevented();
   if (m_restoreAllowed && !m_isHidden) {
     if (m_autoRecoveryMethod == Auto)
       m_restoreTimer.startOneShot(0, BLINK_FROM_HERE);
   }
 }
 
 void WebGLRenderingContextBase::maybeRestoreContext(TimerBase*) {
   ASSERT(isContextLost());
 
@@ skipping 278 matching lines @@
 DEFINE_TRACE(WebGLRenderingContextBase) {
   visitor->trace(m_contextObjects);
   visitor->trace(m_boundArrayBuffer);
   visitor->trace(m_defaultVertexArrayObject);
   visitor->trace(m_boundVertexArrayObject);
   visitor->trace(m_currentProgram);
   visitor->trace(m_framebufferBinding);
   visitor->trace(m_renderbufferBinding);
   visitor->trace(m_textureUnits);
   visitor->trace(m_extensions);
+  visitor->trace(m_executionContext);
   CanvasRenderingContext::trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(WebGLRenderingContextBase) {
   if (isContextLost()) {
     return;
   }
   visitor->traceWrappers(m_boundArrayBuffer);
   visitor->traceWrappers(m_renderbufferBinding);
   visitor->traceWrappers(m_framebufferBinding);
@@ skipping 59 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink