IntersectionObserver: make exceptions match spec

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/ExceptionCode.h"
@@ skipping 35 matching lines @@
             break;
         case DimensionToken:
             switch (token.unitType()) {
             case CSSPrimitiveValue::UnitType::Pixels:
                 rootMargin.append(Length(static_cast<int>(floor(token.numericValue())), Fixed));
                 break;
             case CSSPrimitiveValue::UnitType::Percentage:
                 rootMargin.append(Length(token.numericValue(), Percent));
                 break;
             default:
-                exceptionState.throwTypeError("rootMargin must be specified in pixels or percent.");
+                exceptionState.throwDOMException(SyntaxError, "rootMargin must be specified in pixels or percent.");
             }
             break;
         default:
-            exceptionState.throwTypeError("rootMargin must be specified in pixels or percent.");
+            exceptionState.throwDOMException(SyntaxError, "rootMargin must be specified in pixels or percent.");
         }
     }
 }
 
 static void parseThresholds(const DoubleOrDoubleArray& thresholdParameter, Vector<float>& thresholds, ExceptionState& exceptionState)
 {
     if (thresholdParameter.isDouble()) {
         thresholds.append(static_cast<float>(thresholdParameter.getAsDouble()));
     } else {
         for (auto thresholdValue : thresholdParameter.getAsDoubleArray())
             thresholds.append(static_cast<float>(thresholdValue));
     }
 
     for (auto thresholdValue : thresholds) {
         if (thresholdValue < 0.0 || thresholdValue > 1.0) {
-            exceptionState.throwTypeError("Threshold values must be between 0 and 1");
+            exceptionState.throwRangeError("Threshold values must be between 0 and 1");
             break;
         }
     }
 
     std::sort(thresholds.begin(), thresholds.end());
 }
 
 IntersectionObserver* IntersectionObserver::create(const IntersectionObserverInit& observerInit, IntersectionObserverCallback& callback, ExceptionState& exceptionState)
 {
     RefPtrWillBeRawPtr<Node> root = observerInit.root();
@@ skipping 81 matching lines @@
 {
     Node* node = rootNode();
     if (node->isDocumentNode())
         return toDocument(node)->layoutView();
     return toElement(node)->layoutObject();
 }
 
 void IntersectionObserver::observe(Element* target, ExceptionState& exceptionState)
 {
     if (!m_root) {
-        exceptionState.throwDOMException(HierarchyRequestError, "Invalid observer: root element or containing document has been deleted.");
+        exceptionState.throwDOMException(InvalidStateError, "Invalid observer: root element or containing document has been deleted.");

[ojan, 2016/02/27 01:45:45]

I thought we decided this case wouldn't throw?

[szager1, 2016/02/29 22:35:53]

Initially, I had thought this method would still throw for the other error
cases.  On further consideration, that's not right; in particular, a
cross-origin observe() on an observer with a root margin should not throw, it
should just not use the margin when computing intersections.

I added the above change and a test.

         return;
     }
     if (!target) {
         exceptionState.throwTypeError("Observation target must be an element.");
         return;
     }
     if (m_root.get() == target) {
         exceptionState.throwDOMException(HierarchyRequestError, "Cannot use the same element for root and target.");
         return;
     }
 
     // TODO(szager): Add a pointer to the spec that describes this policy.
     bool shouldReportRootBounds = target->document().frame()->securityContext()->securityOrigin()->canAccess(rootNode()->document().frame()->securityContext()->securityOrigin());
     if (!shouldReportRootBounds && hasPercentMargin()) {
         exceptionState.throwDOMException(HierarchyRequestError, "Cannot observe a cross-origin target because the observer has a root margin value specified as a percent.");
         return;
     }
 
     if (target->ensureIntersectionObserverData().getObservationFor(*this))
         return;
 
     IntersectionObservation* observation = new IntersectionObservation(*this, *target, shouldReportRootBounds);
     target->ensureIntersectionObserverData().addObservation(*observation);
     m_observations.add(observation);
 }
 
-void IntersectionObserver::unobserve(Element* target, ExceptionState&)
+void IntersectionObserver::unobserve(Element* target)
 {
     if (!target || !target->intersectionObserverData())
         return;
     // TODO(szager): unobserve callback
     if (IntersectionObservation* observation = target->intersectionObserverData()->getObservationFor(*this))
         observation->disconnect();
 }
 
 void IntersectionObserver::computeIntersectionObservations()
 {
@@ skipping 25 matching lines @@
 HeapVector<Member<IntersectionObserverEntry>> IntersectionObserver::takeRecords()
 {
     HeapVector<Member<IntersectionObserverEntry>> entries;
     entries.swap(m_entries);
     return entries;
 }
 
 Element* IntersectionObserver::root() const
 {
     Node* node = rootNode();
-    if (node->isDocumentNode())
-        return nullptr;
-    return toElement(node);
+    if (node && !node->isDocumentNode())
+        return toElement(node);
+    return nullptr;
 }
 
 static void appendLength(StringBuilder& stringBuilder, const Length& length)
 {
     stringBuilder.appendNumber(length.intValue());
     if (length.type() == Percent)
         stringBuilder.append('%');
     else
         stringBuilder.append("px", 2);
 }
@@ skipping 78 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->template registerWeakMembers<IntersectionObserver, &IntersectionObserver::clearWeakMembers>(this);
 #endif
     visitor->trace(m_callback);
     visitor->trace(m_observations);
     visitor->trace(m_entries);
 }
 
 } // namespace blink