IntersectionObserver: throw exceptions as spec mandates.

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 140 matching lines @@
         ASSERT_NOT_REACHED();
         break;
     }
     root.document().ensureIntersectionObserverController().addTrackedObserver(*this);
 }
 
 void IntersectionObserver::clearWeakMembers(Visitor* visitor)
 {
     if (ThreadHeap::isHeapObjectAlive(m_root))
         return;
-    disconnect();
+    IgnorableExceptionState exceptionState;
+    disconnect(exceptionState);
     m_root = nullptr;
 }
 
 LayoutObject* IntersectionObserver::rootLayoutObject() const
 {
     Node* node = rootNode();
     if (node->isDocumentNode())
         return toDocument(node)->layoutView();
     return toElement(node)->layoutObject();
 }
 
-void IntersectionObserver::observe(Element* target)
+void IntersectionObserver::observe(Element* target, ExceptionState& exceptionState)
 {
-    if (!m_root || !target || m_root.get() == target)
+    if (!m_root) {
+        exceptionState.throwDOMException(InvalidStateError, "observe() called on an IntersectionObserver with an invalid root.");
+        return;
+    }
+
+    if (!target || m_root.get() == target)
         return;
 
     if (target->ensureIntersectionObserverData().getObservationFor(*this))
         return;
 
     bool shouldReportRootBounds = false;
     LocalFrame* targetFrame = target->document().frame();
     LocalFrame* rootFrame = rootNode()->document().frame();
     if (targetFrame && rootFrame)
         shouldReportRootBounds = targetFrame->securityContext()->getSecurityOrigin()->canAccess(rootFrame->securityContext()->getSecurityOrigin());
     IntersectionObservation* observation = new IntersectionObservation(*this, *target, shouldReportRootBounds);
     target->ensureIntersectionObserverData().addObservation(*observation);
     m_observations.add(observation);
     if (!rootFrame)
         return;
     if (FrameView* rootFrameView = rootFrame->view())
         rootFrameView->scheduleAnimation();
 }
 
-void IntersectionObserver::unobserve(Element* target)
+void IntersectionObserver::unobserve(Element* target, ExceptionState& exceptionState)
 {
+    if (!m_root) {
+        exceptionState.throwDOMException(InvalidStateError, "unobserve() called on an IntersectionObserver with an invalid root.");
+        return;
+    }
+
     if (!target || !target->intersectionObserverData())
         return;
     // TODO(szager): unobserve callback
     if (IntersectionObservation* observation = target->intersectionObserverData()->getObservationFor(*this))
         observation->disconnect();
 }
 
 void IntersectionObserver::computeIntersectionObservations()
 {
     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()
+void IntersectionObserver::disconnect(ExceptionState& exceptionState)
 {
+    if (!m_root) {
+        exceptionState.throwDOMException(InvalidStateError, "disconnect() called on an IntersectionObserver with an invalid root.");
+        return;
+    }
+
     for (auto& observation : m_observations)
         observation->clearRootAndRemoveFromTarget();
     m_observations.clear();
 }
 
 void IntersectionObserver::removeObservation(IntersectionObservation& observation)
 {
     m_observations.remove(&observation);
 }
 
-HeapVector<Member<IntersectionObserverEntry>> IntersectionObserver::takeRecords()
+HeapVector<Member<IntersectionObserverEntry>> IntersectionObserver::takeRecords(ExceptionState& exceptionState)
 {
     HeapVector<Member<IntersectionObserverEntry>> entries;
-    entries.swap(m_entries);
+
+    if (!m_root)
+        exceptionState.throwDOMException(InvalidStateError, "takeRecords() called on an IntersectionObserver with an invalid root.");
+    else
+        entries.swap(m_entries);
+
     return entries;
 }
 
 Element* IntersectionObserver::root() const
 {
     Node* node = rootNode();
     if (node && !node->isDocumentNode())
         return toElement(node);
     return nullptr;
 }
@@ skipping 70 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