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 529 matching lines @@
   formatWebGLStatusString("ErrorMessage", info.errorMessage.utf8().data(),
                           builder);
   builder.append('.');
   return builder.toString();
 }
 
 struct ContextProviderCreationInfo {
   // Inputs.
   Platform::ContextAttributes contextAttributes;
   Platform::GraphicsInfo* glInfo;
-  ScriptState* scriptState;
+  KURL url;
   // Outputs.
   std::unique_ptr<WebGraphicsContext3DProvider> createdContextProvider;
 };
 
 static void createContextProviderOnMainThread(
     ContextProviderCreationInfo* creationInfo,
     WaitableEvent* waitableEvent) {
   ASSERT(isMainThread());
   creationInfo->createdContextProvider =
       wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
-          creationInfo->contextAttributes,
-          creationInfo->scriptState->getExecutionContext()->url(), 0,
+          creationInfo->contextAttributes, creationInfo->url, 0,
           creationInfo->glInfo));
   waitableEvent->signal();
 }
 
 static std::unique_ptr<WebGraphicsContext3DProvider>
 createContextProviderOnWorkerThread(
     Platform::ContextAttributes contextAttributes,
     Platform::GraphicsInfo* glInfo,
-    ScriptState* scriptState) {
+    const KURL& url) {
   WaitableEvent waitableEvent;
   ContextProviderCreationInfo creationInfo;
   creationInfo.contextAttributes = contextAttributes;
   creationInfo.glInfo = glInfo;
-  creationInfo.scriptState = scriptState;
+  creationInfo.url = url;
   WebTaskRunner* taskRunner =
       Platform::current()->mainThread()->getWebTaskRunner();
   taskRunner->postTask(BLINK_FROM_HERE,
                        crossThreadBind(&createContextProviderOnMainThread,
                                        crossThreadUnretained(&creationInfo),
                                        crossThreadUnretained(&waitableEvent)));
   waitableEvent.wait();
   return std::move(creationInfo.createdContextProvider);
 }
 
 std::unique_ptr<WebGraphicsContext3DProvider>
 WebGLRenderingContextBase::createContextProviderInternal(
     HTMLCanvasElement* canvas,
     ScriptState* scriptState,
     const CanvasContextCreationAttributes& attributes,
     unsigned webGLVersion) {
   // Exactly one of these must be provided.
   DCHECK_EQ(!canvas, !!scriptState);
   // The canvas is only given on the main thread.
   DCHECK(!canvas || isMainThread());
 
   Platform::ContextAttributes contextAttributes =
       toPlatformContextAttributes(attributes, webGLVersion);
   Platform::GraphicsInfo glInfo;
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
+  const auto& url = canvas ? canvas->document().topDocument().url()
+                           : scriptState->getExecutionContext()->url();
   if (isMainThread()) {
-    const auto& url = canvas ? canvas->document().topDocument().url()
-                             : scriptState->getExecutionContext()->url();
     contextProvider = wrapUnique(
         Platform::current()->createOffscreenGraphicsContext3DProvider(
             contextAttributes, url, 0, &glInfo));
   } else {
-    contextProvider = createContextProviderOnWorkerThread(contextAttributes,
-                                                          &glInfo, scriptState);
+    contextProvider =
+        createContextProviderOnWorkerThread(contextAttributes, &glInfo, url);
   }
   if (contextProvider && !contextProvider->bindToCurrentThread()) {
     contextProvider = nullptr;
     String errorString(glInfo.errorMessage.utf8().data());
     errorString.insert("bindToCurrentThread failed: ", 0);
     glInfo.errorMessage = errorString;
   }
   if (!contextProvider || shouldFailContextCreationForTesting) {
     shouldFailContextCreationForTesting = false;
     if (canvas)
@@ skipping 406 matching lines @@
   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;
+  // On Mac OS, DrawingBuffer is using an IOSurface as its backing storage, this
+  // allows WebGL-rendered canvases to be composited by the OS rather than
+  // Chrome.
+  // IOSurfaces are only compatible with the GL_TEXTURE_RECTANGLE_ARB binding
+  // target. So to avoid the knowledge of GL_TEXTURE_RECTANGLE_ARB type textures
+  // being introduced into more areas of the code, we use the code path of
+  // non-WebGLImageChromium for OffscreenCanvas.
+  // See detailed discussion in crbug.com/649668.
   if (passedOffscreenCanvas)
     buffer = createDrawingBuffer(std::move(contextProvider),
                                  DrawingBuffer::DisallowChromiumImage);
   else
     buffer = createDrawingBuffer(std::move(contextProvider),
                                  DrawingBuffer::AllowChromiumImage);
   if (!buffer) {
     m_contextLostMode = SyntheticLostContext;
     return;
   }
@@ skipping 6235 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());
 
   // The rendering context is not restored unless the default behavior of the
   // webglcontextlost event was prevented earlier.
   //
   // Because of the way m_restoreTimer is set up for real vs. synthetic lost
   // context events, we don't have to worry about this test short-circuiting
   // the retry loop for real context lost events.
   if (!m_restoreAllowed)
     return;
 
-  LocalFrame* frame = canvas()->document().frame();
-  if (!frame)
-    return;
+  if (canvas()) {
+    LocalFrame* frame = canvas()->document().frame();
+    if (!frame)
+      return;
 
-  Settings* settings = frame->settings();
+    Settings* settings = frame->settings();
 
-  if (!frame->loader().client()->allowWebGL(settings &&
-                                            settings->webGLEnabled()))
-    return;
+    if (!frame->loader().client()->allowWebGL(settings &&
+                                              settings->webGLEnabled()))
+      return;
+  }
 
   // If the context was lost due to RealLostContext, we need to destroy the old
   // DrawingBuffer before creating new DrawingBuffer to ensure resource budget
   // enough.
   if (drawingBuffer()) {
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
   }
 
   Platform::ContextAttributes attributes =
       toPlatformContextAttributes(creationAttributes(), version());
   Platform::GraphicsInfo glInfo;
-  std::unique_ptr<WebGraphicsContext3DProvider> contextProvider =
-      wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
-          attributes, canvas()->document().topDocument().url(), 0, &glInfo));
+  std::unique_ptr<WebGraphicsContext3DProvider> contextProvider;
+  const auto& url = canvas()
+                        ? canvas()->document().topDocument().url()
+                        : getOffscreenCanvas()->getExecutionContext()->url();
+  if (isMainThread()) {
+    contextProvider = wrapUnique(
+        Platform::current()->createOffscreenGraphicsContext3DProvider(
+            attributes, url, 0, &glInfo));
+  } else {
+    contextProvider =
+        createContextProviderOnWorkerThread(attributes, &glInfo, url);
+  }
   RefPtr<DrawingBuffer> buffer;
   if (contextProvider && contextProvider->bindToCurrentThread()) {
     // Construct a new drawing buffer with the new GL context.
-    // TODO(xidachen): make sure that the second parameter is correct for
-    // OffscreenCanvas.
-    buffer = createDrawingBuffer(std::move(contextProvider),
-                                 DrawingBuffer::AllowChromiumImage);
+    if (canvas()) {
+      buffer = createDrawingBuffer(std::move(contextProvider),
+                                   DrawingBuffer::AllowChromiumImage);
+    } else {
+      // Please refer to comment at Line 1040 in this file.
+      buffer = createDrawingBuffer(std::move(contextProvider),
+                                   DrawingBuffer::DisallowChromiumImage);
+    }
     // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is
     // set to null.
   }
   if (!buffer) {
     if (m_contextLostMode == RealLostContext) {
       m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts,
                                   BLINK_FROM_HERE);
     } else {
       // This likely shouldn't happen but is the best way to report it to the
       // WebGL app.
@@ skipping 10 matching lines @@
   drawingBuffer()->bind(GL_FRAMEBUFFER);
   m_lostContextErrors.clear();
   m_contextLostMode = NotLostContext;
   m_autoRecoveryMethod = Manual;
   m_restoreAllowed = false;
   removeFromEvictedList(this);
 
   setupFlags();
   initializeNewContext();
   markContextChanged(CanvasContextChanged);
-  canvas()->dispatchEvent(WebGLContextEvent::create(
-      EventTypeNames::webglcontextrestored, false, true, ""));
+  WebGLContextEvent* event = WebGLContextEvent::create(
+      EventTypeNames::webglcontextrestored, false, true, "");
+  if (canvas())
+    canvas()->dispatchEvent(event);
+  else
+    getOffscreenCanvas()->dispatchEvent(event);
 }
 
 String WebGLRenderingContextBase::ensureNotNull(const String& text) const {
   if (text.isNull())
     return WTF::emptyString();
   return text;
 }
 
 WebGLRenderingContextBase::LRUImageBufferCache::LRUImageBufferCache(
     int capacity)
@@ skipping 275 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink