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 327 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) {

[ojan, 2016/10/31 19:37:09]

This will happen to work for ElementVisibilityObserver because it only calls
observe once before setInitialState, but if any code called observe after
calling setInitialState, it wouldn't work.

I think what we want here is instead to:
1. Store a member on the IntersectionObserver that says the initial state is
Auto.
2. In observe, call setLastThresholdIndex when initial state == Auto.
3. DCHECK in setInitialState that observations() is empty. Then no need to loop
over them obviously. 
4. Put the setInitialState call after the IntersectionObserver::create in
ElementVisibilityObserver.

That way, future code that call setInitialState + observe will work right.

[Sami, 2016/11/01 10:44:48]

Thanks, I think this will help to avoid some surprises in the future. The only
detail I had to change was that the default initial state should be kHidden to
preserve the current behavior of IntersectionObserver.

+  DCHECK_EQ(initialState, InitialState::AUTO);
+  for (auto& observation : observations())
+    observation->setLastThresholdIndex(std::numeric_limits<unsigned>::max());
+}
+
 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