Direct composite canvas background if possible.

Source/core/rendering/RenderLayerBacking.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 49 matching lines @@
 #include "core/rendering/FilterEffectRenderer.h"
 
 #include "core/platform/graphics/GraphicsContext3D.h"
 
 using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle*);
 static IntRect clipBox(RenderBox* renderer);
 
-static inline bool isAcceleratedCanvas(RenderObject* renderer)
+static IntRect contentsRect(const RenderObject* renderer)
+{
+    if (!renderer->isBox())
+        return IntRect();
+
+    return renderer->isVideo() ?
+        toRenderVideo(renderer)->videoBox() :
+        pixelSnappedIntRect(toRenderBox(renderer)->contentBoxRect());
+}
+
+static IntRect backgroundRect(const RenderObject* renderer)
+{
+    if (!renderer->isBox())
+        return IntRect();
+
+    LayoutRect rect;
+    const RenderBox* box = toRenderBox(renderer);
+    EFillBox clip = box->style()->backgroundClip();
+    switch (clip) {
+    case BorderFillBox:
+        rect = box->borderBoxRect();
+        break;
+    case PaddingFillBox:
+        rect = box->paddingBoxRect();
+        break;
+    case ContentFillBox:
+        rect = box->contentBoxRect();
+        break;
+    case TextFillBox:
+        break;
+    }
+
+    return pixelSnappedIntRect(rect);
+}
+
+static inline bool isAcceleratedCanvas(const RenderObject* renderer)
 {
     if (renderer->isCanvas()) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             return context->isAccelerated();
     }
     return false;
 }
 
+static bool hasBoxDecorations(const RenderStyle* style)
+{
+    return style->hasBorder() || style->hasBorderRadius() || style->hasOutline() || style->hasAppearance() || style->boxShadow() || style->hasFilter();
+}
+
+static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle* style)
+{
+    return hasBoxDecorations(style) || style->hasBackgroundImage();
+}
+
+static bool contentLayerSupportsDirectBackgroundComposition(const RenderObject* renderer)
+{
+    // No support for decorations - border, border-radius or outline.
+    // Only simple background - solid color or transparent.
+    if (hasBoxDecorationsOrBackgroundImage(renderer->style()))
+        return false;
+
+    // If there is no background, there is nothing to support.
+    if (!renderer->style()->hasBackground())
+        return true;
+
+    // Simple background that is contained within the contents rect.
+    return contentsRect(renderer).contains(backgroundRect(renderer));
+}
+
 // Get the scrolling coordinator in a way that works inside RenderLayerBacking's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(RenderLayer* layer)
 {
     Page* page = layer->renderer()->frame()->page();
     if (!page)
         return 0;
 
     return page->scrollingCoordinator();
 }
 
@@ skipping 666 matching lines @@
         // m_scrollingContentsLayer only needs backing store if the scrolled contents need to paint.
         bool hasNonScrollingPaintedContent = m_owningLayer->hasVisibleContent() && m_owningLayer->hasBoxDecorationsOrBackground();
         m_graphicsLayer->setDrawsContent(hasNonScrollingPaintedContent);
 
         bool hasScrollingPaintedContent = m_owningLayer->hasVisibleContent() && (renderer()->hasBackground() || paintsChildren());
         m_scrollingContentsLayer->setDrawsContent(hasScrollingPaintedContent);
         return;
     }
 
     bool hasPaintedContent = containsPaintedContent(isSimpleContainer);
+    if (hasPaintedContent && isAcceleratedCanvas(renderer())) {
+        Color bgColor;
+        if (contentLayerSupportsDirectBackgroundComposition(renderer())) {
+            bgColor = rendererBackgroundColor();
+            hasPaintedContent = false;
+        }
+        HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(renderer()->node());
+        CanvasRenderingContext* context = canvas->renderingContext();
+        context->platformLayer()->setBackgroundColor(bgColor.rgb());
+    }
 
     // FIXME: we could refine this to only allocate backing for one of these layers if possible.
     m_graphicsLayer->setDrawsContent(hasPaintedContent);
     if (m_foregroundLayer)
         m_foregroundLayer->setDrawsContent(hasPaintedContent);
 
     if (m_backgroundLayer)
         m_backgroundLayer->setDrawsContent(hasPaintedContent);
 }
 
@@ skipping 290 matching lines @@
         // relative to it. So we can break here.
         if (curr->isComposited())
             break;
         
         finalOpacity *= curr->renderer()->opacity();
     }
 
     return finalOpacity;
 }
 
-static bool hasBoxDecorations(const RenderStyle* style)
-{
-    return style->hasBorder() || style->hasBorderRadius() || style->hasOutline() || style->hasAppearance() || style->boxShadow() || style->hasFilter();
-}
-
-static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle* style)
-{
-    return hasBoxDecorations(style) || style->hasBackgroundImage();
-}
-
 Color RenderLayerBacking::rendererBackgroundColor() const
 {
     RenderObject* backgroundRenderer = renderer();
     if (backgroundRenderer->isRoot())
         backgroundRenderer = backgroundRenderer->rendererForRootBackground();
 
     return backgroundRenderer->resolveColor(CSSPropertyBackgroundColor);
 }
 
 void RenderLayerBacking::updateBackgroundColor(bool isSimpleContainer)
@@ skipping 163 matching lines @@
         return false;
 
     if (isDirectlyCompositedImage())
         return false;
 
     // FIXME: we could optimize cases where the image, video or canvas is known to fill the border box entirely,
     // and set background color on the layer in that case, instead of allocating backing store and painting.
     if (renderer()->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
         return m_owningLayer->hasBoxDecorationsOrBackground();
 
-    if (isAcceleratedCanvas(renderer()))
-        return m_owningLayer->hasBoxDecorationsOrBackground();
-
     return true;
 }
 
 // An image can be directly compositing if it's the sole content of the layer, and has no box decorations
 // that require painting. Direct compositing saves backing store.
 bool RenderLayerBacking::isDirectlyCompositedImage() const
 {
     RenderObject* renderObject = renderer();
     
     if (!renderObject->isImage() || m_owningLayer->hasBoxDecorationsOrBackground() || renderObject->hasClip())
@@ skipping 88 matching lines @@
 }
 
 // Return the offset from the top-left of this compositing layer at which the renderer's contents are painted.
 IntSize RenderLayerBacking::contentOffsetInCompostingLayer() const
 {
     return IntSize(-m_compositedBounds.x(), -m_compositedBounds.y());
 }
 
 IntRect RenderLayerBacking::contentsBox() const
 {
-    if (!renderer()->isBox())
-        return IntRect();
-
-    IntRect contentsRect;
-    if (renderer()->isVideo()) {
-        RenderVideo* videoRenderer = toRenderVideo(renderer());
-        contentsRect = videoRenderer->videoBox();
-    } else
-        contentsRect = pixelSnappedIntRect(toRenderBox(renderer())->contentBoxRect());
-
-    contentsRect.move(contentOffsetInCompostingLayer());
-    return contentsRect;
-}
-
-static LayoutRect backgroundRectForBox(const RenderBox* box)
-{
-    EFillBox clip = box->style()->backgroundClip();
-    switch (clip) {
-    case BorderFillBox:
-        return box->borderBoxRect();
-    case PaddingFillBox:
-        return box->paddingBoxRect();
-    case ContentFillBox:
-        return box->contentBoxRect();
-    case TextFillBox:
-        break;
-    }
-
-    ASSERT_NOT_REACHED();
-    return LayoutRect();
+    IntRect contentsBox = contentsRect(renderer());
+    contentsBox.move(contentOffsetInCompostingLayer());
+    return contentsBox;
 }
 
 IntRect RenderLayerBacking::backgroundBox() const
 {
-    if (!renderer()->isBox())
-        return IntRect();
-
-    IntRect pixelSnappedBackgroundBox = pixelSnappedIntRect(backgroundRectForBox(toRenderBox(renderer())));
-    pixelSnappedBackgroundBox.move(contentOffsetInCompostingLayer());
-    return pixelSnappedBackgroundBox;
+    IntRect backgroundBox = backgroundRect(renderer());
+    backgroundBox.move(contentOffsetInCompostingLayer());
+    return backgroundBox;
 }
 
 GraphicsLayer* RenderLayerBacking::parentForSublayers() const
 {
     if (m_scrollingContentsLayer)
         return m_scrollingContentsLayer.get();
 
     return m_childContainmentLayer ? m_childContainmentLayer.get() : m_graphicsLayer.get();
 }
 
@@ skipping 433 matching lines @@
     if (m_layerForVerticalScrollbar)
         backingMemory += m_layerForVerticalScrollbar->backingStoreMemoryEstimate();
 
     if (m_layerForScrollCorner)
         backingMemory += m_layerForScrollCorner->backingStoreMemoryEstimate();
     
     return backingMemory;
 }
 
 } // namespace WebCore