Implement Style Containment

third_party/WebKit/Source/core/layout/LayoutCounter.cpp

 /**
  * Copyright (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 25 matching lines @@
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 using namespace HTMLNames;
 
 typedef HashMap<AtomicString, RefPtr<CounterNode>> CounterMap;
 typedef HashMap<const LayoutObject*, OwnPtr<CounterMap>> CounterMaps;
 
-static CounterNode* makeCounterNode(LayoutObject&, const AtomicString& identifier, bool alwaysCreateCounter);
+static CounterNode* makeCounterNodeIfNeeded(LayoutObject&, const AtomicString& identifier, bool alwaysCreateCounter);
 
 // See class definition as to why we have this map.
 static CounterMaps& counterMaps()
 {
     DEFINE_STATIC_LOCAL(CounterMaps, staticCounterMaps, ());
     return staticCounterMaps;
 }
 
+Element* ancestorStyleContainmentObject(const Element& element)
+{
+    for (Element* ancestor = FlatTreeTraversal::parentElement(element); ancestor; ancestor = FlatTreeTraversal::parentElement(*ancestor)) {
+        if (ancestor->layoutObject() && ancestor->layoutObject()->style()->containsStyle())
+            return ancestor;
+    }
+    return nullptr;
+}
+
 // This function processes the layoutObject tree in the order of the DOM tree
-// including pseudo elements as defined in CSS 2.1.
-static LayoutObject* previousInPreOrder(const LayoutObject& object)
+// including pseudo elements as defined in CSS 2.1. This method will always return
+// either a previous object within the same contain: style scope or nullptr.
+static LayoutObject* previousInPreOrderRespectingContainment(const LayoutObject& object)
 {
     Element* self = toElement(object.node());
     ASSERT(self);
     Element* previous = ElementTraversal::previousIncludingPseudo(*self);
-    while (previous && !previous->layoutObject())
-        previous = ElementTraversal::previousIncludingPseudo(*previous);
-    return previous ? previous->layoutObject() : 0;
+    Element* styleContainAncestor = ancestorStyleContainmentObject(*self);
+
+    while (1) {
+        while (previous && !previous->layoutObject())
+            previous = ElementTraversal::previousIncludingPseudo(*previous);
+        if (!previous)
+            return nullptr;
+        Element* previousStyleContainAncestor = ancestorStyleContainmentObject(*previous);
+        if (previousStyleContainAncestor == styleContainAncestor)
+            return previous->layoutObject();
+        if (!previousStyleContainAncestor)
+            return nullptr;
+        previous = previousStyleContainAncestor;
+    }
 }
 
 // This function processes the layoutObject tree in the order of the DOM tree
-// including pseudo elements as defined in CSS 2.1.
-static LayoutObject* previousSiblingOrParent(const LayoutObject& object)
+// including pseudo elements as defined in CSS 2.1. This method avoids crossing
+// contain: style boundaries.
+static LayoutObject* previousSiblingOrParentRespectingContainment(const LayoutObject& object)
 {
     Element* self = toElement(object.node());
     ASSERT(self);
     Element* previous = ElementTraversal::pseudoAwarePreviousSibling(*self);
     while (previous && !previous->layoutObject())
         previous = ElementTraversal::pseudoAwarePreviousSibling(*previous);
     if (previous)
         return previous->layoutObject();
     previous = self->parentElement();
-    return previous ? previous->layoutObject() : 0;
+    return previous && previous->layoutObject() && !(previous->layoutObject()->style()->contain() & ContainsStyle) ? previous->layoutObject() : nullptr;
 }
 
 static inline Element* parentElement(LayoutObject& object)
 {
     return toElement(object.node())->parentElement();
 }
 
 static inline bool areLayoutObjectsElementsSiblings(LayoutObject& first, LayoutObject& second)
 {
     return parentElement(first) == parentElement(second);
 }
 
 // This function processes the layoutObject tree in the order of the DOM tree
 // including pseudo elements as defined in CSS 2.1.
 static LayoutObject* nextInPreOrder(const LayoutObject& object, const Element* stayWithin, bool skipDescendants = false)
 {
     Element* self = toElement(object.node());
     ASSERT(self);
     Element* next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(*self, stayWithin) : ElementTraversal::nextIncludingPseudo(*self, stayWithin);
     while (next && !next->layoutObject())
         next = skipDescendants ? ElementTraversal::nextIncludingPseudoSkippingChildren(*next, stayWithin) : ElementTraversal::nextIncludingPseudo(*next, stayWithin);
-    return next ? next->layoutObject() : 0;
+    return next ? next->layoutObject() : nullptr;
 }
 
 static bool planCounter(LayoutObject& object, const AtomicString& identifier, bool& isReset, int& value)
 {
     // Real text nodes don't have their own style so they can't have counters.
     // We can't even look at their styles or we'll see extra resets and increments!
     if (object.isText() && !object.isBR())
         return false;
     Node* generatingNode = object.generatingNode();
     // We must have a generating node or else we cannot have a counter.
@@ skipping 63 matching lines @@
 // - The root of the tree is always a reset type reference.
 // - A subtree rooted at any reset node in the tree is equivalent to all counter
 // references that are in the scope of the counter or nested counter defined by that
 // reset node.
 // - Non-reset CounterNodes cannot have descendants.
 
 static bool findPlaceForCounter(LayoutObject& counterOwner, const AtomicString& identifier, bool isReset, RefPtr<CounterNode>& parent, RefPtr<CounterNode>& previousSibling)
 {
     // We cannot stop searching for counters with the same identifier before we also
     // check this layoutObject, because it may affect the positioning in the tree of our counter.
-    LayoutObject* searchEndLayoutObject = previousSiblingOrParent(counterOwner);
+    LayoutObject* searchEndLayoutObject = previousSiblingOrParentRespectingContainment(counterOwner);
     // We check layoutObjects in preOrder from the layoutObject that our counter is attached to
     // towards the beginning of the document for counters with the same identifier as the one
     // we are trying to find a place for. This is the next layoutObject to be checked.
-    LayoutObject* currentLayoutObject = previousInPreOrder(counterOwner);
+    LayoutObject* currentLayoutObject = previousInPreOrderRespectingContainment(counterOwner);
     previousSibling = nullptr;
     RefPtr<CounterNode> previousSiblingProtector = nullptr;
 
     while (currentLayoutObject) {
-        CounterNode* currentCounter = makeCounterNode(*currentLayoutObject, identifier, false);
+        CounterNode* currentCounter = makeCounterNodeIfNeeded(*currentLayoutObject, identifier, false);
         if (searchEndLayoutObject == currentLayoutObject) {
             // We may be at the end of our search.
             if (currentCounter) {
                 // We have a suitable counter on the EndSearchLayoutObject.
                 if (previousSiblingProtector) { // But we already found another counter that we come after.
                     if (currentCounter->actsAsReset()) {
                         // We found a reset counter that is on a layoutObject that is a sibling of ours or a parent.
                         if (isReset && areLayoutObjectsElementsSiblings(*currentLayoutObject, counterOwner)) {
                             // We are also a reset counter and the previous reset was on a sibling layoutObject
                             // hence we are the next sibling of that counter if that reset is not a root or
                             // we are a root node if that reset is a root.
                             parent = currentCounter->parent();
-                            previousSibling = parent ? currentCounter : 0;
+                            previousSibling = parent ? currentCounter : nullptr;
                             return parent;
                         }
                         // We are not a reset node or the previous reset must be on an ancestor of our owner layoutObject
                         // hence we must be a child of that reset counter.
                         parent = currentCounter;
                         // In some cases layoutObjects can be reparented (ex. nodes inside a table but not in a column or row).
                         // In these cases the identified previousSibling will be invalid as its parent is different from
                         // our identified parent.
                         if (previousSiblingProtector->parent() != currentCounter)
                             previousSiblingProtector = nullptr;
@@ skipping 32 matching lines @@
                         previousSibling = currentCounter;
                         return true;
                     }
                     previousSiblingProtector = currentCounter;
                 }
             }
             // We come here if the previous sibling or parent of our owner layoutObject had no
             // good counter, or we are a reset node and the counter on the previous sibling
             // of our owner layoutObject was not a reset counter.
             // Set a new goal for the end of the search.
-            searchEndLayoutObject = previousSiblingOrParent(*currentLayoutObject);
+            searchEndLayoutObject = previousSiblingOrParentRespectingContainment(*currentLayoutObject);
         } else {
             // We are searching descendants of a previous sibling of the layoutObject that the
             // counter being placed is attached to.
             if (currentCounter) {
                 // We found a suitable counter.
                 if (previousSiblingProtector) {
                     // Since we had a suitable previous counter before, we should only consider this one as our
                     // previousSibling if it is a reset counter and hence the current previousSibling is its child.
                     if (currentCounter->actsAsReset()) {
                         previousSiblingProtector = currentCounter;
                         // We are no longer interested in previous siblings of the currentLayoutObject or their children
                         // as counters they may have attached cannot be the previous sibling of the counter we are placing.
                         Element* parent = parentElement(*currentLayoutObject);
                         currentLayoutObject = parent ? parent->layoutObject() : nullptr;
                         continue;
                     }
                 } else {
                     previousSiblingProtector = currentCounter;
                 }
-                currentLayoutObject = previousSiblingOrParent(*currentLayoutObject);
+                currentLayoutObject = previousSiblingOrParentRespectingContainment(*currentLayoutObject);
                 continue;
             }
         }
         // This function is designed so that the same test is not done twice in an iteration, except for this one
         // which may be done twice in some cases. Rearranging the decision points though, to accommodate this
         // performance improvement would create more code duplication than is worthwhile in my opinion and may further
         // impede the readability of this already complex algorithm.
         if (previousSiblingProtector)
-            currentLayoutObject = previousSiblingOrParent(*currentLayoutObject);
+            currentLayoutObject = previousSiblingOrParentRespectingContainment(*currentLayoutObject);
         else
-            currentLayoutObject = previousInPreOrder(*currentLayoutObject);
+            currentLayoutObject = previousInPreOrderRespectingContainment(*currentLayoutObject);
     }
     return false;
 }
 
-static CounterNode* makeCounterNode(LayoutObject& object, const AtomicString& identifier, bool alwaysCreateCounter)
+static CounterNode* makeCounterNodeIfNeeded(LayoutObject& object, const AtomicString& identifier, bool alwaysCreateCounter)
 {
     if (object.hasCounterNodeMap()) {
         if (CounterMap* nodeMap = counterMaps().get(&object)) {
             if (CounterNode* node = nodeMap->get(identifier))
                 return node;
         }
     }
 
     bool isReset = false;
     int value = 0;
@@ skipping 69 matching lines @@
         while (true) {
             if (!beforeAfterContainer)
                 return nullptr;
             if (!beforeAfterContainer->isAnonymous() && !beforeAfterContainer->isPseudoElement())
                 return nullptr; // LayoutCounters are restricted to before and after pseudo elements
             PseudoId containerStyle = beforeAfterContainer->style()->styleType();
             if ((containerStyle == BEFORE) || (containerStyle == AFTER))
                 break;
             beforeAfterContainer = beforeAfterContainer->parent();
         }
-        makeCounterNode(*beforeAfterContainer, m_counter.identifier(), true)->addLayoutObject(const_cast<LayoutCounter*>(this));
+        makeCounterNodeIfNeeded(*beforeAfterContainer, m_counter.identifier(), true)->addLayoutObject(const_cast<LayoutCounter*>(this));
         ASSERT(m_counterNode);
     }
     CounterNode* child = m_counterNode;
     int value = child->actsAsReset() ? child->value() : child->countInParent();
 
     String text = ListMarkerText::text(m_counter.listStyle(), value);
 
     if (!m_counter.separator().isNull()) {
         if (!child->actsAsReset())
             child = child->parent();
@@ skipping 92 matching lines @@
 
 static void updateCounters(LayoutObject& layoutObject)
 {
     ASSERT(layoutObject.style());
     const CounterDirectiveMap* directiveMap = layoutObject.style()->counterDirectives();
     if (!directiveMap)
         return;
     CounterDirectiveMap::const_iterator end = directiveMap->end();
     if (!layoutObject.hasCounterNodeMap()) {
         for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it)
-            makeCounterNode(layoutObject, it->key, false);
+            makeCounterNodeIfNeeded(layoutObject, it->key, false);
         return;
     }
     CounterMap* counterMap = counterMaps().get(&layoutObject);
     ASSERT(counterMap);
     for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) {
         RefPtr<CounterNode> node = counterMap->get(it->key);
         if (!node) {
-            makeCounterNode(layoutObject, it->key, false);
+            makeCounterNodeIfNeeded(layoutObject, it->key, false);
             continue;
         }
         RefPtr<CounterNode> newParent = nullptr;
         RefPtr<CounterNode> newPreviousSibling = nullptr;
 
         findPlaceForCounter(layoutObject, it->key, node->hasResetType(), newParent, newPreviousSibling);
         if (node != counterMap->get(it->key))
             continue;
         CounterNode* parent = node->parent();
         if (newParent == parent && newPreviousSibling == node->previousSibling())
@@ skipping 35 matching lines @@
             for (CounterDirectiveMap::const_iterator it = newCounterDirectives->begin(); it != newMapEnd; ++it) {
                 CounterDirectiveMap::const_iterator oldMapIt = oldCounterDirectives->find(it->key);
                 if (oldMapIt != oldMapEnd) {
                     if (oldMapIt->value == it->value)
                         continue;
                     LayoutCounter::destroyCounterNode(layoutObject, it->key);
                 }
                 // We must create this node here, because the changed node may be a node with no display such as
                 // as those created by the increment or reset directives and the re-layout that will happen will
                 // not catch the change if the node had no children.
-                makeCounterNode(layoutObject, it->key, false);
+                makeCounterNodeIfNeeded(layoutObject, it->key, false);
             }
             // Destroying old counters that do not exist in the new counterDirective map.
             for (CounterDirectiveMap::const_iterator it = oldCounterDirectives->begin(); it !=oldMapEnd; ++it) {
                 if (!newCounterDirectives->contains(it->key))
                     LayoutCounter::destroyCounterNode(layoutObject, it->key);
             }
         } else {
             if (layoutObject.hasCounterNodeMap())
                 LayoutCounter::destroyCounterNodes(layoutObject);
         }
     } else if (newCounterDirectives) {
         if (layoutObject.hasCounterNodeMap())
             LayoutCounter::destroyCounterNodes(layoutObject);
         CounterDirectiveMap::const_iterator newMapEnd = newCounterDirectives->end();
         for (CounterDirectiveMap::const_iterator it = newCounterDirectives->begin(); it != newMapEnd; ++it) {
             // We must create this node here, because the added node may be a node with no display such as
             // as those created by the increment or reset directives and the re-layout that will happen will
             // not catch the change if the node had no children.
-            makeCounterNode(layoutObject, it->key, false);
+            makeCounterNodeIfNeeded(layoutObject, it->key, false);
         }
     }
 }
 
 } // namespace blink
 
 #ifndef NDEBUG
 
 void showCounterLayoutObjectTree(const blink::LayoutObject* layoutObject, const char* counterName)
 {
@@ skipping 10 matching lines @@
             fprintf(stderr, "    ");
         fprintf(stderr, "%p N:%p P:%p PS:%p NS:%p C:%p\n",
             current, current->node(), current->parent(), current->previousSibling(),
             current->nextSibling(), current->hasCounterNodeMap() ?
             counterName ? blink::counterMaps().get(current)->get(identifier) : (blink::CounterNode*)1 : (blink::CounterNode*)0);
     }
     fflush(stderr);
 }
 
 #endif // NDEBUG