Revert of Divorce PaintInvalidationState from LayoutState (https://codereview.chromium.org/36083300…

Source/core/rendering/LayoutState.cpp

 /*
  * Copyright (C) 2007 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 16 matching lines @@
 #include "core/rendering/LayoutState.h"
 
 #include "core/rendering/RenderInline.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 #include "platform/Partitions.h"
 
 namespace WebCore {
 
 LayoutState::LayoutState(LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged, RenderView& view)
-    : m_isPaginated(pageLogicalHeight)
+    : m_clipped(false)
+    , m_isPaginated(pageLogicalHeight)
     , m_pageLogicalHeightChanged(pageLogicalHeightChanged)
+    , m_cachedOffsetsEnabled(true)
     , m_columnInfo(0)
     , m_next(0)
     , m_pageLogicalHeight(pageLogicalHeight)
     , m_renderer(view)
 {
     ASSERT(!view.layoutState());
     view.pushLayoutState(*this);
 }
 
 LayoutState::LayoutState(RenderBox& renderer, const LayoutSize& offset, LayoutUnit pageLogicalHeight, bool pageLogicalHeightChanged, ColumnInfo* columnInfo)
     : m_columnInfo(columnInfo)
     , m_next(renderer.view()->layoutState())
     , m_renderer(renderer)
 {
     renderer.view()->pushLayoutState(*this);
+    m_cachedOffsetsEnabled = m_next->m_cachedOffsetsEnabled && renderer.supportsLayoutStateCachedOffsets();
     bool fixed = renderer.isOutOfFlowPositioned() && renderer.style()->position() == FixedPosition;
     if (fixed) {
         // FIXME: This doesn't work correctly with transforms.
         FloatPoint fixedOffset = renderer.view()->localToAbsolute(FloatPoint(), IsFixed);
-        m_layoutOffset = LayoutSize(fixedOffset.x(), fixedOffset.y()) + offset;
+        m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y()) + offset;
     } else {
-        m_layoutOffset = m_next->m_layoutOffset + offset;
+        m_paintOffset = m_next->m_paintOffset + offset;
     }
 
     if (renderer.isOutOfFlowPositioned() && !fixed) {
         if (RenderObject* container = renderer.container()) {
-            if (container->style()->hasInFlowPosition() && container->isRenderInline())
-                m_layoutOffset += toRenderInline(container)->offsetForInFlowPositionedInline(renderer);
+            if (container->isRelPositioned() && container->isRenderInline())
+                m_paintOffset += toRenderInline(container)->offsetForInFlowPositionedInline(renderer);
         }
     }
+
+    m_layoutOffset = m_paintOffset;
+
+    if (renderer.isRelPositioned() && renderer.hasLayer())
+        m_paintOffset += renderer.layer()->offsetForInFlowPosition();
+
+    m_clipped = !fixed && m_next->m_clipped;
+    if (m_clipped)
+        m_clipRect = m_next->m_clipRect;
+
+    if (renderer.hasOverflowClip()) {
+        LayoutRect clipRect(toPoint(m_paintOffset), renderer.cachedSizeForOverflowClip());
+        if (m_clipped)
+            m_clipRect.intersect(clipRect);
+        else {
+            m_clipRect = clipRect;
+            m_clipped = true;
+        }
+
+        m_paintOffset -= renderer.scrolledContentOffset();
+    }
+
     // If we establish a new page height, then cache the offset to the top of the first page.
     // We can compare this later on to figure out what part of the page we're actually on,
     if (pageLogicalHeight || m_columnInfo || renderer.isRenderFlowThread()) {
         m_pageLogicalHeight = pageLogicalHeight;
         bool isFlipped = renderer.style()->isFlippedBlocksWritingMode();
         m_pageOffset = LayoutSize(m_layoutOffset.width() + (!isFlipped ? renderer.borderLeft() + renderer.paddingLeft() : renderer.borderRight() + renderer.paddingRight()),
             m_layoutOffset.height() + (!isFlipped ? renderer.borderTop() + renderer.paddingTop() : renderer.borderBottom() + renderer.paddingBottom()));
         m_pageLogicalHeightChanged = pageLogicalHeightChanged;
         m_isPaginated = true;
     } else {
@@ skipping 11 matching lines @@
             m_isPaginated = m_pageLogicalHeight || m_next->m_columnInfo || renderer.flowThreadContainingBlock();
         }
     }
 
     if (!m_columnInfo)
         m_columnInfo = m_next->m_columnInfo;
 
     // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
 }
 
+LayoutState::LayoutState(RenderInline& renderer)
+    : m_next(renderer.view()->layoutState())
+    , m_renderer(renderer)
+{
+    ASSERT(m_next);
+
+    renderer.view()->pushLayoutState(*this);
+    m_cachedOffsetsEnabled = m_next->m_cachedOffsetsEnabled && renderer.supportsLayoutStateCachedOffsets();
+
+    m_paintOffset = m_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 = m_next->m_clipped;
+    m_clipRect = m_next->m_clipRect;
+
+    m_pageLogicalHeight = m_next->m_pageLogicalHeight;
+    m_pageLogicalHeightChanged = m_next->m_pageLogicalHeightChanged;
+    m_pageOffset = m_next->m_pageOffset;
+
+    m_columnInfo = m_next->m_columnInfo;
+}
+
+inline static bool shouldDisableLayoutStateForSubtree(RenderObject& renderer)
+{
+    RenderObject* object = &renderer;
+    while (object) {
+        if (object->supportsLayoutStateCachedOffsets())
+            return true;
+        object = object->container();
+    }
+    return false;
+}
+
 LayoutState::LayoutState(RenderObject& root)
-    : m_isPaginated(false)
+    : m_clipped(false)
+    , m_isPaginated(false)
     , m_pageLogicalHeightChanged(false)
+    , m_cachedOffsetsEnabled(shouldDisableLayoutStateForSubtree(root))
     , m_columnInfo(0)
     , m_next(root.view()->layoutState())
     , m_pageLogicalHeight(0)
     , m_renderer(root)
 {
     // FIXME: Why does RenderTableSection create this wonky LayoutState?
     ASSERT(!m_next || root.isTableSection());
     // We'll end up pushing in RenderView itself, so don't bother adding it.
     if (root.isRenderView())
         return;
 
     root.view()->pushLayoutState(*this);
 
     RenderObject* container = root.container();
     FloatPoint absContentPoint = container->localToAbsolute(FloatPoint(), UseTransforms);
-    m_layoutOffset = LayoutSize(absContentPoint.x(), absContentPoint.y());
+    m_paintOffset = LayoutSize(absContentPoint.x(), absContentPoint.y());
+
+    if (container->hasOverflowClip()) {
+        m_clipped = true;
+        RenderBox* containerBox = toRenderBox(container);
+        m_clipRect = LayoutRect(toPoint(m_paintOffset), containerBox->cachedSizeForOverflowClip());
+        m_paintOffset -= containerBox->scrolledContentOffset();
+    }
 }
 
 LayoutState::~LayoutState()
 {
     if (m_renderer.view()->layoutState()) {
         ASSERT(m_renderer.view()->layoutState() == this);
         m_renderer.view()->popLayoutState();
     }
 }
 
@@ skipping 12 matching lines @@
 }
 
 void LayoutState::addForcedColumnBreak(const RenderBox& child, const LayoutUnit& childLogicalOffset)
 {
     if (!m_columnInfo || m_columnInfo->columnHeight())
         return;
     m_columnInfo->addForcedBreak(pageLogicalOffset(child, childLogicalOffset));
 }
 
 } // namespace WebCore