Canvas2D on WebGL texture

third_party/WebKit/Source/modules/offscreencanvas2d/OffscreenCanvasRenderingContext2D.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/offscreencanvas2d/OffscreenCanvasRenderingContext2D.h"
 
 #include "bindings/modules/v8/OffscreenCanvasRenderingContext2DOrWebGLRenderingContextOrWebGL2RenderingContext.h"
+#include "bindings/modules/v8/V8WebGLTexture.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/Settings.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "core/workers/WorkerSettings.h"
+#include "modules/webgl/WebGLContextGroup.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StaticBitmapImage.h"
+#include "platform/graphics/gpu/SharedGpuContext.h"
+#include "platform/graphics/gpu/TextureImageBufferSurface.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/CurrentTime.h"
+#include "third_party/skia/include/gpu/GrContext.h"
 
 namespace blink {
 
 OffscreenCanvasRenderingContext2D::~OffscreenCanvasRenderingContext2D() {}
 
 OffscreenCanvasRenderingContext2D::OffscreenCanvasRenderingContext2D(
     ScriptState* script_state,
     OffscreenCanvas* canvas,
     const CanvasContextCreationAttributes& attrs)
     : CanvasRenderingContext(canvas, attrs) {
   ExecutionContext* execution_context = ExecutionContext::From(script_state);
+
   if (execution_context->IsDocument()) {
     if (ToDocument(execution_context)
             ->GetSettings()
             ->GetDisableReadingFromCanvas())
       canvas->SetDisableReadingFromCanvasTrue();
-    return;
+  } else {
+    WorkerSettings* worker_settings =
+        ToWorkerGlobalScope(execution_context)->GetWorkerSettings();
+    if (worker_settings && worker_settings->DisableReadingFromCanvas())
+      canvas->SetDisableReadingFromCanvasTrue();
   }
 
-  WorkerSettings* worker_settings =
-      ToWorkerGlobalScope(execution_context)->GetWorkerSettings();
-  if (worker_settings && worker_settings->DisableReadingFromCanvas())
-    canvas->SetDisableReadingFromCanvasTrue();
+  if (attrs.hasTexture()) {
+    webgl_texture_ = V8WebGLTexture::toImplWithTypeCheck(
+        attrs.texture().GetIsolate(), attrs.texture().V8Value());
+    if (!webgl_texture_) {
+      // TODO(fserb): exception_state.ThrowTypeError("member texture is not of
+      // type WebGLTexture.");
+      DVLOG(1) << "member texture is not of type WebGLTexture.";
+      return;
+    }
+    DVLOG(1) << "OCRC2D with texture!";
+    GetImageBuffer();
+  }
 }
 
 DEFINE_TRACE(OffscreenCanvasRenderingContext2D) {
   CanvasRenderingContext::Trace(visitor);
   BaseRenderingContext2D::Trace(visitor);
+  visitor->Trace(webgl_texture_);
 }
 
 ScriptPromise OffscreenCanvasRenderingContext2D::commit(
     ScriptState* script_state,
     ExceptionState& exception_state) {
   UseCounter::Feature feature = UseCounter::kOffscreenCanvasCommit2D;
   UseCounter::Count(ExecutionContext::From(script_state), feature);
   bool is_web_gl_software_rendering = false;
   return host()->Commit(TransferToStaticBitmapImage(),
                         is_web_gl_software_rendering, script_state,
@@ skipping 25 matching lines @@
 
 int OffscreenCanvasRenderingContext2D::Width() const {
   return host()->Size().Width();
 }
 
 int OffscreenCanvasRenderingContext2D::Height() const {
   return host()->Size().Height();
 }
 
 bool OffscreenCanvasRenderingContext2D::HasImageBuffer() const {
+  if (webgl_texture_) {
+    return !!texture_image_buffer_;
+  }
   return host()->GetImageBuffer();
 }
 
 void OffscreenCanvasRenderingContext2D::Reset() {
   host()->DiscardImageBuffer();
   BaseRenderingContext2D::Reset();
 }
 
 ColorBehavior OffscreenCanvasRenderingContext2D::DrawImageColorBehavior()
     const {
   return CanvasRenderingContext::ColorBehaviorForMediaDrawnToCanvas();
 }
 
 ImageBuffer* OffscreenCanvasRenderingContext2D::GetImageBuffer() const {
+  if (webgl_texture_) {
+    return const_cast<OffscreenCanvasRenderingContext2D*>(this)
+        ->CreateTextureImageBuffer();
+  }
   return const_cast<CanvasRenderingContextHost*>(host())
       ->GetOrCreateImageBuffer();
 }
 
+ImageBuffer* OffscreenCanvasRenderingContext2D::CreateTextureImageBuffer() {
+  DCHECK(webgl_texture_);
+  if (!texture_image_buffer_) {
+    OpacityMode opacity_mode =
+        CreationAttributes().hasAlpha() ? kNonOpaque : kOpaque;
+
+    std::unique_ptr<ImageBufferSurface> surface;
+    surface.reset(new TextureImageBufferSurface(
+        webgl_texture_->ContextGroup()->GetAGLInterface(),
+        webgl_texture_->GetTarget(), webgl_texture_->Object(), host()->Size(),
+        opacity_mode));
+    texture_image_buffer_ = ImageBuffer::Create(std::move(surface));
+  }
+
+  return texture_image_buffer_.get();
+}
+
 RefPtr<StaticBitmapImage>
 OffscreenCanvasRenderingContext2D::TransferToStaticBitmapImage() {
   if (!GetImageBuffer())
     return nullptr;
   sk_sp<SkImage> sk_image = GetImageBuffer()->NewSkImageSnapshot(
       kPreferAcceleration, kSnapshotReasonTransferToImageBitmap);
   RefPtr<StaticBitmapImage> image =
       StaticBitmapImage::Create(std::move(sk_image));
   image->SetOriginClean(this->OriginClean());
   return image;
@@ skipping 66 matching lines @@
 
 void OffscreenCanvasRenderingContext2D::DisableDeferral(DisableDeferralReason) {
 }
 
 AffineTransform OffscreenCanvasRenderingContext2D::BaseTransform() const {
   if (!HasImageBuffer())
     return AffineTransform();  // identity
   return GetImageBuffer()->BaseTransform();
 }
 
-void OffscreenCanvasRenderingContext2D::DidDraw(const SkIRect& dirty_rect) {}
+void OffscreenCanvasRenderingContext2D::DidDraw(const SkIRect& dirty_rect) {
+  GrContext* gr_context = SharedGpuContext::Gr();
+  if (texture_image_buffer_ && gr_context) {
+    DVLOG(1) << "Flush";
+    gr_context->resetContext();
+    texture_image_buffer_->FlushGpu(kFlushReasonDrawImageOfWebGL);
+    DVLOG(1) << "EndFlush";
+  }
+}
 
 bool OffscreenCanvasRenderingContext2D::StateHasFilter() {
   return GetState().HasFilterForOffscreenCanvas(host()->Size());
 }
 
 sk_sp<SkImageFilter> OffscreenCanvasRenderingContext2D::StateGetFilter() {
   return GetState().GetFilterForOffscreenCanvas(host()->Size());
 }
 
 void OffscreenCanvasRenderingContext2D::ValidateStateStack() const {
@@ skipping 22 matching lines @@
 }
 
 CanvasPixelFormat OffscreenCanvasRenderingContext2D::PixelFormat() const {
   return color_params().pixel_format();
 }
 
 bool OffscreenCanvasRenderingContext2D::IsAccelerated() const {
   return HasImageBuffer() && GetImageBuffer()->IsAccelerated();
 }
 }