IntersectionObserver: second cut.

third_party/WebKit/Source/core/dom/ElementRareData.h

 /*
  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith <catfish.man@gmail.com>
  *
  * 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,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef ElementRareData_h
 #define ElementRareData_h
 
 #include "core/animation/ElementAnimations.h"
 #include "core/dom/Attr.h"
 #include "core/dom/CompositorProxiedPropertySet.h"
 #include "core/dom/DatasetDOMStringMap.h"
+#include "core/dom/IntersectionObservation.h"
+#include "core/dom/IntersectionObserver.h"
 #include "core/dom/NamedNodeMap.h"
 #include "core/dom/NodeRareData.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/html/ClassList.h"
 #include "core/style/StyleInheritedData.h"
 #include "platform/heap/Handle.h"
+#include "wtf/HashSet.h"
 #include "wtf/OwnPtr.h"
+#include "wtf/WeakPtr.h"
 
 namespace blink {
 
 class HTMLElement;
 class CompositorProxiedPropertySet;
 
 class ElementRareData : public NodeRareData {
 public:
     static ElementRareData* create(LayoutObject* layoutObject)
     {
@@ skipping 54 matching lines @@
 
     IntSize savedLayerScrollOffset() const { return m_savedLayerScrollOffset; }
     void setSavedLayerScrollOffset(IntSize size) { m_savedLayerScrollOffset = size; }
 
     ElementAnimations* elementAnimations() { return m_elementAnimations.get(); }
     void setElementAnimations(ElementAnimations* elementAnimations)
     {
         m_elementAnimations = elementAnimations;
     }
 
+    bool hasIntersectionObserver() const
+    {

[esprehn, 2015/12/12 00:14:13]

move all of this code to your separate object, put it in its own file (.h and
.cpp, it doesn't all need to be inline, in fact most of it shouldn't be)

[szager1, 2015/12/16 19:15:34]

Done.

+        return m_intersectionObservers && m_intersectionObservers->size();
+    }
+
+    IntersectionObserver::WeakHashSet& intersectionObservers()
+    {
+        if (!m_intersectionObservers)
+            m_intersectionObservers = new IntersectionObserver::WeakHashSet();
+        return *m_intersectionObservers;
+    }
+
+    bool hasIntersectionObservation() const
+    {
+        return m_intersectionObservations && m_intersectionObservations->size();
+    }
+
+    IntersectionObservation::HashSet& intersectionObservations()
+    {
+        if (!m_intersectionObservations)
+            m_intersectionObservations = new IntersectionObservation::HashSet();
+        return *m_intersectionObservations;
+    }
+
+    void deactivateAllIntersectionObservers()
+    {
+        if (!m_intersectionObservers)
+            return;
+        for (auto& observer: *m_intersectionObservers)
+            observer->setActive(false);
+    }
+
+    void deactivateAllIntersectionObservations()
+    {
+        if (!m_intersectionObservations)
+            return;
+        for (auto& observation: *m_intersectionObservations)
+            observation->setActive(false);
+    }
+
+#if !ENABLE(OILPAN)
+    WeakPtr<Element> createWeakPtr(Element* element)
+    {
+        if (!m_weakPointerFactory)
+            m_weakPointerFactory = adoptPtrWillBeNoop(new WeakPtrFactory<Element>(element));
+        return m_weakPointerFactory->createWeakPtr();
+    }
+#endif
+
     bool hasPseudoElements() const;
     void clearPseudoElements();
 
     void incrementCompositorProxiedProperties(uint32_t properties);
     void decrementCompositorProxiedProperties(uint32_t properties);
     CompositorProxiedPropertySet* proxiedPropertyCounts() const { return m_proxiedProperties.get(); }
 
     void setCustomElementDefinition(PassRefPtrWillBeRawPtr<CustomElementDefinition> definition) { m_customElementDefinition = definition; }
     CustomElementDefinition* customElementDefinition() const { return m_customElementDefinition.get(); }
 
@@ skipping 10 matching lines @@
     short m_tabindex;
 
     LayoutSize m_minimumSizeForResizing;
     IntSize m_savedLayerScrollOffset;
 
     OwnPtrWillBeMember<DatasetDOMStringMap> m_dataset;
     OwnPtrWillBeMember<ClassList> m_classList;
     OwnPtrWillBeMember<ElementShadow> m_shadow;
     OwnPtrWillBeMember<NamedNodeMap> m_attributeMap;
     OwnPtrWillBeMember<AttrNodeList> m_attrNodeList;
-    PersistentWillBeMember<ElementAnimations> m_elementAnimations;
     OwnPtrWillBeMember<InlineCSSStyleDeclaration> m_cssomWrapper;
     OwnPtr<CompositorProxiedPropertySet> m_proxiedProperties;
 
+#if !ENABLE(OILPAN)
+    OwnPtrWillBeMember<WeakPtrFactory<Element>> m_weakPointerFactory;

[esprehn, 2015/12/12 00:14:13]

move to controller

[szager1, 2015/12/16 19:15:34]

Done.

+#endif
+
+    PersistentWillBeMember<ElementAnimations> m_elementAnimations;
+    // Note that m_intersectionObservers will contain both observers for which this element is target,

[ojan, 2015/12/12 01:06:28]

This comment is in the wrong place?

[szager1, 2015/12/16 19:15:34]

That's an obsolete comment, I removed it.

+    // and observers for which this element is root.  To tell them apart, check (observer->root() == element).

[esprehn, 2015/12/12 00:14:13]

keep two sets instead? This doesn't seem right

[szager1, 2015/12/16 19:15:34]

same comment

+
     RefPtr<ComputedStyle> m_computedStyle;
     RefPtrWillBeMember<CustomElementDefinition> m_customElementDefinition;
 
     RefPtrWillBeMember<PseudoElement> m_generatedBefore;
     RefPtrWillBeMember<PseudoElement> m_generatedAfter;
     RefPtrWillBeMember<PseudoElement> m_generatedFirstLetter;
     RefPtrWillBeMember<PseudoElement> m_backdrop;
 
+    // IntersectionObservers for which this element is root.
+    PersistentWillBeMember<IntersectionObserver::WeakHashSet> m_intersectionObservers;
+    // IntersectionObservations for which this element is target.
+    PersistentWillBeMember<IntersectionObservation::HashSet> m_intersectionObservations;

[esprehn, 2015/12/12 00:14:13]

PersistentWillBeMember<IntersectionObserverController> or whatever you want to
call it, only add a single member here, the rest of your code and data should
live there.

[szager1, 2015/12/16 19:15:34]

Done.

+
     explicit ElementRareData(LayoutObject*);
 };
 
 inline LayoutSize defaultMinimumSizeForResizing()
 {
     return LayoutSize(LayoutUnit::max(), LayoutUnit::max());
 }
 
 inline ElementRareData::ElementRareData(LayoutObject* layoutObject)
     : NodeRareData(layoutObject)
@@ skipping 88 matching lines @@
 inline CompositorProxiedPropertySet& ElementRareData::ensureCompositorProxiedPropertySet()
 {
     if (!m_proxiedProperties)
         m_proxiedProperties = CompositorProxiedPropertySet::create();
     return *m_proxiedProperties;
 }
 
 } // namespace
 
 #endif // ElementRareData_h