IntersectionObserver: second cut.

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

Index: third_party/WebKit/Source/core/dom/IntersectionObserver.h
diff --git a/third_party/WebKit/Source/core/dom/IntersectionObserver.h b/third_party/WebKit/Source/core/dom/IntersectionObserver.h
new file mode 100644
index 0000000000000000000000000000000000000000..174c0d623d0cc8866e6673488f2f6ad75afd4df7
--- /dev/null
+++ b/third_party/WebKit/Source/core/dom/IntersectionObserver.h
@@ -0,0 +1,77 @@
+// 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.
+
+#ifndef IntersectionObserver_h
+#define IntersectionObserver_h
+
+#include "bindings/core/v8/ScriptWrappable.h"
+#include "core/dom/Element.h"
+#include "core/dom/IntersectionObservation.h"
+#include "core/dom/IntersectionObserverEntry.h"
+#include "platform/heap/Handle.h"
+#include "wtf/HashSet.h"
+#include "wtf/RefCounted.h"
+#include "wtf/Vector.h"
+
+namespace blink {
+
+class ExceptionState;
+class IntersectionObserverCallback;
+class IntersectionObserverInit;
+
+class IntersectionObserver final : public GarbageCollectedFinalized<IntersectionObserver>, public ScriptWrappable {
+    DEFINE_WRAPPERTYPEINFO();
+
+public:
+    static IntersectionObserver* create(const IntersectionObserverInit&, IntersectionObserverCallback&, ExceptionState&);
+    static void resumeSuspendedObservers();
+
+    // API methods
+    void observe(Element*, ExceptionState&);
+    void unobserve(Element*, ExceptionState&);
+    void disconnect();
+    HeapVector<Member<IntersectionObserverEntry>> takeRecords();
+
+    Element* root() { return m_root.get(); }
+    LayoutObject* rootLayoutObject();
+    bool isDescendantOfRoot(const Element*) const;
+    void computeIntersectionObservations(double timestamp);
+    void disconnect(IntersectionObservation&);
+    void enqueueIntersectionObserverEntry(IntersectionObserverEntry&);
+    void applyRootMargin(LayoutRect&) const;
+    unsigned firstThresholdGreaterThan(float ratio) const;
+    bool shouldBeSuspended() const;
+    void deliver();
+    void setActive(bool);
+    bool hasPercentMargin() const;
+    const Length& topMargin() const { return m_topMargin; }
+    const Length& rightMargin() const { return m_rightMargin; }
+    const Length& bottomMargin() const { return m_bottomMargin; }
+    const Length& leftMargin() const { return m_leftMargin; }
+
+#if !ENABLE(OILPAN)
+    void dispose();
+#endif
+
+    DECLARE_TRACE();
+
+private:
+    explicit IntersectionObserver(IntersectionObserverCallback&, Element&, const Vector<Length>& rootMargin, const Vector<float>& thresholds);
+
+    void checkRootAndDetachIfNeeded();
+
+    Member<IntersectionObserverCallback> m_callback;
+    WeakPtrWillBeWeakMember<Element> m_root;

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

If you use a WeakMember, isn't there any risk that Oilpan's GC behavior becomes
observable to JS? The timing when the WeakMember is cleared depends on when
Oilpan's GC runs. It is not a good idea that the behavior is exposed to JS.

When should the m_root become nullptr? That must be explicitly defined without
relying on a GC timing.

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

JS can't get the root from the observer, that's not observable. The observer
must not keep the root alive though, it also must not keep the targets alive.
Only observations keep them alive. The only way to observe any of this is to
have strong refs from JS, so I think this WeakPtr is fine.

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

m_root should become nullptr when the Element it points to is deleted.  Is there
some other way to do this, aside from waiting for gc to run?

+    HeapHashSet<WeakMember<IntersectionObservation>> m_observations;

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

I'm wondering why this needs to be weak.

You're already adding HeapHashMap<Member<IntersectionObserver>,
Member<IntersectionObservation>> to ElementIntersectionObserverData. Doesn't it
mean that you're already adding a strong reference from the IntersectionObserver
to the IntersectionObservation?

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

Hmm yeah, shouldn't the observer keep the observations alive? Cycles in the
Oilpan heap should be fine.

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

No, I think you are confused about the members of
ElementIntersectionObserverData.  An Element may be the root of one observer,
and the target of another.  ElementIntersectionObserverData keeps track of both.

An IntersectionObserver may outlive its IntersectionObservations (if the target
element goes away).  The observer should not keep the observation alive; only
the target element keeps the observation alive.

+    HeapVector<Member<IntersectionObserverEntry>> m_entries;
+    Vector<float> m_thresholds;
+    Length m_topMargin;
+    Length m_rightMargin;
+    Length m_bottomMargin;
+    Length m_leftMargin;
+};
+
+} // namespace blink
+
+#endif // IntersectionObserver_h