Synchronize OffscreenCanvas content with the placeholder canvas

third_party/WebKit/Source/core/html/HTMLCanvasElement.cpp

 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. 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.
@@ skipping 127 matching lines @@
 }
 
 DEFINE_NODE_FACTORY(HTMLCanvasElement)
 
 HTMLCanvasElement::~HTMLCanvasElement() {
   v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(
       -m_externallyAllocatedMemory);
 }
 
 void HTMLCanvasElement::dispose() {
+  releasePlaceholderFrame();
+
   if (m_context) {
     m_context->detachCanvas();
     m_context = nullptr;
   }
   m_imageBuffer = nullptr;
 }
 
 void HTMLCanvasElement::parseAttribute(const QualifiedName& name,
                                        const AtomicString& oldValue,
                                        const AtomicString& value) {
@@ skipping 305 matching lines @@
         if (layoutBox() && layoutBox()->hasAcceleratedCompositing())
           layoutBox()->contentChanged(CanvasChanged);
       }
       if (hadImageBuffer)
         layoutObject->setShouldDoFullPaintInvalidation();
     }
   }
 }
 
 bool HTMLCanvasElement::paintsIntoCanvasBuffer() const {
+  if (placeholderFrame())
+    return false;
   DCHECK(m_context);
-
   if (!m_context->isAccelerated())
     return true;
   if (layoutBox() && layoutBox()->hasAcceleratedCompositing())
     return false;
 
   return true;
 }
 
 void HTMLCanvasElement::notifyListenersCanvasChanged() {
   if (m_listeners.size() == 0)
@@ skipping 23 matching lines @@
       if (listener->needsNewFrame()) {
         listener->sendNewFrame(image);
       }
     }
   }
 }
 
 void HTMLCanvasElement::paint(GraphicsContext& context, const LayoutRect& r) {
   // FIXME: crbug.com/438240; there is a bug with the new CSS blending and
   // compositing feature.
-  if (!m_context)
+  if (!m_context && !placeholderFrame())
     return;
 
   const ComputedStyle* style = ensureComputedStyle();
   SkFilterQuality filterQuality =
       (style && style->imageRendering() == ImageRenderingPixelated)
           ? kNone_SkFilterQuality
           : kLow_SkFilterQuality;
 
   if (is3D()) {
     m_context->setFilterQuality(filterQuality);
   } else if (hasImageBuffer()) {
     m_imageBuffer->setFilterQuality(filterQuality);
   }
 
   if (hasImageBuffer() && !m_imageBufferIsClear)
     PaintTiming::from(document()).markFirstContentfulPaint();
 
   if (!paintsIntoCanvasBuffer() && !document().printing())
     return;
 
+  if (placeholderFrame()) {
+    DCHECK(document().printing());
+    context.drawImage(placeholderFrame().get(), pixelSnappedIntRect(r));
+    return;
+  }
+
   // TODO(junov): Paint is currently only implemented by ImageBitmap contexts.
   // We could improve the abstraction by making all context types paint
   // themselves (implement paint()).
   if (m_context->paint(context, pixelSnappedIntRect(r)))
     return;
 
   m_context->paintRenderingResultsToCanvas(FrontBuffer);
   if (hasImageBuffer()) {
     if (!context.contextDisabled()) {
       SkBlendMode compositeOperator =
@@ skipping 63 matching lines @@
             width(), height(), kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
         snapshot->readPixels(imageInfo, imageData->data()->data(),
                              imageInfo.minRowBytes(), 0, 0);
       }
     }
     return imageData;
   }
 
   imageData = ImageData::create(m_size);
 
-  if (!m_context || !imageData)
+  if ((!m_context || !imageData) && !placeholderFrame())
     return imageData;
 
-  DCHECK(m_context->is2d());
+  DCHECK((m_context && m_context->is2d()) || placeholderFrame());
+  sk_sp<SkImage> snapshot;
   if (hasImageBuffer()) {
-    sk_sp<SkImage> snapshot =
-        buffer()->newSkImageSnapshot(PreferNoAcceleration, reason);
-    if (snapshot) {
-      SkImageInfo imageInfo = SkImageInfo::Make(
-          width(), height(), kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
-      snapshot->readPixels(imageInfo, imageData->data()->data(),
-                           imageInfo.minRowBytes(), 0, 0);
-    }
+    snapshot = buffer()->newSkImageSnapshot(PreferNoAcceleration, reason);
+  } else if (placeholderFrame()) {
+    snapshot = placeholderFrame()->imageForCurrentFrame();
+  }
+
+  if (snapshot) {
+    SkImageInfo imageInfo = SkImageInfo::Make(
+        width(), height(), kRGBA_8888_SkColorType, kUnpremul_SkAlphaType);
+    snapshot->readPixels(imageInfo, imageData->data()->data(),
+                         imageInfo.minRowBytes(), 0, 0);
   }
 
   return imageData;
 }
 
 String HTMLCanvasElement::toDataURLInternal(
     const String& mimeType,
     const double& quality,
     SourceDrawingBuffer sourceBuffer) const {
   if (!isPaintable())
@@ skipping 31 matching lines @@
   if (!imageData)  // allocation failure
     return String("data:,");
 
   return ImageDataBuffer(imageData->size(), imageData->data()->data())
       .toDataURL(encodingMimeType, quality);
 }
 
 String HTMLCanvasElement::toDataURL(const String& mimeType,
                                     const ScriptValue& qualityArgument,
                                     ExceptionState& exceptionState) const {
-  if (surfaceLayerBridge()) {
-    exceptionState.throwDOMException(InvalidStateError,
-                                     "canvas.toDataURL is not allowed for a "
-                                     "canvas that has transferred its control "
-                                     "to offscreen.");
-    return String();
-  }
   if (!originClean()) {
     exceptionState.throwSecurityError("Tainted canvases may not be exported.");
     return String();
   }
 
   double quality = UndefinedQualityValue;
   if (!qualityArgument.isEmpty()) {
     v8::Local<v8::Value> v8Value = qualityArgument.v8Value();
     if (v8Value->IsNumber()) {
       quality = v8Value.As<v8::Number>()->Value();
     }
   }
   return toDataURLInternal(mimeType, quality, BackBuffer);
 }
 
 void HTMLCanvasElement::toBlob(BlobCallback* callback,
                                const String& mimeType,
                                const ScriptValue& qualityArgument,
                                ExceptionState& exceptionState) {
-  if (surfaceLayerBridge()) {
-    exceptionState.throwDOMException(InvalidStateError,
-                                     "canvas.toBlob is not allowed for a "
-                                     "canvas that has transferred its control "
-                                     "to offscreen.");
-    return;
-  }
-
   if (!originClean()) {
     exceptionState.throwSecurityError("Tainted canvases may not be exported.");
     return;
   }
 
   if (!isPaintable()) {
     // If the canvas element's bitmap has no pixels
     TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, &document())
         ->postTask(BLINK_FROM_HERE,
                    WTF::bind(&BlobCallback::handleEvent,
@@ skipping 463 matching lines @@
   if (!width() || !height()) {
     *status = ZeroSizeCanvasSourceImageStatus;
     return nullptr;
   }
 
   if (!isPaintable()) {
     *status = InvalidSourceImageStatus;
     return nullptr;
   }
 
+  if (placeholderFrame()) {
+    *status = NormalSourceImageStatus;
+    return placeholderFrame();
+  }
+
   if (!m_context) {
     *status = NormalSourceImageStatus;
     return createTransparentImage(size());
   }
 
   sk_sp<SkImage> skImage;
   if (m_context->is3d()) {
     // Because WebGL sources always require making a copy of the back buffer, we
     // use paintRenderingResultsToCanvas instead of getImage in order to keep a
     // cached copy of the backing in the canvas's ImageBuffer.
@@ skipping 144 matching lines @@
   mojom::blink::OffscreenCanvasSurfacePtr service;
   Platform::current()->interfaceProvider()->getInterface(
       mojo::GetProxy(&service));
   m_surfaceLayerBridge =
       wrapUnique(new CanvasSurfaceLayerBridge(std::move(service)));
   return m_surfaceLayerBridge->createSurfaceLayer(this->width(),
                                                   this->height());
 }
 
 }  // namespace blink