IntersectionObserver: second cut.

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 41 matching lines @@
 #include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
 #include "core/dom/DatasetDOMStringMap.h"
 #include "core/dom/ElementDataCache.h"
 #include "core/dom/ElementRareData.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/Fullscreen.h"
+#include "core/dom/IntersectionObserver.h"
 #include "core/dom/LayoutTreeBuilder.h"
 #include "core/dom/MutationObserverInterestGroup.h"
 #include "core/dom/MutationRecord.h"
 #include "core/dom/NamedNodeMap.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/PresentationAttributeStyle.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/ScriptableDocumentParser.h"
 #include "core/dom/SelectorQuery.h"
 #include "core/dom/StyleChangeReason.h"
@@ skipping 26 matching lines @@
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLFormControlsCollection.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLOptionsCollection.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLTableRowsCollection.h"
 #include "core/html/HTMLTemplateElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/inspector/InspectorInstrumentation.h"
+#include "core/layout/LayoutInline.h"
+#include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutTextFragment.h"
 #include "core/layout/LayoutView.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/PointerLockController.h"
 #include "core/page/SpatialNavigation.h"
 #include "core/page/scrolling/ScrollCustomizationCallbacks.h"
 #include "core/page/scrolling/ScrollState.h"
@@ skipping 45 matching lines @@
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
 {
 }
 
 Element::~Element()
 {
     ASSERT(needsAttach());
 
+    disconnectIntersectionObservations();

[dcheng, 2015/11/20 22:50:52]

This needs to be inside the #if !ENABLE(OILPAN) block. Destructors of
heap-allocated objects cannot touch heap-allocated objects (since the other
heap-allocated objects may have already been destroyed).

[szager1, 2015/12/01 06:53:31]

Removed this line, so now there is a possibility of a memory leak.  It seems
like something is missing in oilpan if I can't do necessary cleanup in the
destructor.

+
 #if !ENABLE(OILPAN)
     if (hasRareData()) {
         elementRareData()->clearShadow();
         detachAllAttrNodesFromElement();
     }
 
     if (isCustomElement())
         CustomElement::wasDestroyed(this);
 
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
@@ skipping 1259 matching lines @@
     ContainerNode::insertedInto(insertionPoint);
 
     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
     ASSERT(!hasRareData() || !elementRareData()->hasPseudoElements());
 
     if (!insertionPoint->isInTreeScope())
         return InsertionDone;
 
-    if (hasRareData())
-        elementRareData()->clearClassListValueForQuirksMode();
+    if (hasRareData()) {
+        ElementRareData* rareData = elementRareData();
+        rareData->clearClassListValueForQuirksMode();
+        if (rareData->hasIntersectionObservation()) {
+            for (auto& observation: rareData->intersectionObservations())
+                observation->setActive(observation->observer()->isDescendantOfRoot(this));
+        }
+    }
 
     if (isUpgradedCustomElement() && inDocument())
         CustomElement::didAttach(this, document());
 
     TreeScope& scope = insertionPoint->treeScope();
     if (scope != treeScope())
         return InsertionDone;
 
     const AtomicString& idValue = getIdAttribute();
     if (!idValue.isNull())
@@ skipping 57 matching lines @@
 
     clearElementFlag(IsInCanvasSubtree);
 
     if (hasRareData()) {
         ElementRareData* data = elementRareData();
 
         data->clearRestyleFlags();
 
         if (ElementAnimations* elementAnimations = data->elementAnimations())
             elementAnimations->cssAnimations().cancel();
+
+        data->deactivateAllIntersectionObservations();
     }
 }
 
 void Element::attach(const AttachContext& context)
 {
     ASSERT(document().inStyleRecalc());
 
     // We've already been through detach when doing an attach, but we might
     // need to clear any state that's been added since then.
     if (hasRareData() && styleChangeType() == NeedsReattachStyleChange) {
@@ skipping 2021 matching lines @@
         return false;
     if (isHTMLElement() && toHTMLElement(this)->hasDirectionAuto())
         return false;
     if (hasAnimations())
         return false;
     if (Fullscreen::isActiveFullScreenElement(*this))
         return false;
     return true;
 }
 
+WeakPtr<Element> Element::createWeakPtr()
+{
+    return ensureElementRareData().createWeakPtr(this);
+}
+
+void Element::addIntersectionObservation(IntersectionObservation& observation)
+{
+    ensureElementRareData().intersectionObservations().add(&observation);
+}
+
+void Element::removeIntersectionObservation(IntersectionObservation& observation)
+{
+    if (!hasRareData() || !elementRareData()->hasIntersectionObservation())
+        return;
+    elementRareData()->intersectionObservations().remove(&observation);
+}
+
+void Element::disconnectIntersectionObservations()
+{
+    if (!hasRareData() || !elementRareData()->hasIntersectionObservation())
+        return;
+    HeapVector<Member<IntersectionObservation>> toRemove;
+    for (auto& observation: elementRareData()->intersectionObservations())
+        toRemove.append(observation);
+    for (auto& observation: toRemove) {
+        if (observation->observer()->root() == this)
+            observation->observer()->disconnect();
+        else
+            observation->disconnect();
+    }
+}
+
+bool Element::computeIntersection(Element* root, LayoutRect& targetRect, LayoutRect& rootRect, LayoutRect& intersectionRect)
+{
+    // TODO: support zero-size targetRect
+    intersectionRect = targetRect = toLayoutBoxModelObject(layoutObject())->visualOverflowRect();
+
+    if (root) {
+        ASSERT(root->isInTreeScope());
+        ASSERT(isDescendantOf(root));
+        // TODO: Support SVG
+        if (!root->layoutObject()->isBoxModelObject())
+            return false;
+        rootRect = toLayoutBoxModelObject(root->layoutObject())->visualOverflowRect();
+        layoutObject()->mapRectToPaintInvalidationBacking(toLayoutBoxModelObject(root->layoutObject()), intersectionRect, nullptr);
+
+        // Convert rects to frame coordinates.
+        targetRect.moveBy(LayoutPoint(layoutObject()->localToAbsolute()));
+        LayoutPoint rootOffset = LayoutPoint(root->layoutObject()->localToAbsolute());
+        intersectionRect.moveBy(rootOffset);
+        rootRect.moveBy(rootOffset);
+    } else {
+        Element* target = this;
+        LocalFrame* frame = document().frame();
+        while (target) {
+            targetRect.moveBy(LayoutPoint(target->layoutObject()->localToAbsolute()));
+            Document& document = target->document();
+            LayoutView* layoutView = document.layoutView();
+            ASSERT(layoutView);
+            // TODO: mapRectToPaintInvalidationBacking probably doesn't do exactly the clipping we want,
+            // and it doesn't support rootMargin at all.
+            target->layoutObject()->mapRectToPaintInvalidationBacking(layoutView, intersectionRect, nullptr);
+            frame = document.frame();
+            ASSERT(frame);
+            target = toElement(frame->ownerLayoutObject()->node());
+        }
+        rootRect = LayoutRect(frame->view()->scrollableArea()->visibleContentRect());
+        intersectionRect = intersection(intersectionRect, rootRect);
+    }
+
+    return true;
+}
+
 DEFINE_TRACE(Element)
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink