IntersectionObserver: remove gc-timing-revealing execeptions.

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 212 matching lines @@
   if (rootIsImplicit()) {
     DCHECK(m_callback->getExecutionContext());
     return *toDocument(m_callback->getExecutionContext());
   }
   DCHECK(root());
   return root()->document();
 }
 
 void IntersectionObserver::observe(Element* target,
                                    ExceptionState& exceptionState) {
-  if (!rootIsValid()) {
-    exceptionState.throwDOMException(
-        InvalidStateError,
-        "observe() called on an IntersectionObserver with an invalid root.");
+  if (!rootIsValid())
     return;
-  }
 
   if (!target || root() == target)
     return;
 
   LocalFrame* targetFrame = target->document().frame();
   if (!targetFrame)
     return;
 
   if (target->ensureIntersectionObserverData().getObservationFor(*this))
     return;
@@ skipping 31 matching lines @@
     for (auto& observation : m_observations)
       observation->setLastThresholdIndex(std::numeric_limits<unsigned>::max());
   }
 
   if (FrameView* frameView = targetFrame->view())
     frameView->scheduleAnimation();
 }
 
 void IntersectionObserver::unobserve(Element* target,
                                      ExceptionState& exceptionState) {
-  if (!rootIsValid()) {
-    exceptionState.throwDOMException(
-        InvalidStateError,
-        "unobserve() called on an IntersectionObserver with an invalid root.");
-    return;
-  }
-
   if (!target || !target->intersectionObserverData())
     return;
 
   if (IntersectionObservation* observation =
-          target->intersectionObserverData()->getObservationFor(*this))
+          target->intersectionObserverData()->getObservationFor(*this)) {
     observation->disconnect();
+    m_observations.remove(observation);
+  }
 }
 
 void IntersectionObserver::computeIntersectionObservations() {
   if (!rootIsValid())
     return;
   Document* callbackDocument = toDocument(m_callback->getExecutionContext());
   if (!callbackDocument)
     return;
   LocalDOMWindow* callbackDOMWindow = callbackDocument->domWindow();
   if (!callbackDOMWindow)
     return;
   DOMHighResTimeStamp timestamp =
       DOMWindowPerformance::performance(*callbackDOMWindow)->now();
   for (auto& observation : m_observations)
     observation->computeIntersectionObservations(timestamp);
 }
 
 void IntersectionObserver::disconnect(ExceptionState& exceptionState) {
-  if (!rootIsValid()) {
-    exceptionState.throwDOMException(
-        InvalidStateError,
-        "disconnect() called on an IntersectionObserver with an invalid root.");
-    return;
-  }
-
   for (auto& observation : m_observations)
-    observation->clearRootAndRemoveFromTarget();
+    observation->disconnect();
   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 (!rootIsValid()) {
-    exceptionState.throwDOMException(InvalidStateError,
-                                     "takeRecords() called on an "
-                                     "IntersectionObserver with an invalid "
-                                     "root.");
-  } else {
-    entries.swap(m_entries);
-  }
-
+  entries.swap(m_entries);
   return entries;
 }
 
 static void appendLength(StringBuilder& stringBuilder, const Length& length) {
   stringBuilder.appendNumber(length.intValue());
   if (length.type() == Percent)
     stringBuilder.append('%');
   else
     stringBuilder.append("px", 2);
 }
@@ skipping 36 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