Merge 88496 - 2011-06-09 James Robinson <jamesr@chromium.org>

Source/WebCore/platform/graphics/chromium/LayerRendererChromium.cpp

 /*
  * Copyright (C) 2010 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 640 matching lines @@
     layerLocalTransform.multiply(layer->transform());
     // LT = Tr[l] * M[l] * Tr[c]
     layerLocalTransform.translate3d(centerOffsetX, centerOffsetY, -layer->anchorPointZ());
 
     TransformationMatrix combinedTransform = parentMatrix;
     combinedTransform = combinedTransform.multiply(layerLocalTransform);
 
     FloatRect layerRect(-0.5 * layer->bounds().width(), -0.5 * layer->bounds().height(), layer->bounds().width(), layer->bounds().height());
     IntRect transformedLayerRect;
 
+    // FIXME: This seems like the wrong place to set this
+    layer->setUsesLayerScissor(false);
+
     // The layer and its descendants render on a new RenderSurface if any of
     // these conditions hold:
     // 1. The layer clips its descendants and its transform is not a simple translation.
     // 2. If the layer has opacity != 1 and does not have a preserves-3d transform style.
     // 3. The layer uses a mask
     // 4. The layer has a replica (used for reflections)
     // 5. The layer doesn't preserve-3d but is the child of a layer which does.
     // If a layer preserves-3d then we don't create a RenderSurface for it to avoid flattening
     // out its children. The opacity value of the children layers is multiplied by the opacity
     // of their parent.
@@ skipping 16 matching lines @@
 
         // Layer's opacity will be applied when drawing the render surface.
         renderSurface->m_drawOpacity = layer->opacity();
         if (layer->parent() && layer->parent()->preserves3D())
             renderSurface->m_drawOpacity *= layer->parent()->drawOpacity();
         layer->setDrawOpacity(1);
 
         TransformationMatrix layerOriginTransform = combinedTransform;
         layerOriginTransform.translate3d(-0.5 * bounds.width(), -0.5 * bounds.height(), 0);
         renderSurface->m_originTransform = layerOriginTransform;
-        layer->setScissorRect(IntRect());
 
         // The render surface scissor rect is the scissor rect that needs to
         // be applied before drawing the render surface onto its containing
         // surface and is therefore expressed in the parent's coordinate system.
         renderSurface->m_scissorRect = layer->parent() ? layer->parent()->scissorRect() : layer->scissorRect();
 
         renderSurface->m_layerList.clear();
 
         if (layer->maskLayer()) {
             renderSurface->m_maskLayer = layer->maskLayer();
@@ skipping 11 matching lines @@
         transformedLayerRect = enclosingIntRect(layer->drawTransform().mapRect(layerRect));
 
         layer->setDrawOpacity(layer->opacity());
 
         if (layer->parent()) {
             if (layer->parent()->preserves3D())
                layer->setDrawOpacity(layer->drawOpacity() * layer->parent()->drawOpacity());
 
             // Layers inherit the scissor rect from their parent.
             layer->setScissorRect(layer->parent()->scissorRect());
+            if (layer->parent()->usesLayerScissor())
+                layer->setUsesLayerScissor(true);
 
             layer->setTargetRenderSurface(layer->parent()->targetRenderSurface());
         }
 
         if (layer != m_rootCCLayerImpl.get())
             layer->clearRenderSurface();
 
         if (layer->masksToBounds()) {
             IntRect scissor = transformedLayerRect;
             if (!layer->scissorRect().isEmpty())
                 scissor.intersect(layer->scissorRect());
             layer->setScissorRect(scissor);
+            layer->setUsesLayerScissor(true);
         }
     }
 
     if (layer->renderSurface())
         layer->setTargetRenderSurface(layer->renderSurface());
     else {
         ASSERT(layer->parent());
         layer->setTargetRenderSurface(layer->parent()->targetRenderSurface());
     }
 
@@ skipping 215 matching lines @@
     }
 
     if (!layer->drawsContent())
         return;
 
     if (layer->bounds().isEmpty()) {
         layer->unreserveContentsTexture();
         return;
     }
 
-    setScissorToRect(layer->scissorRect());
-
+    if (layer->usesLayerScissor())
+        setScissorToRect(layer->scissorRect());
+    else
+        GLC(m_context.get(), m_context->disable(GraphicsContext3D::SCISSOR_TEST));
     IntRect targetSurfaceRect = m_currentRenderSurface ? m_currentRenderSurface->contentRect() : m_defaultRenderSurface->contentRect();
-    IntRect scissorRect = layer->scissorRect();
-    if (!scissorRect.isEmpty())
-        targetSurfaceRect.intersect(scissorRect);
 
     // Check if the layer falls within the visible bounds of the page.
     IntRect layerRect = layer->getDrawRect();
     bool isLayerVisible = targetSurfaceRect.intersects(layerRect);
     if (!isLayerVisible) {
         layer->unreserveContentsTexture();
         return;
     }
 
     // FIXME: Need to take into account the commulative render surface transforms all the way from
@@ skipping 15 matching lines @@
     }
 
     layer->draw(targetSurfaceRect);
 
     // Draw the debug border if there is one.
     layer->drawDebugBorder();
 }
 
 // Sets the scissor region to the given rectangle. The coordinate system for the
 // scissorRect has its origin at the top left corner of the current visible rect.
-void LayerRendererChromium::setScissorToRect(const IntRect& requestedScissor)
+void LayerRendererChromium::setScissorToRect(const IntRect& scissorRect)
 {
     IntRect contentRect = (m_currentRenderSurface ? m_currentRenderSurface->m_contentRect : m_defaultRenderSurface->m_contentRect);
 
-    const IntRect scissorRect = requestedScissor.isEmpty() ? contentRect : requestedScissor;
+    GLC(m_context.get(), m_context->enable(GraphicsContext3D::SCISSOR_TEST));
 
     // The scissor coordinates must be supplied in viewport space so we need to offset
     // by the relative position of the top left corner of the current render surface.
     int scissorX = scissorRect.x() - contentRect.x();
     // When rendering to the default render surface we're rendering upside down so the top
     // of the GL scissor is the bottom of our layer.
     // But, if rendering to offscreen texture, we reverse our sense of 'upside down'.
     int scissorY;
     if (m_currentRenderSurface == m_defaultRenderSurface && !m_compositeOffscreen)
         scissorY = m_currentRenderSurface->m_contentRect.height() - (scissorRect.maxY() - m_currentRenderSurface->m_contentRect.y());
@@ skipping 154 matching lines @@
     if (layer->ccLayerImpl()->renderSurface())
         layer->ccLayerImpl()->renderSurface()->dumpSurface(ts, indent);
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         dumpRenderSurfaces(ts, indent, layer->children()[i].get());
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)