Use intersection observer to control frame throttling

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

 // Copyright 2016 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 "core/dom/IntersectionObserver.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/css/parser/CSSParserTokenRange.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/dom/Element.h"
@@ skipping 185 matching lines @@
     IntersectionObserverCallback& callback,
     Node& root,
     const Vector<Length>& rootMargin,
     const Vector<float>& thresholds)
     : m_callback(&callback),
       m_root(&root),
       m_thresholds(thresholds),
       m_topMargin(Fixed),
       m_rightMargin(Fixed),
       m_bottomMargin(Fixed),
-      m_leftMargin(Fixed) {
+      m_leftMargin(Fixed),
+      m_initialState(InitialState::kHidden) {
   switch (rootMargin.size()) {
     case 0:
       break;
     case 1:
       m_topMargin = m_rightMargin = m_bottomMargin = m_leftMargin =
           rootMargin[0];
       break;
     case 2:
       m_topMargin = m_bottomMargin = rootMargin[0];
       m_rightMargin = m_leftMargin = rootMargin[1];
@@ skipping 67 matching lines @@
   m_observations.add(observation);
 
   if (!isDOMDescendant) {
     m_root->document().addConsoleMessage(
         ConsoleMessage::create(JSMessageSource, WarningMessageLevel,
                                "IntersectionObserver.observe(target): target "
                                "element is not a descendant of root."));
     return;
   }
 
+  if (m_initialState == InitialState::kAuto) {
+    for (auto& observation : m_observations)
+      observation->setLastThresholdIndex(std::numeric_limits<unsigned>::max());
+  }
+
   if (!rootFrame)
     return;
   if (FrameView* rootFrameView = rootFrame->view())
     rootFrameView->scheduleAnimation();
 }
 
 void IntersectionObserver::unobserve(Element* target,
                                      ExceptionState& exceptionState) {
   if (!m_root) {
     exceptionState.throwDOMException(
@@ skipping 34 matching lines @@
   for (auto& observation : m_observations)
     observation->clearRootAndRemoveFromTarget();
   m_observations.clear();
 }
 
 void IntersectionObserver::removeObservation(
     IntersectionObservation& observation) {
   m_observations.remove(&observation);
 }
 
+void IntersectionObserver::setInitialState(InitialState initialState) {
+  DCHECK(m_observations.isEmpty());
+  m_initialState = initialState;
+}
+
 HeapVector<Member<IntersectionObserverEntry>> IntersectionObserver::takeRecords(
     ExceptionState& exceptionState) {
   HeapVector<Member<IntersectionObserverEntry>> entries;
 
   if (!m_root)
     exceptionState.throwDOMException(InvalidStateError,
                                      "takeRecords() called on an "
                                      "IntersectionObserver with an invalid "
                                      "root.");
   else
@@ skipping 78 matching lines @@
 
 DEFINE_TRACE(IntersectionObserver) {
   visitor->template registerWeakMembers<
       IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
   visitor->trace(m_callback);
   visitor->trace(m_observations);
   visitor->trace(m_entries);
 }
 
 }  // namespace blink