Move rendering/RenderObject to layout/LayoutObject.

Source/core/layout/compositing/CompositedLayerMapping.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 53 matching lines @@
 #include "platform/graphics/paint/TransformDisplayItem.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static IntRect clipBox(RenderBox* renderer);
 
-static IntRect contentsRect(const RenderObject* renderer)
+static IntRect contentsRect(const LayoutObject* renderer)
 {
     if (!renderer->isBox())
         return IntRect();
 
     return renderer->isVideo() ?
         toRenderVideo(renderer)->videoBox() :
         pixelSnappedIntRect(toRenderBox(renderer)->contentBoxRect());
 }
 
-static IntRect backgroundRect(const RenderObject* renderer)
+static IntRect backgroundRect(const LayoutObject* 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)
+static inline bool isAcceleratedCanvas(const LayoutObject* renderer)
 {
     if (renderer->isCanvas()) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             return context->isAccelerated();
     }
     return false;
 }
 
 static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle* style)
 {
     return style->hasBoxDecorations() || style->hasBackgroundImage();
 }
 
-static bool contentLayerSupportsDirectBackgroundComposition(const RenderObject* renderer)
+static bool contentLayerSupportsDirectBackgroundComposition(const LayoutObject* 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));
 }
 
-static WebLayer* platformLayerForPlugin(RenderObject* renderer)
+static WebLayer* platformLayerForPlugin(LayoutObject* renderer)
 {
     if (!renderer->isEmbeddedObject())
         return 0;
     Widget* widget = toRenderEmbeddedObject(renderer)->widget();
     if (!widget || !widget->isPluginView())
         return 0;
     return toPluginView(widget)->platformLayer();
 
 }
 
-static inline bool isAcceleratedContents(RenderObject* renderer)
+static inline bool isAcceleratedContents(LayoutObject* renderer)
 {
     return isAcceleratedCanvas(renderer)
         || (renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->requiresAcceleratedCompositing())
         || renderer->isVideo();
 }
 
 // Get the scrolling coordinator in a way that works inside CompositedLayerMapping's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(Layer& layer)
 {
     Page* page = layer.renderer()->frame()->page();
@@ skipping 198 matching lines @@
 
 bool CompositedLayerMapping::owningLayerClippedByLayerNotAboveCompositedAncestor()
 {
     if (!m_owningLayer.parent())
         return false;
 
     const Layer* compositingAncestor = m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
     if (!compositingAncestor)
         return false;
 
-    const RenderObject* clippingContainer = m_owningLayer.clippingContainer();
+    const LayoutObject* clippingContainer = m_owningLayer.clippingContainer();
     if (!clippingContainer)
         return false;
 
     if (compositingAncestor->renderer()->isDescendantOf(clippingContainer))
         return false;
 
     // We ignore overflow clip here; we want composited overflow content to
     // behave as if it lives in an unclipped universe so it can prepaint, etc.
     // This means that we need to check if we are actually clipped before
     // setting up m_ancestorClippingLayer otherwise
@@ skipping 14 matching lines @@
     // Note carefully: here we assume that the compositing state of all descendants have been updated already,
     // so it is legitimate to compute and cache the composited bounds for this layer.
     updateCompositedBounds();
 
     if (LayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
         if (reflection->reflectionLayer()->hasCompositedLayerMapping())
             reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds();
     }
 
     LayerCompositor* compositor = this->compositor();
-    RenderObject* renderer = this->renderer();
+    LayoutObject* renderer = this->renderer();
 
     bool layerConfigChanged = false;
     setBackgroundLayerPaintsFixedRootBackground(compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
     // The background layer is currently only used for fixed root backgrounds.
     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
         layerConfigChanged = true;
 
     if (updateForegroundLayer(compositor->needsContentsCompositingLayer(&m_owningLayer)))
         layerConfigChanged = true;
@@ skipping 1306 matching lines @@
             break;
 
         finalOpacity *= curr->renderer()->opacity();
     }
 
     return finalOpacity;
 }
 
 Color CompositedLayerMapping::rendererBackgroundColor() const
 {
-    RenderObject* backgroundRenderer = renderer();
+    LayoutObject* backgroundRenderer = renderer();
     if (backgroundRenderer->isDocumentElement())
         backgroundRenderer = backgroundRenderer->rendererForRootBackground();
 
     return backgroundRenderer->resolveColor(CSSPropertyBackgroundColor);
 }
 
 void CompositedLayerMapping::updateBackgroundColor()
 {
     m_graphicsLayer->setBackgroundColor(rendererBackgroundColor());
 }
 
 bool CompositedLayerMapping::paintsChildren() const
 {
     if (m_owningLayer.hasVisibleContent() && m_owningLayer.hasNonEmptyChildRenderers())
         return true;
 
     if (hasVisibleNonCompositingDescendant(&m_owningLayer))
         return true;
 
     return false;
 }
 
-static bool isCompositedPlugin(RenderObject* renderer)
+static bool isCompositedPlugin(LayoutObject* renderer)
 {
     return renderer->isEmbeddedObject() && toRenderEmbeddedObject(renderer)->requiresAcceleratedCompositing();
 }
 
 bool CompositedLayerMapping::hasVisibleNonCompositingDescendant(Layer* parent)
 {
     if (!parent->hasVisibleDescendant())
         return false;
 
     // FIXME: We shouldn't be called with a stale z-order lists. See bug 85512.
@@ skipping 16 matching lines @@
 }
 
 bool CompositedLayerMapping::containsPaintedContent() const
 {
     if (m_owningLayer.isReflection())
         return false;
 
     if (renderer()->isImage() && isDirectlyCompositedImage())
         return false;
 
-    RenderObject* renderObject = renderer();
+    LayoutObject* layoutObject = renderer();
     // 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 (renderObject->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
+    if (layoutObject->isVideo() && toRenderVideo(renderer())->shouldDisplayVideo())
         return m_owningLayer.hasBoxDecorationsOrBackground();
 
     if (m_owningLayer.hasVisibleBoxDecorations())
         return true;
 
-    if (renderObject->hasMask()) // masks require special treatment
+    if (layoutObject->hasMask()) // masks require special treatment
         return true;
 
-    if (renderObject->isReplaced() && !isCompositedPlugin(renderObject))
+    if (layoutObject->isReplaced() && !isCompositedPlugin(layoutObject))
         return true;
 
-    if (renderObject->isRenderRegion())
+    if (layoutObject->isRenderRegion())
         return true;
 
-    if (renderObject->node() && renderObject->node()->isDocumentNode()) {
+    if (layoutObject->node() && layoutObject->node()->isDocumentNode()) {
         // Look to see if the root object has a non-simple background
-        RenderObject* rootObject = renderObject->document().documentElement() ? renderObject->document().documentElement()->renderer() : 0;
+        LayoutObject* rootObject = layoutObject->document().documentElement() ? layoutObject->document().documentElement()->renderer() : 0;
         // Reject anything that has a border, a border-radius or outline,
         // or is not a simple background (no background, or solid color).
         if (rootObject && hasBoxDecorationsOrBackgroundImage(rootObject->style()))
             return true;
 
         // Now look at the body's renderer.
-        HTMLElement* body = renderObject->document().body();
-        RenderObject* bodyObject = isHTMLBodyElement(body) ? body->renderer() : 0;
+        HTMLElement* body = layoutObject->document().body();
+        LayoutObject* bodyObject = isHTMLBodyElement(body) ? body->renderer() : 0;
         if (bodyObject && hasBoxDecorationsOrBackgroundImage(bodyObject->style()))
             return true;
     }
 
     // FIXME: it's O(n^2). A better solution is needed.
     return paintsChildren();
 }
 
 // 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 CompositedLayerMapping::isDirectlyCompositedImage() const
 {
     ASSERT(renderer()->isImage());
 
-    RenderObject* renderObject = renderer();
-    if (m_owningLayer.hasBoxDecorationsOrBackground() || renderObject->hasClip() || renderObject->hasClipPath())
+    LayoutObject* layoutObject = renderer();
+    if (m_owningLayer.hasBoxDecorationsOrBackground() || layoutObject->hasClip() || layoutObject->hasClipPath())
         return false;
 
-    RenderImage* imageRenderer = toRenderImage(renderObject);
+    RenderImage* imageRenderer = toRenderImage(layoutObject);
     if (ImageResource* cachedImage = imageRenderer->cachedImage()) {
         if (!cachedImage->hasImage())
             return false;
 
         Image* image = cachedImage->imageForRenderer(imageRenderer);
         return image->isBitmapImage();
     }
 
     return false;
 }
@@ skipping 176 matching lines @@
 void CompositedLayerMapping::setContentsNeedDisplayInRect(const LayoutRect& r, PaintInvalidationReason invalidationReason)
 {
     // FIXME: need to split out paint invalidations for the background.
     SetContentsNeedsDisplayInRectFunctor functor = {
         pixelSnappedIntRect(r.location() + m_owningLayer.subpixelAccumulation(), r.size()),
         invalidationReason
     };
     ApplyToGraphicsLayers(this, functor, ApplyToContentLayers);
 }
 
-const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const RenderObject* renderObject, const Vector<GraphicsLayerPaintInfo>& layers, unsigned maxSquashedLayerIndex)
+const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const LayoutObject* layoutObject, const Vector<GraphicsLayerPaintInfo>& layers, unsigned maxSquashedLayerIndex)
 {
     for (size_t i = 0; i < layers.size() && i < maxSquashedLayerIndex; ++i) {
-        if (renderObject->isDescendantOf(layers[i].renderLayer->renderer()))
+        if (layoutObject->isDescendantOf(layers[i].renderLayer->renderer()))
             return &layers[i];
     }
     return 0;
 }
 
-const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const RenderObject* renderObject, unsigned maxSquashedLayerIndex)
+const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(const LayoutObject* layoutObject, unsigned maxSquashedLayerIndex)
 {
-    return CompositedLayerMapping::containingSquashedLayer(renderObject, m_squashedLayers, maxSquashedLayerIndex);
+    return CompositedLayerMapping::containingSquashedLayer(layoutObject, m_squashedLayers, maxSquashedLayerIndex);
 }
 
 IntRect CompositedLayerMapping::localClipRectForSquashedLayer(const Layer& referenceLayer, const GraphicsLayerPaintInfo& paintInfo, const Vector<GraphicsLayerPaintInfo>& layers)
 {
-    const RenderObject* clippingContainer = paintInfo.renderLayer->clippingContainer();
+    const LayoutObject* clippingContainer = paintInfo.renderLayer->clippingContainer();
     if (clippingContainer == referenceLayer.clippingContainer())
         return LayoutRect::infiniteIntRect();
 
     ASSERT(clippingContainer);
 
     const GraphicsLayerPaintInfo* ancestorPaintInfo = containingSquashedLayer(clippingContainer, layers, layers.size());
     // Must be there, otherwise CompositingLayerAssigner::canSquashIntoCurrentSquashingOwner would have disallowed squashing.
     ASSERT(ancestorPaintInfo);
 
     // FIXME: this is a potential performance issue. We should consider caching these clip rects or otherwise optimizing.
@@ skipping 274 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink