Add m-esr52 at 52.6.0

1 files changed, 730 insertions, 0 deletions

diff --git a/dom/smil/nsSMILParserUtils.cpp b/dom/smil/nsSMILParserUtils.cpp
new file mode 100644
index 000000000..9174bdd4a
--- /dev/null
+++ b/dom/smil/nsSMILParserUtils.cpp
@@ -0,0 +1,730 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsSMILParserUtils.h"
+#include "nsSMILKeySpline.h"
+#include "nsISMILAttr.h"
+#include "nsSMILValue.h"
+#include "nsSMILTimeValue.h"
+#include "nsSMILTimeValueSpecParams.h"
+#include "nsSMILTypes.h"
+#include "nsSMILRepeatCount.h"
+#include "nsContentUtils.h"
+#include "nsCharSeparatedTokenizer.h"
+#include "SVGContentUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+//------------------------------------------------------------------------------
+// Helper functions and Constants
+
+namespace {
+
+const uint32_t MSEC_PER_SEC  = 1000;
+const uint32_t MSEC_PER_MIN  = 1000 * 60;
+const uint32_t MSEC_PER_HOUR = 1000 * 60 * 60;
+
+#define ACCESSKEY_PREFIX_LC NS_LITERAL_STRING("accesskey(") // SMIL2+
+#define ACCESSKEY_PREFIX_CC NS_LITERAL_STRING("accessKey(") // SVG/SMIL ANIM
+#define REPEAT_PREFIX    NS_LITERAL_STRING("repeat(")
+#define WALLCLOCK_PREFIX NS_LITERAL_STRING("wallclock(")
+
+inline bool
+SkipWhitespace(RangedPtr<const char16_t>& aIter,
+               const RangedPtr<const char16_t>& aEnd)
+{
+  while (aIter != aEnd) {
+    if (!IsSVGWhitespace(*aIter)) {
+      return true;
+    }
+    ++aIter;
+  }
+  return false;
+}
+
+inline bool
+ParseColon(RangedPtr<const char16_t>& aIter,
+           const RangedPtr<const char16_t>& aEnd)
+{
+  if (aIter == aEnd || *aIter != ':') {
+    return false;
+  }
+  ++aIter;
+  return true;
+}
+
+/*
+ * Exactly two digits in the range 00 - 59 are expected.
+ */
+bool
+ParseSecondsOrMinutes(RangedPtr<const char16_t>& aIter,
+                      const RangedPtr<const char16_t>& aEnd,
+                      uint32_t& aValue)
+{
+  if (aIter == aEnd || !SVGContentUtils::IsDigit(*aIter)) {
+    return false;
+  }
+
+  RangedPtr<const char16_t> iter(aIter);
+
+  if (++iter == aEnd || !SVGContentUtils::IsDigit(*iter)) {
+     return false;
+  }
+
+  uint32_t value = 10 * SVGContentUtils::DecimalDigitValue(*aIter) +
+                   SVGContentUtils::DecimalDigitValue(*iter);
+  if (value > 59) {
+    return false;
+  }
+  if (++iter != aEnd && SVGContentUtils::IsDigit(*iter)) {
+    return false;
+  }
+
+  aValue = value;
+  aIter = iter;
+  return true;
+}
+
+inline bool
+ParseClockMetric(RangedPtr<const char16_t>& aIter,
+                 const RangedPtr<const char16_t>& aEnd,
+                 uint32_t& aMultiplier)
+{
+  if (aIter == aEnd) {
+    aMultiplier = MSEC_PER_SEC;
+    return true;
+  }
+
+  switch (*aIter) {
+  case 'h':
+    if (++aIter == aEnd) {
+      aMultiplier = MSEC_PER_HOUR;
+      return true;
+    }
+    return false;
+  case 'm':
+    {
+      const nsAString& metric = Substring(aIter.get(), aEnd.get());
+      if (metric.EqualsLiteral("min")) {
+        aMultiplier = MSEC_PER_MIN;
+        aIter = aEnd;
+        return true;
+      }
+      if (metric.EqualsLiteral("ms")) {
+        aMultiplier = 1;
+        aIter = aEnd;
+        return true;
+      }
+    }
+    return false;
+  case 's':
+    if (++aIter == aEnd) {
+      aMultiplier = MSEC_PER_SEC;
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * See http://www.w3.org/TR/SVG/animate.html#ClockValueSyntax
+ */
+bool
+ParseClockValue(RangedPtr<const char16_t>& aIter,
+                const RangedPtr<const char16_t>& aEnd,
+                nsSMILTimeValue* aResult)
+{
+  if (aIter == aEnd) {
+    return false;
+  }
+
+  // TIMECOUNT_VALUE     ::= Timecount ("." Fraction)? (Metric)?
+  // PARTIAL_CLOCK_VALUE ::= Minutes ":" Seconds ("." Fraction)?
+  // FULL_CLOCK_VALUE    ::= Hours ":" Minutes ":" Seconds ("." Fraction)?
+  enum ClockType {
+    TIMECOUNT_VALUE,
+    PARTIAL_CLOCK_VALUE,
+    FULL_CLOCK_VALUE
+  };
+
+  int32_t clockType = TIMECOUNT_VALUE;
+
+  RangedPtr<const char16_t> iter(aIter);
+
+  // Determine which type of clock value we have by counting the number
+  // of colons in the string.
+  do {
+    switch (*iter) {
+    case ':':
+       if (clockType == FULL_CLOCK_VALUE) {
+         return false;
+       }
+       ++clockType;
+       break;
+    case 'e':
+    case 'E':
+    case '-':
+    case '+':
+      // Exclude anything invalid (for clock values)
+      // that number parsing might otherwise allow.
+      return false;
+    }
+    ++iter;
+  } while (iter != aEnd);
+
+  iter = aIter;
+
+  int32_t hours = 0, timecount;
+  double fraction = 0.0;
+  uint32_t minutes, seconds, multiplier;
+
+  switch (clockType) {
+    case FULL_CLOCK_VALUE:
+      if (!SVGContentUtils::ParseInteger(iter, aEnd, hours) ||
+          !ParseColon(iter, aEnd)) {
+        return false;
+      }
+      MOZ_FALLTHROUGH;
+    case PARTIAL_CLOCK_VALUE:
+      if (!ParseSecondsOrMinutes(iter, aEnd, minutes) ||
+          !ParseColon(iter, aEnd) ||
+          !ParseSecondsOrMinutes(iter, aEnd, seconds)) {
+        return false;
+      }
+      if (iter != aEnd &&
+          (*iter != '.' ||
+           !SVGContentUtils::ParseNumber(iter, aEnd, fraction))) {
+        return false;
+      }
+      aResult->SetMillis(nsSMILTime(hours) * MSEC_PER_HOUR +
+                         minutes * MSEC_PER_MIN +
+                         seconds * MSEC_PER_SEC +
+                         NS_round(fraction * MSEC_PER_SEC));
+      aIter = iter;
+      return true;
+    case TIMECOUNT_VALUE:
+      if (!SVGContentUtils::ParseInteger(iter, aEnd, timecount)) {
+        return false;
+      }
+      if (iter != aEnd && *iter == '.' &&
+          !SVGContentUtils::ParseNumber(iter, aEnd, fraction)) {
+        return false;
+      }
+      if (!ParseClockMetric(iter, aEnd, multiplier)) {
+        return false;
+      }
+      aResult->SetMillis(nsSMILTime(timecount) * multiplier +
+                         NS_round(fraction * multiplier));
+      aIter = iter;
+      return true;
+  }
+
+  return false;
+}
+
+bool
+ParseOffsetValue(RangedPtr<const char16_t>& aIter,
+                 const RangedPtr<const char16_t>& aEnd,
+                 nsSMILTimeValue* aResult)
+{
+  RangedPtr<const char16_t> iter(aIter);
+
+  int32_t sign;
+  if (!SVGContentUtils::ParseOptionalSign(iter, aEnd, sign) ||
+      !SkipWhitespace(iter, aEnd) ||
+      !ParseClockValue(iter, aEnd, aResult)) {
+    return false;
+  }
+  if (sign == -1) {
+    aResult->SetMillis(-aResult->GetMillis());
+  }
+  aIter = iter;
+  return true;
+}
+
+bool
+ParseOffsetValue(const nsAString& aSpec,
+                 nsSMILTimeValue* aResult)
+{
+  RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
+  const RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
+
+  return ParseOffsetValue(iter, end, aResult) && iter == end;
+}
+
+bool
+ParseOptionalOffset(RangedPtr<const char16_t>& aIter,
+                    const RangedPtr<const char16_t>& aEnd,
+                    nsSMILTimeValue* aResult)
+{
+  if (aIter == aEnd) {
+    aResult->SetMillis(0L);
+    return true;
+  }
+
+  return SkipWhitespace(aIter, aEnd) &&
+         ParseOffsetValue(aIter, aEnd, aResult);
+}
+
+bool
+ParseAccessKey(const nsAString& aSpec, nsSMILTimeValueSpecParams& aResult)
+{
+  MOZ_ASSERT(StringBeginsWith(aSpec, ACCESSKEY_PREFIX_CC) ||
+             StringBeginsWith(aSpec, ACCESSKEY_PREFIX_LC),
+             "Calling ParseAccessKey on non-accesskey-type spec");
+
+  nsSMILTimeValueSpecParams result;
+  result.mType = nsSMILTimeValueSpecParams::ACCESSKEY;
+
+  MOZ_ASSERT(ACCESSKEY_PREFIX_LC.Length() == ACCESSKEY_PREFIX_CC.Length(),
+             "Case variations for accesskey prefix differ in length");
+
+  RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
+  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
+
+  iter += ACCESSKEY_PREFIX_LC.Length();
+
+  // Expecting at least <accesskey> + ')'
+  if (end - iter < 2)
+    return false;
+
+  uint32_t c = *iter++;
+
+  // Process 32-bit codepoints
+  if (NS_IS_HIGH_SURROGATE(c)) {
+    if (end - iter < 2) // Expecting at least low-surrogate + ')'
+      return false;
+    uint32_t lo = *iter++;
+    if (!NS_IS_LOW_SURROGATE(lo))
+      return false;
+    c = SURROGATE_TO_UCS4(c, lo);
+  // XML 1.1 says that 0xFFFE and 0xFFFF are not valid characters
+  } else if (NS_IS_LOW_SURROGATE(c) || c == 0xFFFE || c == 0xFFFF) {
+    return false;
+  }
+
+  result.mRepeatIterationOrAccessKey = c;
+
+  if (*iter++ != ')')
+    return false;
+
+  if (!ParseOptionalOffset(iter, end, &result.mOffset) || iter != end) {
+    return false;
+  }
+  aResult = result;
+  return true;
+}
+
+void
+MoveToNextToken(RangedPtr<const char16_t>& aIter,
+                const RangedPtr<const char16_t>& aEnd,
+                bool aBreakOnDot,
+                bool& aIsAnyCharEscaped)
+{
+  aIsAnyCharEscaped = false;
+
+  bool isCurrentCharEscaped = false;
+
+  while (aIter != aEnd && !IsSVGWhitespace(*aIter)) {
+    if (isCurrentCharEscaped) {
+      isCurrentCharEscaped = false;
+    } else {
+      if (*aIter == '+' || *aIter == '-' ||
+          (aBreakOnDot && *aIter == '.')) {
+        break;
+      }
+      if (*aIter == '\\') {
+        isCurrentCharEscaped = true;
+        aIsAnyCharEscaped = true;
+      }
+    }
+    ++aIter;
+  }
+}
+
+already_AddRefed<nsIAtom>
+ConvertUnescapedTokenToAtom(const nsAString& aToken)
+{
+  // Whether the token is an id-ref or event-symbol it should be a valid NCName
+  if (aToken.IsEmpty() || NS_FAILED(nsContentUtils::CheckQName(aToken, false)))
+    return nullptr;
+  return NS_Atomize(aToken);
+}
+    
+already_AddRefed<nsIAtom>
+ConvertTokenToAtom(const nsAString& aToken,
+                   bool aUnescapeToken)
+{
+  // Unescaping involves making a copy of the string which we'd like to avoid if possible
+  if (!aUnescapeToken) {
+    return ConvertUnescapedTokenToAtom(aToken);
+  }
+
+  nsAutoString token(aToken);
+
+  const char16_t* read = token.BeginReading();
+  const char16_t* const end = token.EndReading();
+  char16_t* write = token.BeginWriting();
+  bool escape = false;
+
+  while (read != end) {
+    MOZ_ASSERT(write <= read, "Writing past where we've read");
+    if (!escape && *read == '\\') {
+      escape = true;
+      ++read;
+    } else {
+      *write++ = *read++;
+      escape = false;
+    }
+  }
+  token.Truncate(write - token.BeginReading());
+
+  return ConvertUnescapedTokenToAtom(token);
+}
+
+bool
+ParseElementBaseTimeValueSpec(const nsAString& aSpec,
+                              nsSMILTimeValueSpecParams& aResult)
+{
+  nsSMILTimeValueSpecParams result;
+
+  //
+  // The spec will probably look something like one of these
+  //
+  // element-name.begin
+  // element-name.event-name
+  // event-name
+  // element-name.repeat(3)
+  // event\.name
+  //
+  // Technically `repeat(3)' is permitted but the behaviour in this case is not
+  // defined (for SMIL Animation) so we don't support it here.
+  //
+
+  RangedPtr<const char16_t> start(SVGContentUtils::GetStartRangedPtr(aSpec));
+  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
+
+  if (start == end) {
+    return false;
+  }
+
+  RangedPtr<const char16_t> tokenEnd(start);
+
+  bool requiresUnescaping;
+  MoveToNextToken(tokenEnd, end, true, requiresUnescaping);
+
+  RefPtr<nsIAtom> atom =
+    ConvertTokenToAtom(Substring(start.get(), tokenEnd.get()),
+                       requiresUnescaping);
+  if (atom == nullptr) {
+    return false;
+  }
+
+  // Parse the second token if there is one
+  if (tokenEnd != end && *tokenEnd == '.') {
+    result.mDependentElemID = atom;
+
+    ++tokenEnd;
+    start = tokenEnd;
+    MoveToNextToken(tokenEnd, end, false, requiresUnescaping);
+
+    const nsAString& token2 = Substring(start.get(), tokenEnd.get());
+
+    // element-name.begin
+    if (token2.EqualsLiteral("begin")) {
+      result.mType = nsSMILTimeValueSpecParams::SYNCBASE;
+      result.mSyncBegin = true;
+    // element-name.end
+    } else if (token2.EqualsLiteral("end")) {
+      result.mType = nsSMILTimeValueSpecParams::SYNCBASE;
+      result.mSyncBegin = false;
+    // element-name.repeat(digit+)
+    } else if (StringBeginsWith(token2, REPEAT_PREFIX)) {
+      start += REPEAT_PREFIX.Length();
+      int32_t repeatValue;
+      if (start == tokenEnd || *start == '+' || *start == '-' ||
+          !SVGContentUtils::ParseInteger(start, tokenEnd, repeatValue)) {
+        return false;
+      }
+      if (start == tokenEnd || *start != ')') {
+        return false;
+      }
+      result.mType = nsSMILTimeValueSpecParams::REPEAT;
+      result.mRepeatIterationOrAccessKey = repeatValue;
+    // element-name.event-symbol
+    } else {
+      atom = ConvertTokenToAtom(token2, requiresUnescaping);
+      if (atom == nullptr) {
+        return false;
+      }
+      result.mType = nsSMILTimeValueSpecParams::EVENT;
+      result.mEventSymbol = atom;
+    }
+  } else {
+    // event-symbol
+    result.mType = nsSMILTimeValueSpecParams::EVENT;
+    result.mEventSymbol = atom;
+  }
+
+  // We've reached the end of the token, so we should now be either looking at
+  // a '+', '-' (possibly with whitespace before it), or the end.
+  if (!ParseOptionalOffset(tokenEnd, end, &result.mOffset) || tokenEnd != end) {
+    return false;
+  }
+  aResult = result;
+  return true;
+}
+
+} // namespace
+
+//------------------------------------------------------------------------------
+// Implementation
+
+const nsDependentSubstring
+nsSMILParserUtils::TrimWhitespace(const nsAString& aString)
+{
+  nsAString::const_iterator start, end;
+
+  aString.BeginReading(start);
+  aString.EndReading(end);
+
+  // Skip whitespace characters at the beginning
+  while (start != end && IsSVGWhitespace(*start)) {
+    ++start;
+  }
+
+  // Skip whitespace characters at the end.
+  while (end != start) {
+    --end;
+
+    if (!IsSVGWhitespace(*end)) {
+      // Step back to the last non-whitespace character.
+      ++end;
+
+      break;
+    }
+  }
+
+  return Substring(start, end);
+}
+
+bool
+nsSMILParserUtils::ParseKeySplines(const nsAString& aSpec,
+                                   FallibleTArray<nsSMILKeySpline>& aKeySplines)
+{
+  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> controlPointTokenizer(aSpec, ';');
+  while (controlPointTokenizer.hasMoreTokens()) {
+
+    nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> 
+      tokenizer(controlPointTokenizer.nextToken(), ',',
+                nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);
+
+    double values[4];
+    for (int i = 0 ; i < 4; i++) {
+      if (!tokenizer.hasMoreTokens() ||
+          !SVGContentUtils::ParseNumber(tokenizer.nextToken(), values[i]) ||
+          values[i] > 1.0 || values[i] < 0.0) {
+        return false;
+      }
+    }
+    if (tokenizer.hasMoreTokens() ||
+        tokenizer.separatorAfterCurrentToken() ||
+        !aKeySplines.AppendElement(nsSMILKeySpline(values[0],
+                                                   values[1],
+                                                   values[2],
+                                                   values[3]),
+                                   fallible)) {
+      return false;
+    }
+  }
+
+  return !aKeySplines.IsEmpty();
+}
+
+bool
+nsSMILParserUtils::ParseSemicolonDelimitedProgressList(const nsAString& aSpec,
+                                                       bool aNonDecreasing,
+                                                       FallibleTArray<double>& aArray)
+{
+  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> tokenizer(aSpec, ';');
+
+  double previousValue = -1.0;
+
+  while (tokenizer.hasMoreTokens()) {
+    double value;
+    if (!SVGContentUtils::ParseNumber(tokenizer.nextToken(), value)) {
+      return false;
+    }
+
+    if (value > 1.0 || value < 0.0 ||
+        (aNonDecreasing && value < previousValue)) {
+      return false;
+    }
+
+    if (!aArray.AppendElement(value, fallible)) {
+      return false;
+    }
+    previousValue = value;
+  }
+
+  return !aArray.IsEmpty();
+}
+
+// Helper class for ParseValues
+class MOZ_STACK_CLASS SMILValueParser :
+  public nsSMILParserUtils::GenericValueParser
+{
+public:
+  SMILValueParser(const SVGAnimationElement* aSrcElement,
+                  const nsISMILAttr* aSMILAttr,
+                  FallibleTArray<nsSMILValue>* aValuesArray,
+                  bool* aPreventCachingOfSandwich) :
+    mSrcElement(aSrcElement),
+    mSMILAttr(aSMILAttr),
+    mValuesArray(aValuesArray),
+    mPreventCachingOfSandwich(aPreventCachingOfSandwich)
+  {}
+
+  virtual bool Parse(const nsAString& aValueStr) override {
+    nsSMILValue newValue;
+    bool tmpPreventCachingOfSandwich = false;
+    if (NS_FAILED(mSMILAttr->ValueFromString(aValueStr, mSrcElement, newValue,
+                                             tmpPreventCachingOfSandwich)))
+      return false;
+
+    if (!mValuesArray->AppendElement(newValue, fallible)) {
+      return false;
+    }
+    if (tmpPreventCachingOfSandwich) {
+      *mPreventCachingOfSandwich = true;
+    }
+    return true;
+  }
+protected:
+  const SVGAnimationElement* mSrcElement;
+  const nsISMILAttr* mSMILAttr;
+  FallibleTArray<nsSMILValue>* mValuesArray;
+  bool* mPreventCachingOfSandwich;
+};
+
+bool
+nsSMILParserUtils::ParseValues(const nsAString& aSpec,
+                               const SVGAnimationElement* aSrcElement,
+                               const nsISMILAttr& aAttribute,
+                               FallibleTArray<nsSMILValue>& aValuesArray,
+                               bool& aPreventCachingOfSandwich)
+{
+  // Assume all results can be cached, until we find one that can't.
+  aPreventCachingOfSandwich = false;
+  SMILValueParser valueParser(aSrcElement, &aAttribute,
+                              &aValuesArray, &aPreventCachingOfSandwich);
+  return ParseValuesGeneric(aSpec, valueParser);
+}
+
+bool
+nsSMILParserUtils::ParseValuesGeneric(const nsAString& aSpec,
+                                      GenericValueParser& aParser)
+{
+  nsCharSeparatedTokenizerTemplate<IsSVGWhitespace> tokenizer(aSpec, ';');
+  if (!tokenizer.hasMoreTokens()) { // Empty list
+    return false;
+  }
+
+  while (tokenizer.hasMoreTokens()) {
+    if (!aParser.Parse(tokenizer.nextToken())) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool
+nsSMILParserUtils::ParseRepeatCount(const nsAString& aSpec,
+                                    nsSMILRepeatCount& aResult)
+{
+  const nsAString& spec =
+    nsSMILParserUtils::TrimWhitespace(aSpec);
+
+  if (spec.EqualsLiteral("indefinite")) {
+    aResult.SetIndefinite();
+    return true;
+  }
+
+  double value;
+  if (!SVGContentUtils::ParseNumber(spec, value) || value <= 0.0) {
+    return false;
+  }
+  aResult = value;
+  return true;
+}
+
+bool
+nsSMILParserUtils::ParseTimeValueSpecParams(const nsAString& aSpec,
+                                            nsSMILTimeValueSpecParams& aResult)
+{
+  const nsAString& spec = TrimWhitespace(aSpec);
+
+  if (spec.EqualsLiteral("indefinite")) {
+     aResult.mType = nsSMILTimeValueSpecParams::INDEFINITE;
+     return true;
+  }
+  
+  // offset type
+  if (ParseOffsetValue(spec, &aResult.mOffset)) {
+    aResult.mType = nsSMILTimeValueSpecParams::OFFSET;
+    return true;
+  }
+
+  // wallclock type
+  if (StringBeginsWith(spec, WALLCLOCK_PREFIX)) {
+    return false; // Wallclock times not implemented
+  }
+
+  // accesskey type
+  if (StringBeginsWith(spec, ACCESSKEY_PREFIX_LC) ||
+      StringBeginsWith(spec, ACCESSKEY_PREFIX_CC)) {
+    return ParseAccessKey(spec, aResult);
+  }
+
+  // event, syncbase, or repeat
+  return ParseElementBaseTimeValueSpec(spec, aResult);
+}
+
+bool
+nsSMILParserUtils::ParseClockValue(const nsAString& aSpec,
+                                   nsSMILTimeValue* aResult)
+{
+  RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));
+  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));
+
+  return ::ParseClockValue(iter, end, aResult) && iter == end;
+}
+
+int32_t
+nsSMILParserUtils::CheckForNegativeNumber(const nsAString& aStr)
+{
+  int32_t absValLocation = -1;
+
+  RangedPtr<const char16_t> start(SVGContentUtils::GetStartRangedPtr(aStr));
+  RangedPtr<const char16_t> iter = start;
+  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aStr));
+
+  // Skip initial whitespace
+  while (iter != end && IsSVGWhitespace(*iter)) {
+    ++iter;
+  }
+
+  // Check for dash
+  if (iter != end && *iter == '-') {
+    ++iter;
+    // Check for numeric character
+    if (iter != end && SVGContentUtils::IsDigit(*iter)) {
+      absValLocation = iter - start;
+    }
+  }
+  return absValLocation;
+}