WebGL: clarify which Front or Back buffer is used by each API.

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 339 matching lines @@
 
     return true;
 }
 
 
 void HTMLCanvasElement::paint(GraphicsContext* context, const LayoutRect& r)
 {
     if (m_context) {
         if (!paintsIntoCanvasBuffer() && !document().printing())
             return;
-        m_context->paintRenderingResultsToCanvas(CanvasRenderingContext::Front);
+        m_context->paintRenderingResultsToCanvas(FrontBuffer);
     }
 
     if (hasImageBuffer()) {
         CompositeOperator compositeOperator = !m_context || m_context->hasAlpha() ? CompositeSourceOver : CompositeCopy;
         context->drawImageBuffer(buffer(), pixelSnappedIntRect(r), 0, compositeOperator);
     } else {
         // When alpha is false, we should draw to opaque black.
         if (m_context && !m_context->hasAlpha())
             context->fillRect(FloatRect(r), Color(0, 0, 0));
     }
@@ skipping 27 matching lines @@
 
     // FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this method to be used on a worker thread).
     if (mimeType.isNull() || !MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(lowercaseMimeType))
         lowercaseMimeType = "image/png";
 
     return lowercaseMimeType;
 }
 
 const AtomicString HTMLCanvasElement::imageSourceURL() const
 {
-    return AtomicString(toDataURLInternal("image/png", 0, true));
+    return AtomicString(toDataURLInternal("image/png", 0, FrontBuffer));
 }
 
-String HTMLCanvasElement::toDataURLInternal(const String& mimeType, const double* quality, bool isSaving) const
+String HTMLCanvasElement::toDataURLInternal(const String& mimeType, const double* quality, SourceDrawingBuffer sourceBuffer) const
 {
     if (m_size.isEmpty() || !canCreateImageBuffer(size()))
         return String("data:,");
 
     String encodingMimeType = toEncodingMimeType(mimeType);
     if (!m_context) {
         RefPtrWillBeRawPtr<ImageData> imageData = ImageData::create(m_size);
         return ImageDataToDataURL(ImageDataBuffer(imageData->size(), imageData->data()), encodingMimeType, quality);
     }
 
-    // Try to get ImageData first, as that may avoid lossy conversions.
-    RefPtrWillBeRawPtr<ImageData> imageData = getImageData();
-
-    if (imageData)
-        return ImageDataToDataURL(ImageDataBuffer(imageData->size(), imageData->data()), encodingMimeType, quality);
-
     if (m_context->is3d()) {
-        m_context->paintRenderingResultsToCanvas(isSaving ? CanvasRenderingContext::Front : CanvasRenderingContext::Back);
+        // Get non-premultiplied data because of inaccurate premultiplied alpha conversion of buffer()->toDataURL().
+        RefPtrWillBeRawPtr<ImageData> imageData =
+            toWebGLRenderingContext(m_context.get())->paintRenderingResultsToImageData(sourceBuffer);
+        if (imageData)
+            return ImageDataToDataURL(ImageDataBuffer(imageData->size(), imageData->data()), encodingMimeType, quality);
+        m_context->paintRenderingResultsToCanvas(sourceBuffer);
     }
 
     return buffer()->toDataURL(encodingMimeType, quality);
 }
 
 String HTMLCanvasElement::toDataURL(const String& mimeType, const double* quality, ExceptionState& exceptionState) const
 {
     if (!m_originClean) {
         exceptionState.throwSecurityError("Tainted canvases may not be exported.");
         return String();
     }
 
-    return toDataURLInternal(mimeType, quality);
-}
-
-PassRefPtrWillBeRawPtr<ImageData> HTMLCanvasElement::getImageData() const
-{
-    if (!m_context || !m_context->is3d())
-        return nullptr;
-    return toWebGLRenderingContext(m_context.get())->paintRenderingResultsToImageData();
+    return toDataURLInternal(mimeType, quality, BackBuffer);
 }
 
 SecurityOrigin* HTMLCanvasElement::securityOrigin() const
 {
     return document().securityOrigin();
 }
 
 bool HTMLCanvasElement::shouldAccelerate(const IntSize& size) const
 {
     if (m_context && !m_context->is2d())
@@ skipping 220 matching lines @@
 void HTMLCanvasElement::ensureUnacceleratedImageBuffer()
 {
     if ((hasImageBuffer() && !m_imageBuffer->isAccelerated()) || m_didFailToCreateImageBuffer)
         return;
     discardImageBuffer();
     OpacityMode opacityMode = !m_context || m_context->hasAlpha() ? NonOpaque : Opaque;
     m_imageBuffer = ImageBuffer::create(size(), opacityMode);
     m_didFailToCreateImageBuffer = !m_imageBuffer;
 }
 
-Image* HTMLCanvasElement::copiedImage() const
+Image* HTMLCanvasElement::copiedImage(SourceDrawingBuffer sourceBuffer) const
 {
     if (!m_copiedImage && buffer()) {
-        if (m_context && m_context->is3d()) {
-            m_context->paintRenderingResultsToCanvas(CanvasRenderingContext::Front);
-        }
+        if (m_context && m_context->is3d())
+            m_context->paintRenderingResultsToCanvas(sourceBuffer);
         m_copiedImage = buffer()->copyImage(CopyBackingStore, Unscaled);
         updateExternallyAllocatedMemory();
     }
     return m_copiedImage.get();
 }
 
 void HTMLCanvasElement::discardImageBuffer()
 {
     m_contextStateSaver.clear(); // uses context owned by m_imageBuffer
     m_imageBuffer.clear();
@@ skipping 46 matching lines @@
         *status = ZeroSizeCanvasSourceImageStatus;
         return nullptr;
     }
 
     if (!buffer()) {
         *status = InvalidSourceImageStatus;
         return nullptr;
     }
 
     if (m_context && m_context->is3d()) {
-        m_context->paintRenderingResultsToCanvas(CanvasRenderingContext::Back);
+        m_context->paintRenderingResultsToCanvas(BackBuffer);
         *status = ExternalSourceImageStatus;
 
         // can't create SkImage from WebGLImageBufferSurface (contains only SkBitmap)
         return m_imageBuffer->copyImage(DontCopyBackingStore, Unscaled);
     }
 
     RefPtr<SkImage> image = m_imageBuffer->newImageSnapshot();
     if (image) {
         *status = NormalSourceImageStatus;
 
@@ skipping 10 matching lines @@
 {
     return !originClean();
 }
 
 FloatSize HTMLCanvasElement::sourceSize() const
 {
     return FloatSize(width(), height());
 }
 
 }