IntersectionObserver: second cut.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 57 matching lines @@
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/DocumentLifecycleObserver.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementDataCache.h"
 #include "core/dom/ElementRegistrationOptions.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/dom/FrameRequestCallback.h"
+#include "core/dom/IntersectionObserverController.h"
 #include "core/dom/LayoutTreeBuilderTraversal.h"
 #include "core/dom/MainThreadTaskRunner.h"
 #include "core/dom/Microtask.h"
 #include "core/dom/MutationObserver.h"
 #include "core/dom/NodeChildRemovalTracker.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/NodeFilter.h"
 #include "core/dom/NodeIterator.h"
 #include "core/dom/NodeRareData.h"
 #include "core/dom/NodeTraversal.h"
@@ skipping 513 matching lines @@
     // FIXME: consider using ActiveDOMObject.
     if (m_scriptedAnimationController)
         m_scriptedAnimationController->clearDocumentPointer();
     m_scriptedAnimationController.clear();
 
     m_scriptedIdleTaskController.clear();
 
     if (svgExtensions())
         accessSVGExtensions().pauseAnimations();
 
+    if (m_intersectionObserverController) {
+        m_intersectionObserverController->dispose();
+        m_intersectionObserverController.clear();
+    }
+
     m_lifecycle.advanceTo(DocumentLifecycle::Disposed);
     DocumentLifecycleNotifier::notifyDocumentWasDisposed();
 
     m_canvasFontCache.clear();
 }
 #endif
 
 SelectorQueryCache& Document::selectorQueryCache()
 {
     if (!m_selectorQueryCache)
@@ skipping 3954 matching lines @@
 
     ASSERT(doc);
     return *doc;
 }
 
 WeakPtrWillBeRawPtr<Document> Document::contextDocument()
 {
     if (m_contextDocument)
         return m_contextDocument;
     if (m_frame) {
-#if ENABLE(OILPAN)
-        return this;
-#else
-        return m_weakFactory.createWeakPtr();
-#endif
+        return createWeakPtr();
     }
     return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<Attr> Document::createAttribute(const AtomicString& name, ExceptionState& exceptionState)
 {
     if (isHTMLDocument() && name != name.lower())
         UseCounter::count(*this, UseCounter::HTMLDocumentCreateAttributeNameNotLowercase);
     return createAttributeNS(nullAtom, name, exceptionState, true);
 }
@@ skipping 455 matching lines @@
 {
     if (equalIgnoringCase(dnsPrefetchControl, "on") && !m_haveExplicitlyDisabledDNSPrefetch) {
         m_isDNSPrefetchEnabled = true;
         return;
     }
 
     m_isDNSPrefetchEnabled = false;
     m_haveExplicitlyDisabledDNSPrefetch = true;
 }
 
+WeakPtrWillBeRawPtr<Document> Document::createWeakPtr()
+{
+#if ENABLE(OILPAN)
+    return this;
+#else
+    return m_weakFactory.createWeakPtr();
+#endif
+}
+
+IntersectionObserverController& Document::ensureIntersectionObserverController()
+{
+    if (!m_intersectionObserverController)
+        m_intersectionObserverController = new IntersectionObserverController();
+    return *m_intersectionObserverController;
+}
+
 void Document::reportBlockedScriptExecutionToInspector(const String& directiveText)
 {
     InspectorInstrumentation::scriptExecutionBlockedByCSP(this, directiveText);
 }
 
 void Document::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
 {
     if (!isContextThread()) {
         m_taskRunner->postTask(BLINK_FROM_HERE, AddConsoleMessageTask::create(consoleMessage->source(), consoleMessage->level(), consoleMessage->message()));
         return;
@@ skipping 17 matching lines @@
 void Document::postTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task)
 {
     m_taskRunner->postTask(location, task);
 }
 
 void Document::postInspectorTask(const WebTraceLocation& location, PassOwnPtr<ExecutionContextTask> task)
 {
     m_taskRunner->postInspectorTask(location, task);
 }
 
 void Document::tasksWereSuspended()

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

Don't you need to suspend the observers when the document gets suspended?

The only customer of suspend/resume is Devtools and a couple of unpopular
features. I'd propose not supporting suspend/resume in this CL (i.e. remove
IntersectionObserverController::m_suspendedIntersectionObservers). We can
support it in a follow-up CL.

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

As I understand it, "suspended" in this case means "javascript cannot run." 
It's not clear to me that the observers should stop generating notifications in
this circumstance; in this case, I am following the example of MutationObserver,
which continues to generate notifications while tasks are suspended, but delays
running the callbacks until after tasks have been resumed.

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

Yes, you're right. What I'm suggesting is just to remove code for suspend/resume
in this CL and support it in a follow-up CL. That would be acceptable because
IntersectionObserver is under a runtime flag. This CL is already way too huge.

If you need to support the behavior for suspend/resume correctly, I think we
need to address a couple of more issues (e.g., I think you need to suspend
Observers in Document::tasksWereSuspended()). Let's address the complexity in a
follow-up CL.

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

Done.

 {
     scriptRunner()->suspend();
 
     if (m_parser)
         m_parser->suspendScheduledTasks();
     if (m_scriptedAnimationController)
         m_scriptedAnimationController->suspend();
 }
 
 void Document::tasksWereResumed()
 {
     scriptRunner()->resume();
 
     if (m_parser)
         m_parser->resumeScheduledTasks();
     if (m_scriptedAnimationController)
         m_scriptedAnimationController->resume();
 
     MutationObserver::resumeSuspendedObservers();
+    if (m_intersectionObserverController)
+        m_intersectionObserverController->resumeSuspendedIntersectionObservers();
     if (m_domWindow)
         DOMWindowPerformance::performance(*m_domWindow)->resumeSuspendedObservers();
 }
 
 // FIXME: suspendScheduledTasks(), resumeScheduledTasks(), tasksNeedSuspension()
 // should be moved to LocalDOMWindow once it inherits ExecutionContext
 void Document::suspendScheduledTasks()
 {
     ExecutionContext::suspendScheduledTasks();
     m_taskRunner->suspend();
@@ skipping 726 matching lines @@
     visitor->trace(m_timers);
     visitor->trace(m_templateDocument);
     visitor->trace(m_templateDocumentHost);
     visitor->trace(m_visibilityObservers);
     visitor->trace(m_userActionElements);
     visitor->trace(m_svgExtensions);
     visitor->trace(m_timeline);
     visitor->trace(m_compositorPendingAnimations);
     visitor->trace(m_contextDocument);
     visitor->trace(m_canvasFontCache);
+    visitor->trace(m_intersectionObserverController);
     WillBeHeapSupplementable<Document>::trace(visitor);
 #endif
     TreeScope::trace(visitor);
     ContainerNode::trace(visitor);
     ExecutionContext::trace(visitor);
     DocumentLifecycleNotifier::trace(visitor);
     SecurityContext::trace(visitor);
 }
 
 template class CORE_TEMPLATE_EXPORT WillBeHeapSupplement<Document>;
 
 } // namespace blink
 
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     Document::WeakDocumentSet& set = Document::liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().string().utf8().data());
 }
 #endif