Merge 92908 - Readback composited webgl results for printing

Source/WebKit/chromium/src/GraphicsContext3DChromium.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 72 matching lines @@
 //----------------------------------------------------------------------
 // GraphicsContext3DInternal
 
 GraphicsContext3DInternal::GraphicsContext3DInternal()
     : m_webViewImpl(0)
     , m_initializedAvailableExtensions(false)
     , m_layerComposited(false)
 #if USE(SKIA)
     , m_grContext(0)
 #elif USE(CG)
-    , m_renderOutput(0)
+    , m_renderOutputSize(0)
 #else
 #error Must port to your platform
 #endif
 {
 }
 
 GraphicsContext3DInternal::~GraphicsContext3DInternal()
 {
-#if USE(CG)
-    if (m_renderOutput)
-        delete[] m_renderOutput;
-#endif
 #if USE(SKIA)
     if (m_grContext) {
         m_grContext->contextDestroyed();
         GrSafeUnref(m_grContext);
     }
 #endif
 }
 
 bool GraphicsContext3DInternal::initialize(GraphicsContext3D::Attributes attrs, HostWindow* hostWindow, bool renderDirectlyToHostWindow)
 {
@@ skipping 82 matching lines @@
 void GraphicsContext3DInternal::markLayerComposited()
 {
     m_layerComposited = true;
 }
 
 bool GraphicsContext3DInternal::layerComposited() const
 {
     return m_layerComposited;
 }
 
-void GraphicsContext3DInternal::paintRenderingResultsToCanvas(CanvasRenderingContext* context)
+void GraphicsContext3DInternal::paintFramebufferToCanvas(int framebuffer, int width, int height, bool premultiplyAlpha, ImageBuffer* imageBuffer)
 {
-    HTMLCanvasElement* canvas = context->canvas();
-    ImageBuffer* imageBuffer = canvas->buffer();
     unsigned char* pixels = 0;
+    size_t bufferSize = 4 * width * height;
 #if USE(SKIA)
     const SkBitmap* canvasBitmap = imageBuffer->context()->platformContext()->bitmap();
     const SkBitmap* readbackBitmap = 0;
     ASSERT(canvasBitmap->config() == SkBitmap::kARGB_8888_Config);
-    if (canvasBitmap->width() == m_impl->width() && canvasBitmap->height() == m_impl->height()) {
+    if (canvasBitmap->width() == width && canvasBitmap->height() == height) {
         // This is the fastest and most common case. We read back
         // directly into the canvas's backing store.
         readbackBitmap = canvasBitmap;
         m_resizingBitmap.reset();
     } else {
         // We need to allocate a temporary bitmap for reading back the
         // pixel data. We will then use Skia to rescale this bitmap to
         // the size of the canvas's backing store.
-        if (m_resizingBitmap.width() != m_impl->width() || m_resizingBitmap.height() != m_impl->height()) {
+        if (m_resizingBitmap.width() != width || m_resizingBitmap.height() != height) {
             m_resizingBitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                                       m_impl->width(),
-                                       m_impl->height());
+                                       width,
+                                       height);
             if (!m_resizingBitmap.allocPixels())
                 return;
         }
         readbackBitmap = &m_resizingBitmap;
     }
 
     // Read back the frame buffer.
     SkAutoLockPixels bitmapLock(*readbackBitmap);
     pixels = static_cast<unsigned char*>(readbackBitmap->getPixels());
 #elif USE(CG)
-    if (m_renderOutput)
-        pixels = m_renderOutput;
+    if (!m_renderOutput || m_renderOutputSize != bufferSize) {
+        m_renderOutput = adoptArrayPtr(new unsigned char[bufferSize]);
+        m_renderOutputSize = bufferSize;
+    }
+
+    pixels = m_renderOutput.get();
 #else
 #error Must port to your platform
 #endif
 
-    m_impl->readBackFramebuffer(pixels, 4 * m_impl->width() * m_impl->height());
+    m_impl->readBackFramebuffer(pixels, 4 * width * height, framebuffer, width, height);
 
-    if (!m_impl->getContextAttributes().premultipliedAlpha) {
-        size_t bufferSize = 4 * m_impl->width() * m_impl->height();
-
+    if (premultiplyAlpha) {
         for (size_t i = 0; i < bufferSize; i += 4) {
             pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255);
             pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255);
             pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255);
         }
     }
 
 #if USE(SKIA)
     readbackBitmap->notifyPixelsChanged();
     if (m_resizingBitmap.readyToDraw()) {
         // We need to draw the resizing bitmap into the canvas's backing store.
         SkCanvas canvas(*canvasBitmap);
         SkRect dst;
         dst.set(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(canvasBitmap->width()), SkIntToScalar(canvasBitmap->height()));
         canvas.drawBitmapRect(m_resizingBitmap, 0, dst);
     }
 #elif USE(CG)
-    if (m_renderOutput && context->is3d()) {
-        WebGLRenderingContext* webGLContext = static_cast<WebGLRenderingContext*>(context);
-        webGLContext->graphicsContext3D()->paintToCanvas(m_renderOutput, m_impl->width(), m_impl->height(), canvas->width(), canvas->height(), imageBuffer->context()->platformContext());
-    }
+    GraphicsContext3D::paintToCanvas(pixels, width, height, imageBuffer->width(), imageBuffer->height(), imageBuffer->context()->platformContext());
 #else
 #error Must port to your platform
 #endif
 }
 
+void GraphicsContext3DInternal::paintRenderingResultsToCanvas(CanvasRenderingContext* context)
+{
+    ImageBuffer* imageBuffer = context->canvas()->buffer();
+    paintFramebufferToCanvas(0, m_impl->width(), m_impl->height(), !m_impl->getContextAttributes().premultipliedAlpha, imageBuffer);
+}
+
+bool GraphicsContext3DInternal::paintCompositedResultsToCanvas(CanvasRenderingContext* context)
+{
+#if USE(ACCELERATED_COMPOSITING)
+    if (platformLayer())
+        return platformLayer()->paintRenderedResultsToCanvas(context->canvas()->buffer());
+#endif
+    return false;
+}
+
 PassRefPtr<ImageData> GraphicsContext3DInternal::paintRenderingResultsToImageData()
 {
     if (m_impl->getContextAttributes().premultipliedAlpha)
         return 0;
     
     RefPtr<ImageData> imageData = ImageData::create(IntSize(m_impl->width(), m_impl->height()));
     unsigned char* pixels = imageData->data()->data()->data();
     size_t bufferSize = 4 * m_impl->width() * m_impl->height();
 
-    m_impl->readBackFramebuffer(pixels, bufferSize);
+    m_impl->readBackFramebuffer(pixels, bufferSize, 0, m_impl->width(), m_impl->height());
 
     for (size_t i = 0; i < bufferSize; i += 4)
         std::swap(pixels[i], pixels[i + 2]);
 
     return imageData.release();
 }
 
 bool GraphicsContext3DInternal::paintsIntoCanvasBuffer() const
 {
     // If the gpu compositor is on then skip the readback and software rendering path.
     return !m_webViewImpl->isAcceleratedCompositingActive();
 }
 
 void GraphicsContext3DInternal::reshape(int width, int height)
 {
     if (width == m_impl->width() && height == m_impl->height())
         return;
 
     m_impl->reshape(width, height);
-
-#if USE(CG)
-    // Need to reallocate the client-side backing store.
-    // FIXME: make this more efficient.
-    if (m_renderOutput) {
-        delete[] m_renderOutput;
-        m_renderOutput = 0;
-    }
-    int rowBytes = width * 4;
-    m_renderOutput = new unsigned char[height * rowBytes];
-#endif // USE(CG)
 }
 
 IntSize GraphicsContext3DInternal::getInternalFramebufferSize() const
 {
     return IntSize(m_impl->width(), m_impl->height());
 }
 
 bool GraphicsContext3DInternal::isContextLost()
 {
     return m_impl->isContextLost();
@@ skipping 844 matching lines @@
 DELEGATE_TO_INTERNAL(markLayerComposited)
 DELEGATE_TO_INTERNAL(markContextChanged)
 
 bool GraphicsContext3D::layerComposited() const
 {
     return m_internal->layerComposited();
 }
 
 DELEGATE_TO_INTERNAL_1(paintRenderingResultsToCanvas, CanvasRenderingContext*)
 DELEGATE_TO_INTERNAL_R(paintRenderingResultsToImageData, PassRefPtr<ImageData>)
+DELEGATE_TO_INTERNAL_1R(paintCompositedResultsToCanvas, CanvasRenderingContext*, bool)
 
 bool GraphicsContext3D::paintsIntoCanvasBuffer() const
 {
     return m_internal->paintsIntoCanvasBuffer();
 }
 
 DELEGATE_TO_INTERNAL_R(createBuffer, Platform3DObject)
 DELEGATE_TO_INTERNAL_R(createFramebuffer, Platform3DObject)
 DELEGATE_TO_INTERNAL_R(createProgram, Platform3DObject)
 DELEGATE_TO_INTERNAL_R(createRenderbuffer, Platform3DObject)
@@ skipping 67 matching lines @@
 
 void GraphicsContext3DInternal::setSwapBuffersCompleteCallbackCHROMIUM(PassOwnPtr<Extensions3DChromium::SwapBuffersCompleteCallbackCHROMIUM> cb)
 {
     m_swapBuffersCompleteCallbackAdapter = SwapBuffersCompleteCallbackAdapter::create(cb);
     m_impl->setSwapBuffersCompleteCallbackCHROMIUM(m_swapBuffersCompleteCallbackAdapter.get());
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WEBGL)