Divorce PaintInvalidationState from LayoutState

Source/core/rendering/InvalidationTreeWalkState.cpp

+/*
+ * Copyright (C) 2014 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
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "core/rendering/InvalidationTreeWalkState.h"
+
+#include "core/rendering/RenderInline.h"
+#include "core/rendering/RenderLayer.h"
+#include "core/rendering/RenderView.h"
+#include "core/rendering/svg/RenderSVGModelObject.h"
+#include "platform/Partitions.h"
+
+namespace WebCore {
+
+InvalidationTreeWalkState::InvalidationTreeWalkState(RenderObject& renderer)
+    : m_clipped(false)
+    , m_cachedOffsetsEnabled(true)
+    , m_paintInvalidationContainer(*renderer.containerForPaintInvalidation())
+    , m_renderer(renderer)
+{
+    bool establishesPaintInvalidationContainer = &m_renderer == &m_paintInvalidationContainer;
+    if (!establishesPaintInvalidationContainer) {
+        if (!renderer.supportsLayoutStateCachedOffsets()) {
+            m_cachedOffsetsEnabled = false;
+            return;
+        }
+        bool invalidationContainerSkipped;
+        RenderObject* container = renderer.container(&m_paintInvalidationContainer, &invalidationContainerSkipped);
+        if (container && !invalidationContainerSkipped) {
+            // m_diabled = true;

[dsinclair, 2014/07/02 18:48:24]

remove

+            FloatPoint point = container->localToContainerPoint(FloatPoint(), &m_paintInvalidationContainer);
+            if (container->isTableRow())
+                point = FloatPoint(point.x() - toRenderBox(container)->x().toFloat(), point.y() - toRenderBox(container)->y().toFloat());
+            m_paintOffset = LayoutSize(point.x(), point.y());
+
+            applyClipIfNeeded(*container);
+        }
+    } else {
+        applyClipIfNeeded(m_renderer);
+    }
+}
+
+InvalidationTreeWalkState::InvalidationTreeWalkState(const InvalidationTreeWalkState& next, RenderSVGModelObject& renderer, const RenderLayerModelObject& paintInvalidationContainer)
+    : m_clipped(next.m_clipped)
+    , m_cachedOffsetsEnabled(next.m_cachedOffsetsEnabled)
+    , m_paintInvalidationContainer(paintInvalidationContainer)
+    , m_renderer(renderer)
+{
+    // FIXME: SVG could probably benefit from a stack-based optimization like html does.

[dsinclair, 2014/07/02 18:48:24]

bug?

+    ASSERT(!m_cachedOffsetsEnabled);
+}
+
+InvalidationTreeWalkState::InvalidationTreeWalkState(const InvalidationTreeWalkState& next, RenderInline& renderer, const RenderLayerModelObject& paintInvalidationContainer)
+    : m_clipped(next.m_clipped)
+    , m_cachedOffsetsEnabled(true)
+    , m_paintInvalidationContainer(paintInvalidationContainer)
+    , m_renderer(renderer)
+{
+    bool establishesPaintInvalidationContainer = &m_renderer == &m_paintInvalidationContainer;
+    if (!establishesPaintInvalidationContainer) {
+        if (!renderer.supportsLayoutStateCachedOffsets() || !next.m_cachedOffsetsEnabled) {
+            m_cachedOffsetsEnabled = false;
+        } else if (m_cachedOffsetsEnabled) {
+            m_paintOffset = next.m_paintOffset;
+            // Handle relative positioned inline.
+            if (renderer.style()->hasInFlowPosition() && renderer.layer())
+                m_paintOffset += renderer.layer()->offsetForInFlowPosition();
+
+            // RenderInline can't be out-of-flow positioned.
+        }
+    }
+
+    // The following can't apply to RenderInline so we just propagate them.
+    m_clipped = next.m_clipped;
+    m_clipRect = next.m_clipRect;
+}
+
+InvalidationTreeWalkState::InvalidationTreeWalkState(const InvalidationTreeWalkState& next, RenderBox& renderer, const RenderLayerModelObject& paintInvalidationContainer)
+    : m_clipped(false)
+    , m_cachedOffsetsEnabled(true)
+    , m_paintInvalidationContainer(paintInvalidationContainer)
+    , m_renderer(renderer)
+{
+    ASSERT(&m_paintInvalidationContainer == renderer.containerForPaintInvalidation() || !next.m_cachedOffsetsEnabled);
+    bool establishesPaintInvalidationContainer = &m_renderer == &m_paintInvalidationContainer;
+    bool fixed = m_renderer.isOutOfFlowPositioned() && m_renderer.style()->position() == FixedPosition;
+
+    if (!establishesPaintInvalidationContainer) {
+        if (!renderer.supportsLayoutStateCachedOffsets() || !next.m_cachedOffsetsEnabled) {
+            m_cachedOffsetsEnabled = false;
+        } else {
+            LayoutSize offset = m_renderer.isTableRow() ? LayoutSize() : renderer.locationOffset();
+            if (fixed) {
+                // FIXME: This doesn't work correctly with transforms.
+                FloatPoint fixedOffset = m_renderer.view()->localToAbsolute(FloatPoint(), IsFixed);
+                m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y()) + offset;
+            } else {
+                m_paintOffset = next.m_paintOffset + offset;
+            }
+
+            if (m_renderer.isOutOfFlowPositioned() && !fixed) {
+                if (RenderObject* container = m_renderer.container()) {
+                    if (container->style()->hasInFlowPosition() && container->isRenderInline())
+                        m_paintOffset += toRenderInline(container)->offsetForInFlowPositionedInline(renderer);
+                }
+            }
+
+            if (m_renderer.style()->hasInFlowPosition() && renderer.hasLayer())
+                m_paintOffset += renderer.layer()->offsetForInFlowPosition();
+        }
+    }
+
+    m_clipped = !fixed && next.m_clipped;
+    if (m_clipped)
+        m_clipRect = next.m_clipRect;
+
+    applyClipIfNeeded(renderer);
+
+    // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
+}
+
+void InvalidationTreeWalkState::applyClipIfNeeded(const RenderObject& renderer)
+{
+    if (renderer.hasOverflowClip()) {

[dsinclair, 2014/07/02 18:48:24]

if (!renderer.hasOverflowClip())
    return;

+        const RenderBox* box = toRenderBox(&renderer);
+        LayoutRect clipRect(toPoint(m_paintOffset), box->cachedSizeForOverflowClip());
+        if (m_clipped) {
+            m_clipRect.intersect(clipRect);
+        } else {
+            m_clipRect = clipRect;
+            m_clipped = true;
+        }
+        m_paintOffset -= box->scrolledContentOffset();
+    }
+}
+
+} // namespace WebCore