IntersectionObserver: second cut.

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

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "core/dom/ElementIntersectionObserverData.h"
+
+#include "core/dom/Document.h"
+#include "core/dom/Element.h"
+#include "core/dom/IntersectionObservation.h"
+#include "core/dom/IntersectionObserver.h"
+#include "core/dom/IntersectionObserverController.h"
+
+namespace blink {
+
+ElementIntersectionObserverData::ElementIntersectionObserverData() { }
+
+ElementIntersectionObserverData::~ElementIntersectionObserverData() { }
+
+bool ElementIntersectionObserverData::hasIntersectionObserver() const
+{
+    return !m_intersectionObservers.isEmpty();
+}
+
+bool ElementIntersectionObserverData::hasIntersectionObservation() const
+{
+    return !m_intersectionObservations.isEmpty();
+}
+
+IntersectionObservation* ElementIntersectionObserverData::getObservationFor(IntersectionObserver& observer)
+{
+    HeapHashMap<Member<IntersectionObserver>, Member<IntersectionObservation>>::iterator i = m_intersectionObservations.find(&observer);

[haraken, 2016/01/07 00:48:17]

Can we use auto& ?

[szager1, 2016/01/07 07:12:22]

Done.

+    if (i == m_intersectionObservations.end())
+        return nullptr;
+    return i->value;
+}
+
+void ElementIntersectionObserverData::addObservation(IntersectionObservation& observation)
+{
+    m_intersectionObservations.add(&observation.observer(), &observation);
+}
+
+void ElementIntersectionObserverData::removeObservation(IntersectionObserver& observer)
+{
+    m_intersectionObservations.remove(&observer);
+}
+
+void ElementIntersectionObserverData::activateValidIntersectionObservers(Element& element)
+{
+    IntersectionObserverController& controller = element.document().ensureIntersectionObserverController();
+    for (auto& observer : m_intersectionObservers) {
+        controller.addTrackedObserver(*observer);
+        observer->setActive(true);
+    }
+    for (auto& observation : m_intersectionObservations)
+        observation.value->setActive(observation.key->isDescendantOfRoot(&element));
+}
+
+void ElementIntersectionObserverData::deactivateAllIntersectionObservers(Element& element)
+{
+    element.document().ensureIntersectionObserverController().removeTrackedObserversForRoot(element);
+    for (auto& observer : m_intersectionObservers)
+        observer->setActive(false);
+    for (auto& observation : m_intersectionObservations)
+        observation.value->setActive(false);
+}
+
+#if !ENABLE(OILPAN)
+void ElementIntersectionObserverData::dispose()
+{
+    HeapVector<Member<IntersectionObservation>> observationsToDisconnect;
+    copyValuesToVector(m_intersectionObservations, observationsToDisconnect);
+    for (auto& observation : observationsToDisconnect)
+        observation->disconnect();
+    ASSERT(m_intersectionObservations.isEmpty());
+
+    HeapVector<Member<IntersectionObserver>> observersToDisconnect;
+    copyToVector(m_intersectionObservers, observersToDisconnect);
+    for (auto& observer : observersToDisconnect)
+        observer->disconnect();

[haraken, 2016/01/07 00:48:17]

Why do you need to call disconnect() for Observers? Won't it be enough to call
disconnect() for Observations? (i.e., the line 73 would be enough.)

[szager1, 2016/01/07 07:12:22]

The first section disconnects observations for which this element is target. 
The second section disconnects observers for which this element is root.

[haraken, 2016/01/07 07:38:13]

Thanks. I understand the second one is necessary (this will be replaced with
registerWeakMember in oilpan).

But the first one looks a bit nasty. The first one is doing something like:

- When the target element is destructed, it calls
ElementIntersectionObserverData::dispose().
- ElementIntersectionObserverData::dispose() calls Observation::disconnect().
- The Observation::disconnect() removes the Observation from the
ElementIntersectionObserverData of the target element that is currently being
destructed.

Is the first one necessary?

+    ASSERT(m_intersectionObservers.isEmpty());
+
+    m_weakPointerFactory.clear();
+}
+#endif
+
+WeakPtrWillBeRawPtr<Element> ElementIntersectionObserverData::createWeakPtr(Element* element)
+{
+#if ENABLE(OILPAN)
+    return element;
+#else
+    if (!m_weakPointerFactory)
+        m_weakPointerFactory = adoptPtrWillBeNoop(new WeakPtrFactory<Element>(element));
+    return m_weakPointerFactory->createWeakPtr();
+#endif
+}
+
+DEFINE_TRACE(ElementIntersectionObserverData)
+{
+    visitor->trace(m_intersectionObservers);
+    visitor->trace(m_intersectionObservations);
+}
+
+} // namespace blink