IntersectionObserver: second cut.

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

+// 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);
+
+    struct IntersectionGeometry {
+        LayoutRect targetRect;
+        LayoutRect intersectionRect;
+        LayoutRect rootRect;
+    };
+
+    IntersectionObserver& observer() const { return *m_observer; }
+    Element* target() const { 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;
+    WeakPtrWillBeMember<Element> m_target;

[haraken, 2016/01/02 13:47:40]

Doesn't this need to be a WeakMember?

According to the design document
(https://docs.google.com/document/d/1hLK0eyT5_BzyNS4OkjsnoqqFQDYCbKfyBinj94OnL...),
observation => target needs to be weak.

(Sorry, in the previous review I asked you to use a Member, not a WeakMember. I
now understand the lifetime relationship and I think a WeakMember is a right
solution.)

[szager1, 2016/01/02 19:18:34]

Actually, I agreed with your previous comment :)  This *can* be a WeakMember,
but it need not be.  If the only remaining reference to the target element is
the strong reference from IntersectionObservation, then the garbage collector
should detect the reference cycle and do the right thing.  There are no other
strong references to IntersectionObservation in the code.

[haraken, 2016/01/03 16:34:20]

Thanks, I understand. Then I'd prefer using a WeakMember because it is a bit
fragile to assume that there is no other strong references to the Observation
even though it is true at the moment.

[szager1, 2016/01/04 03:53:04]

Done.

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