IntersectionObserver: second cut.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003-2011, 2013, 2014 Apple Inc. All rights reserved.
  *
  * 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
@@ skipping 38 matching lines @@
 class ClientRect;
 class ClientRectList;
 class CustomElementDefinition;
 class DOMStringMap;
 class DOMTokenList;
 class Dictionary;
 class ElementRareData;
 class ElementShadow;
 class ExceptionState;
 class Image;
+class IntersectionObservation;
+class IntersectionObserver;
 class IntSize;
 class Locale;
 class MutableStylePropertySet;
 class PropertySetCSSStyleDeclaration;
 class PseudoElement;
 class ScrollState;
 class ScrollStateCallback;
 class ScrollToOptions;
 class ShadowRoot;
 class ShadowRootInit;
@@ skipping 462 matching lines @@
     void setTabIndex(int);
     short tabIndex() const override;
 
     void incrementProxyCount();
     void decrementProxyCount();
 
     DECLARE_VIRTUAL_TRACE();
 
     SpellcheckAttributeState spellcheckAttributeState() const;
 
+    WeakPtr<Element> createWeakPtr();

[dcheng, 2015/11/20 20:35:07]

That being said, can we do this without exposing weak pointers for
Document/Element?

For Document, it feels weird, because there's already DocumentLifecycleObserver.
For elements, it seems unnecessary as well: from what I can tell
(https://rawgit.com/slightlyoff/IntersectionObserver/master/index.html#removin...),
unregistering observers is tied to removing nodes from the DOM. In that case,
wouldn't Element::detach() be the place to do the unregistration?

[szager1, 2015/11/20 22:02:23]

The spec is out-of-date; the consensus is now:

- when either the root or target element is removed from the DOM, its
RegisteredIntersectionObservers will be disabled, but not unobserved.
- when root or target is re-added to the DOM, its
RegisteredIntersectionObservers will be examined and any one that now has an
appropriate inheritance relationship between root and target will be
reactivated.

Basically, that means that the lifetime of the observer is tied to the lifetime
of the root and target elements, which may be in different documents.

[dcheng, 2015/11/20 22:50:52]

In general, I'm not thrilled about exposing weak pointers externally to a class
and I'm still not convinced it's necessary here. Where's the most up-to-date
spec? And who should I bug to answer random questions about the spec?

[szager1, 2015/12/01 06:53:31]

I updated the implementation design doc:

https://docs.google.com/a/google.com/document/d/1hLK0eyT5_BzyNS4OkjsnoqqFQDYC...

Hopefully that clears up the need for weak pointers.

+
+    void addIntersectionObservation(IntersectionObservation&);
+    void removeIntersectionObservation(IntersectionObservation&);
+
+    bool computeIntersection(Element*, LayoutRect&, LayoutRect&, LayoutRect&);
+
 protected:
     Element(const QualifiedName& tagName, Document*, ConstructionType);
 
     const ElementData* elementData() const { return m_elementData.get(); }
     UniqueElementData& ensureUniqueElementData();
 
     void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, CSSValueID identifier);
     void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, double value, CSSPrimitiveValue::UnitType);
     void addPropertyToPresentationAttributeStyle(MutableStylePropertySet*, CSSPropertyID, const String& value);
 
@@ skipping 123 matching lines @@
 
     ElementRareData* elementRareData() const;
     ElementRareData& ensureElementRareData();
 
     AttrNodeList& ensureAttrNodeList();
     void removeAttrNodeList();
     void detachAllAttrNodesFromElement();
     void detachAttrNodeFromElementWithValue(Attr*, const AtomicString& value);
     void detachAttrNodeAtIndex(Attr*, size_t index);
 
+    void disconnectIntersectionObservations();
+
     v8::Local<v8::Object> wrapCustomElement(v8::Isolate*, v8::Local<v8::Object> creationContext);
 
     RefPtrWillBeMember<ElementData> m_elementData;
 };
 
 DEFINE_NODE_TYPE_CASTS(Element, isElementNode());
 template <typename T> bool isElementOfType(const Node&);
 template <> inline bool isElementOfType<const Element>(const Node& node) { return node.isElementNode(); }
 template <typename T> inline bool isElementOfType(const Element& element) { return isElementOfType<T>(static_cast<const Node&>(element)); }
 template <> inline bool isElementOfType<const Element>(const Element&) { return true; }
@@ skipping 225 matching lines @@
     static PassRefPtrWillBeRawPtr<T> create(const QualifiedName&, Document&)
 #define DEFINE_ELEMENT_FACTORY_WITH_TAGNAME(T) \
     PassRefPtrWillBeRawPtr<T> T::create(const QualifiedName& tagName, Document& document) \
     { \
         return adoptRefWillBeNoop(new T(tagName, document)); \
     }
 
 } // namespace
 
 #endif // Element_h