IntersectionObserver: second cut.

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

Index: third_party/WebKit/Source/core/dom/IntersectionObservation.h
diff --git a/third_party/WebKit/Source/core/dom/IntersectionObservation.h b/third_party/WebKit/Source/core/dom/IntersectionObservation.h
new file mode 100644
index 0000000000000000000000000000000000000000..149f95b347a8710881537b22b851c830ba864007
--- /dev/null
+++ b/third_party/WebKit/Source/core/dom/IntersectionObservation.h
@@ -0,0 +1,56 @@
+// Copyright 2015 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 "platform/geometry/LayoutRect.h"
+#include "platform/heap/Handle.h"
+
+#ifndef IntersectionObservation_h
+#define IntersectionObservation_h
+
+namespace blink {
+
+class Element;
+class IntersectionObserver;
+
+class IntersectionObservation : public GarbageCollectedFinalized<IntersectionObservation> {
+public:
+    IntersectionObservation(IntersectionObserver&, Element&, bool shouldReportRootBounds);

[haraken, 2015/12/22 01:13:30]

Can we add a destructor and add ASSERT(!m_target)? We need to make sure that
disconnect() has been called before the IntersectionObserver gets destructed.

[szager1, 2015/12/22 07:53:41]

It should be OK to destruct an IntersectionObservation without calling
disconnect().  In fact, in an oilpan world, that *must* be the case, because
there is no opportunity to call disconnect() from the target element destructor,
and the target element holds the only hard reference to the
IntersectionObservation.

+
+    struct IntersectionGeometry {
+        LayoutRect targetRect;
+        LayoutRect intersectionRect;
+        LayoutRect rootRect;
+    };
+
+    const IntersectionObserver* observer() const { return m_observer; }
+    IntersectionObserver* observer() { return m_observer; }

[esprehn, 2015/12/22 07:50:32]

can these ever be null?

[szager1, 2015/12/22 08:49:50]

No, switched to reference.

+    const Element* target() const { return m_target.get(); }
+    Element* target() { return m_target.get(); }
+    bool isActive() const { return m_active; }
+    void setActive(bool active) { m_active = active; }
+    unsigned lastThresholdIndex() const { return m_lastThresholdIndex; }
+    void setLastThresholdIndex(unsigned index) { m_lastThresholdIndex = index; }
+    bool shouldReportRootBounds() const { return m_shouldReportRootBounds; }
+
+    void computeIntersectionObservations(double timestamp);
+    void disconnect();
+
+    DECLARE_TRACE();
+
+private:
+    void initializeGeometry(IntersectionGeometry&);
+    void clipToRoot(LayoutRect&);
+    void clipToFrameView(IntersectionGeometry&);
+    bool computeGeometry(IntersectionGeometry&);
+
+    Member<IntersectionObserver> m_observer;
+    WeakPtrWillBeWeakMember<Element> m_target;

[haraken, 2015/12/22 01:13:30]

In oilpan, why does this need to be a WeakMember? Given that the
IntersectionObservation should not outlive the Element, it should be a Member.

In non-oilpan, I guess this doesn't need to be a WeakPtr. We can make it a
RawPtr and clear it in disconnect(). I'm assuming that disconnect() is always
called before the IntersectionObservation is destructed, right?

[szager1, 2015/12/22 07:53:41]

The IntersectionObservation should not 
You're right that in oilpan, it doesn't need to be weak.  In non-oilpan, the
observation should not keep the element alive, and as I said in the previous
comment, there is no guarantee that disconnect() will be called.

I changed it to WeakPtrWillBeMember

+    unsigned m_active : 1;
+    unsigned m_shouldReportRootBounds : 1;
+    unsigned m_lastThresholdIndex : 30;
+};
+
+} // namespace blink {
+
+#endif // IntersectionObservation_h