Make OffscreenCanvas Webgl Context work with preserveDrawingBuffer flag

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 731 matching lines @@
   if (!offscreenCanvas()->hasPlaceholderCanvas()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "Commit() was called on a context whose "
                                      "OffscreenCanvas is not associated with a "
                                      "canvas element.");
     return exceptionState.reject(scriptState);
   }
   if (!drawingBuffer()) {
     return offscreenCanvas()->commit(nullptr, false, scriptState);
   }
-  // TODO(crbug.com/646864): Make commit() work correctly with
-  // { preserveDrawingBuffer : true }.
+
+  RefPtr<StaticBitmapImage> image;
+  if (creationAttributes().preserveDrawingBuffer()) {
+    int width = drawingBuffer()->size().width();
+    int height = drawingBuffer()->size().height();
+    SkImageInfo imageInfo =
+        SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
+                          creationAttributes().alpha() ? kPremul_SkAlphaType
+                                                       : kOpaque_SkAlphaType);
+    image = StaticBitmapImage::create(makeImageSnapshot(imageInfo));
+  } else {
+    image = drawingBuffer()->transferToStaticBitmapImage();
+  }
+
   return offscreenCanvas()->commit(
-      std::move(drawingBuffer()->transferToStaticBitmapImage()),
+      std::move(image),
       drawingBuffer()->contextProvider()->isSoftwareRendering(), scriptState);
 }
 
 PassRefPtr<Image> WebGLRenderingContextBase::getImage(
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!drawingBuffer())
     return nullptr;
 
   drawingBuffer()->resolveAndBindForReadAndDraw();
   IntSize size = clampedCanvasSize();
   OpacityMode opacityMode =
       creationAttributes().hasAlpha() ? NonOpaque : Opaque;
   std::unique_ptr<AcceleratedImageBufferSurface> surface =
       WTF::makeUnique<AcceleratedImageBufferSurface>(size, opacityMode);
   if (!surface->isValid())
     return nullptr;
   std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(std::move(surface));
   if (!buffer->copyRenderingResultsFromDrawingBuffer(drawingBuffer(),
                                                      BackBuffer)) {
     // copyRenderingResultsFromDrawingBuffer is expected to always succeed
     // because we've explicitly created an Accelerated surface and have already
     // validated it.
     NOTREACHED();
     return nullptr;
   }
   return buffer->newImageSnapshot(hint, reason);
 }
 
+sk_sp<SkImage> WebGLRenderingContextBase::makeImageSnapshot(
+    SkImageInfo& imageInfo) {
+  drawingBuffer()->resolveAndBindForReadAndDraw();
+  gpu::gles2::GLES2Interface* gl = SharedGpuContext::gl();
+
+  SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
+  sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
+      SharedGpuContext::gr(), SkBudgeted::kYes, imageInfo, 0,
+      imageInfo.alphaType() == kOpaque_SkAlphaType ? nullptr
+                                                   : &disableLCDProps);
+  GLuint textureId = skia::GrBackendObjectToGrGLTextureInfo(
+                         surface->getTextureHandle(
+                             SkSurface::kDiscardWrite_TextureHandleAccess))
+                         ->fID;
+
+  drawingBuffer()->copyToPlatformTexture(
+      gl, textureId, GL_RGBA, GL_UNSIGNED_BYTE, 0, true, false, IntPoint(0, 0),
+      IntRect(IntPoint(0, 0), drawingBuffer()->size()), BackBuffer);
+  return surface->makeImageSnapshot();
+}
+
 ImageData* WebGLRenderingContextBase::toImageData(SnapshotReason reason) {
   ImageData* imageData = nullptr;
   // TODO(ccameron): WebGL should produce sRGB images.
   // https://crbug.com/672299
   if (drawingBuffer()) {
     // For un-premultiplied data
     imageData = paintRenderingResultsToImageData(BackBuffer);
     if (imageData) {
       return imageData;
     }
 
     int width = drawingBuffer()->size().width();
     int height = drawingBuffer()->size().height();
-    OpacityMode opacityMode = creationAttributes().alpha() ? NonOpaque : Opaque;
-
-    drawingBuffer()->resolveAndBindForReadAndDraw();
-    gpu::gles2::GLES2Interface* gl = SharedGpuContext::gl();
-    SkImageInfo imageInfo = SkImageInfo::Make(
-        width, height, kRGBA_8888_SkColorType,
-        Opaque == opacityMode ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
-    SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
-    sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
-        SharedGpuContext::gr(), SkBudgeted::kYes, imageInfo, 0,
-        Opaque == opacityMode ? nullptr : &disableLCDProps);
-    GLuint textureId = skia::GrBackendObjectToGrGLTextureInfo(
-                           surface->getTextureHandle(
-                               SkSurface::kDiscardWrite_TextureHandleAccess))
-                           ->fID;
-
-    drawingBuffer()->copyToPlatformTexture(
-        gl, textureId, GL_RGBA, GL_UNSIGNED_BYTE, 0, true, false,
-        IntPoint(0, 0), IntRect(IntPoint(0, 0), drawingBuffer()->size()),
-        BackBuffer);
-    sk_sp<SkImage> snapshot = surface->makeImageSnapshot();
+    SkImageInfo imageInfo =
+        SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
+                          creationAttributes().alpha() ? kPremul_SkAlphaType
+                                                       : kOpaque_SkAlphaType);
+    sk_sp<SkImage> snapshot = makeImageSnapshot(imageInfo);
     if (snapshot) {
       imageData = ImageData::create(drawingBuffer()->size());
       snapshot->readPixels(imageInfo, imageData->data()->data(),
                            imageInfo.minRowBytes(), 0, 0);
     }
   }
   return imageData;
 }
 
 namespace {
@@ skipping 3282 matching lines @@
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLenum format,
                                                  GLenum type,
                                                  DOMArrayBufferView* pixels,
                                                  GLuint offset) {
   if (isContextLost())
     return;
   // Due to WebGL's same-origin restrictions, it is not possible to
   // taint the origin using the WebGL API.
-  ASSERT(canvas()->originClean());
+  DCHECK(canvas() ? canvas()->originClean() : offscreenCanvas()->originClean());
+
   // Validate input parameters.
   if (!pixels) {
     synthesizeGLError(GL_INVALID_VALUE, "readPixels",
                       "no destination ArrayBufferView");
     return;
   }
   CheckedNumeric<GLuint> offsetInBytes = offset;
   offsetInBytes *= pixels->typeSize();
   if (!offsetInBytes.IsValid() ||
       offsetInBytes.ValueOrDie() > pixels->byteLength()) {
@@ skipping 3689 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink