Bug 1332639 followup. I apparently didn't actually remove the nsStringAPI.* files, but that was the intention, r=oops
authorBenjamin Smedberg <benjamin@smedbergs.us>
Thu, 02 Mar 2017 09:23:08 -0500
changeset 394599 d60dce18350aa8a8a7932d949cd0fcf8ae5722c0
parent 394598 c385308aa7722dbc787b6c54bd623f3ff1b3e8f9
child 394600 d9a06d9da18bbbe51eaf98bcdd978c89ced5362c
push id1468
push userasasaki@mozilla.com
push dateMon, 05 Jun 2017 19:31:07 +0000
treeherdermozilla-release@0641fc6ee9d1 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersoops
bugs1332639
milestone54.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1332639 followup. I apparently didn't actually remove the nsStringAPI.* files, but that was the intention, r=oops MozReview-Commit-ID: GJBNWAmO6iy
xpcom/glue/nsStringAPI.cpp
xpcom/glue/nsStringAPI.h
xpcom/string/nsTSubstring.h
deleted file mode 100644
--- a/xpcom/glue/nsStringAPI.cpp
+++ /dev/null
@@ -1,1340 +0,0 @@
-/* -*- 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 "nscore.h"
-#include "nsCRTGlue.h"
-#include "prprf.h"
-#include "nsStringAPI.h"
-#include "nsXPCOMStrings.h"
-#include "nsDebug.h"
-
-#include "mozilla/Sprintf.h"
-
-#include <stdio.h>
-
-// nsAString
-
-uint32_t
-nsAString::BeginReading(const char_type** aBegin, const char_type** aEnd) const
-{
-  uint32_t len = NS_StringGetData(*this, aBegin);
-  if (aEnd) {
-    *aEnd = *aBegin + len;
-  }
-
-  return len;
-}
-
-const nsAString::char_type*
-nsAString::BeginReading() const
-{
-  const char_type* data;
-  NS_StringGetData(*this, &data);
-  return data;
-}
-
-const nsAString::char_type*
-nsAString::EndReading() const
-{
-  const char_type* data;
-  uint32_t len = NS_StringGetData(*this, &data);
-  return data + len;
-}
-
-uint32_t
-nsAString::BeginWriting(char_type** aBegin, char_type** aEnd, uint32_t aNewSize)
-{
-  uint32_t len = NS_StringGetMutableData(*this, aNewSize, aBegin);
-  if (aEnd) {
-    *aEnd = *aBegin + len;
-  }
-
-  return len;
-}
-
-nsAString::char_type*
-nsAString::BeginWriting(uint32_t aLen)
-{
-  char_type* data;
-  NS_StringGetMutableData(*this, aLen, &data);
-  return data;
-}
-
-nsAString::char_type*
-nsAString::EndWriting()
-{
-  char_type* data;
-  uint32_t len = NS_StringGetMutableData(*this, UINT32_MAX, &data);
-  return data + len;
-}
-
-bool
-nsAString::SetLength(uint32_t aLen)
-{
-  char_type* data;
-  NS_StringGetMutableData(*this, aLen, &data);
-  return data != nullptr;
-}
-
-void
-nsAString::AssignLiteral(const char* aStr)
-{
-  uint32_t len = strlen(aStr);
-  char16_t* buf = BeginWriting(len);
-  if (!buf) {
-    return;
-  }
-
-  for (; *aStr; ++aStr, ++buf) {
-    *buf = *aStr;
-  }
-}
-
-void
-nsAString::AppendLiteral(const char* aASCIIStr)
-{
-  uint32_t appendLen = strlen(aASCIIStr);
-
-  uint32_t thisLen = Length();
-  char16_t* begin;
-  char16_t* end;
-  BeginWriting(&begin, &end, appendLen + thisLen);
-  if (!begin) {
-    return;
-  }
-
-  for (begin += thisLen; begin < end; ++begin, ++aASCIIStr) {
-    *begin = *aASCIIStr;
-  }
-}
-
-void
-nsAString::StripChars(const char* aSet)
-{
-  nsString copy(*this);
-
-  const char_type* source;
-  const char_type* sourceEnd;
-  copy.BeginReading(&source, &sourceEnd);
-
-  char_type* dest;
-  BeginWriting(&dest);
-  if (!dest) {
-    return;
-  }
-
-  char_type* curDest = dest;
-
-  for (; source < sourceEnd; ++source) {
-    const char* test;
-    for (test = aSet; *test; ++test) {
-      if (*source == char_type(*test)) {
-        break;
-      }
-    }
-
-    if (!*test) {
-      // not stripped, copy this char
-      *curDest = *source;
-      ++curDest;
-    }
-  }
-
-  SetLength(curDest - dest);
-}
-
-void
-nsAString::Trim(const char* aSet, bool aLeading, bool aTrailing)
-{
-  NS_ASSERTION(aLeading || aTrailing, "Ineffective Trim");
-
-  const char16_t* start;
-  const char16_t* end;
-  uint32_t cutLen;
-
-  if (aLeading) {
-    BeginReading(&start, &end);
-    for (cutLen = 0; start < end; ++start, ++cutLen) {
-      const char* test;
-      for (test = aSet; *test; ++test) {
-        if (*test == *start) {
-          break;
-        }
-      }
-      if (!*test) {
-        break;
-      }
-    }
-    if (cutLen) {
-      NS_StringCutData(*this, 0, cutLen);
-    }
-  }
-  if (aTrailing) {
-    uint32_t len = BeginReading(&start, &end);
-    --end;
-    for (cutLen = 0; end >= start; --end, ++cutLen) {
-      const char* test;
-      for (test = aSet; *test; ++test) {
-        if (*test == *end) {
-          break;
-        }
-      }
-      if (!*test) {
-        break;
-      }
-    }
-    if (cutLen) {
-      NS_StringCutData(*this, len - cutLen, cutLen);
-    }
-  }
-}
-
-int32_t
-nsAString::DefaultComparator(const char_type* aStrA, const char_type* aStrB,
-                             uint32_t aLen)
-{
-  for (const char_type* end = aStrA + aLen; aStrA < end; ++aStrA, ++aStrB) {
-    if (*aStrA == *aStrB) {
-      continue;
-    }
-
-    return *aStrA < *aStrB ? -1 : 1;
-  }
-
-  return 0;
-}
-
-int32_t
-nsAString::Compare(const char_type* aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  uint32_t selflen = NS_StringGetData(*this, &cself);
-  uint32_t otherlen = NS_strlen(aOther);
-  uint32_t comparelen = selflen <= otherlen ? selflen : otherlen;
-
-  int32_t result = aComparator(cself, aOther, comparelen);
-  if (result == 0) {
-    if (selflen < otherlen) {
-      return -1;
-    }
-    if (selflen > otherlen) {
-      return 1;
-    }
-  }
-  return result;
-}
-
-int32_t
-nsAString::Compare(const self_type& aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  const char_type* cother;
-  uint32_t selflen = NS_StringGetData(*this, &cself);
-  uint32_t otherlen = NS_StringGetData(aOther, &cother);
-  uint32_t comparelen = selflen <= otherlen ? selflen : otherlen;
-
-  int32_t result = aComparator(cself, cother, comparelen);
-  if (result == 0) {
-    if (selflen < otherlen) {
-      return -1;
-    }
-    if (selflen > otherlen) {
-      return 1;
-    }
-  }
-  return result;
-}
-
-bool
-nsAString::Equals(const char_type* aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  uint32_t selflen = NS_StringGetData(*this, &cself);
-  uint32_t otherlen = NS_strlen(aOther);
-
-  if (selflen != otherlen) {
-    return false;
-  }
-
-  return aComparator(cself, aOther, selflen) == 0;
-}
-
-bool
-nsAString::Equals(const self_type& aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  const char_type* cother;
-  uint32_t selflen = NS_StringGetData(*this, &cself);
-  uint32_t otherlen = NS_StringGetData(aOther, &cother);
-
-  if (selflen != otherlen) {
-    return false;
-  }
-
-  return aComparator(cself, cother, selflen) == 0;
-}
-
-bool
-nsAString::EqualsLiteral(const char* aASCIIString) const
-{
-  const char16_t* begin;
-  const char16_t* end;
-  BeginReading(&begin, &end);
-
-  for (; begin < end; ++begin, ++aASCIIString) {
-    if (!*aASCIIString || !NS_IsAscii(*begin) ||
-        (char)*begin != *aASCIIString) {
-      return false;
-    }
-  }
-
-  return *aASCIIString == '\0';
-}
-
-bool
-nsAString::LowerCaseEqualsLiteral(const char* aASCIIString) const
-{
-  const char16_t* begin;
-  const char16_t* end;
-  BeginReading(&begin, &end);
-
-  for (; begin < end; ++begin, ++aASCIIString) {
-    if (!*aASCIIString || !NS_IsAscii(*begin) ||
-        NS_ToLower((char)*begin) != *aASCIIString) {
-      return false;
-    }
-  }
-
-  return *aASCIIString == '\0';
-}
-
-int32_t
-nsAString::Find(const self_type& aStr, uint32_t aOffset,
-                ComparatorFunc aComparator) const
-{
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  if (aOffset > selflen) {
-    return -1;
-  }
-
-  const char_type* other;
-  uint32_t otherlen = aStr.BeginReading(&other);
-
-  if (otherlen > selflen - aOffset) {
-    return -1;
-  }
-
-  // We want to stop searching otherlen characters before the end of the string
-  end -= otherlen;
-
-  for (const char_type* cur = begin + aOffset; cur <= end; ++cur) {
-    if (!aComparator(cur, other, otherlen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-static bool
-ns_strnmatch(const char16_t* aStr, const char* aSubstring, uint32_t aLen)
-{
-  for (; aLen; ++aStr, ++aSubstring, --aLen) {
-    if (!NS_IsAscii(*aStr)) {
-      return false;
-    }
-
-    if ((char)*aStr != *aSubstring) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-static bool
-ns_strnimatch(const char16_t* aStr, const char* aSubstring, uint32_t aLen)
-{
-  for (; aLen; ++aStr, ++aSubstring, --aLen) {
-    if (!NS_IsAscii(*aStr)) {
-      return false;
-    }
-
-    if (NS_ToLower((char)*aStr) != NS_ToLower(*aSubstring)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-int32_t
-nsAString::Find(const char* aStr, uint32_t aOffset, bool aIgnoreCase) const
-{
-  bool (*match)(const char16_t*, const char*, uint32_t) =
-    aIgnoreCase ? ns_strnimatch : ns_strnmatch;
-
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  if (aOffset > selflen) {
-    return -1;
-  }
-
-  uint32_t otherlen = strlen(aStr);
-
-  if (otherlen > selflen - aOffset) {
-    return -1;
-  }
-
-  // We want to stop searching otherlen characters before the end of the string
-  end -= otherlen;
-
-  for (const char_type* cur = begin + aOffset; cur <= end; ++cur) {
-    if (match(cur, aStr, otherlen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsAString::RFind(const self_type& aStr, int32_t aOffset,
-                 ComparatorFunc aComparator) const
-{
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  const char_type* other;
-  uint32_t otherlen = aStr.BeginReading(&other);
-
-  if (selflen < otherlen) {
-    return -1;
-  }
-
-  if (aOffset < 0 || uint32_t(aOffset) > (selflen - otherlen)) {
-    end -= otherlen;
-  } else {
-    end = begin + aOffset;
-  }
-
-  for (const char_type* cur = end; cur >= begin; --cur) {
-    if (!aComparator(cur, other, otherlen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsAString::RFind(const char* aStr, int32_t aOffset, bool aIgnoreCase) const
-{
-  bool (*match)(const char16_t*, const char*, uint32_t) =
-    aIgnoreCase ? ns_strnimatch : ns_strnmatch;
-
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-  uint32_t otherlen = strlen(aStr);
-
-  if (selflen < otherlen) {
-    return -1;
-  }
-
-  if (aOffset < 0 || uint32_t(aOffset) > (selflen - otherlen)) {
-    end -= otherlen;
-  } else {
-    end = begin + aOffset;
-  }
-
-  for (const char_type* cur = end; cur >= begin; --cur) {
-    if (match(cur, aStr, otherlen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsAString::FindChar(char_type aChar, uint32_t aOffset) const
-{
-  const char_type* start;
-  const char_type* end;
-  uint32_t len = BeginReading(&start, &end);
-  if (aOffset > len) {
-    return -1;
-  }
-
-  const char_type* cur;
-
-  for (cur = start + aOffset; cur < end; ++cur) {
-    if (*cur == aChar) {
-      return cur - start;
-    }
-  }
-
-  return -1;
-}
-
-int32_t
-nsAString::RFindChar(char_type aChar) const
-{
-  const char16_t* start;
-  const char16_t* end;
-  BeginReading(&start, &end);
-
-  do {
-    --end;
-
-    if (*end == aChar) {
-      return end - start;
-    }
-
-  } while (end >= start);
-
-  return -1;
-}
-
-void
-nsAString::AppendInt(int aInt, int32_t aRadix)
-{
-  const char* fmt;
-  switch (aRadix) {
-    case 8:
-      fmt = "%o";
-      break;
-
-    case 10:
-      fmt = "%d";
-      break;
-
-    case 16:
-      fmt = "%x";
-      break;
-
-    default:
-      NS_ERROR("Unrecognized radix");
-      fmt = "";
-  }
-
-  char buf[20];
-  int len = SprintfLiteral(buf, fmt, aInt);
-  Append(NS_ConvertASCIItoUTF16(buf, len));
-}
-
-// Strings
-
-#ifndef XPCOM_GLUE_AVOID_NSPR
-int32_t
-nsAString::ToInteger(nsresult* aErrorCode, uint32_t aRadix) const
-{
-  NS_ConvertUTF16toUTF8 narrow(*this);
-
-  const char* fmt;
-  switch (aRadix) {
-    case 10:
-      fmt = "%i";
-      break;
-
-    case 16:
-      fmt = "%x";
-      break;
-
-    default:
-      NS_ERROR("Unrecognized radix!");
-      *aErrorCode = NS_ERROR_INVALID_ARG;
-      return 0;
-  }
-
-  int32_t result = 0;
-  if (PR_sscanf(narrow.get(), fmt, &result) == 1) {
-    *aErrorCode = NS_OK;
-  } else {
-    *aErrorCode = NS_ERROR_FAILURE;
-  }
-
-  return result;
-}
-
-int64_t
-nsAString::ToInteger64(nsresult* aErrorCode, uint32_t aRadix) const
-{
-  NS_ConvertUTF16toUTF8 narrow(*this);
-
-  const char* fmt;
-  switch (aRadix) {
-    case 10:
-      fmt = "%lli";
-      break;
-
-    case 16:
-      fmt = "%llx";
-      break;
-
-    default:
-      NS_ERROR("Unrecognized radix!");
-      *aErrorCode = NS_ERROR_INVALID_ARG;
-      return 0;
-  }
-
-  int64_t result = 0;
-  if (PR_sscanf(narrow.get(), fmt, &result) == 1) {
-    *aErrorCode = NS_OK;
-  } else {
-    *aErrorCode = NS_ERROR_FAILURE;
-  }
-
-  return result;
-}
-#endif // XPCOM_GLUE_AVOID_NSPR
-
-// nsACString
-
-uint32_t
-nsACString::BeginReading(const char_type** aBegin, const char_type** aEnd) const
-{
-  uint32_t len = NS_CStringGetData(*this, aBegin);
-  if (aEnd) {
-    *aEnd = *aBegin + len;
-  }
-
-  return len;
-}
-
-const nsACString::char_type*
-nsACString::BeginReading() const
-{
-  const char_type* data;
-  NS_CStringGetData(*this, &data);
-  return data;
-}
-
-const nsACString::char_type*
-nsACString::EndReading() const
-{
-  const char_type* data;
-  uint32_t len = NS_CStringGetData(*this, &data);
-  return data + len;
-}
-
-uint32_t
-nsACString::BeginWriting(char_type** aBegin, char_type** aEnd,
-                         uint32_t aNewSize)
-{
-  uint32_t len = NS_CStringGetMutableData(*this, aNewSize, aBegin);
-  if (aEnd) {
-    *aEnd = *aBegin + len;
-  }
-
-  return len;
-}
-
-nsACString::char_type*
-nsACString::BeginWriting(uint32_t aLen)
-{
-  char_type* data;
-  NS_CStringGetMutableData(*this, aLen, &data);
-  return data;
-}
-
-nsACString::char_type*
-nsACString::EndWriting()
-{
-  char_type* data;
-  uint32_t len = NS_CStringGetMutableData(*this, UINT32_MAX, &data);
-  return data + len;
-}
-
-bool
-nsACString::SetLength(uint32_t aLen)
-{
-  char_type* data;
-  NS_CStringGetMutableData(*this, aLen, &data);
-  return data != nullptr;
-}
-
-void
-nsACString::StripChars(const char* aSet)
-{
-  nsCString copy(*this);
-
-  const char_type* source;
-  const char_type* sourceEnd;
-  copy.BeginReading(&source, &sourceEnd);
-
-  char_type* dest;
-  BeginWriting(&dest);
-  if (!dest) {
-    return;
-  }
-
-  char_type* curDest = dest;
-
-  for (; source < sourceEnd; ++source) {
-    const char* test;
-    for (test = aSet; *test; ++test) {
-      if (*source == char_type(*test)) {
-        break;
-      }
-    }
-
-    if (!*test) {
-      // not stripped, copy this char
-      *curDest = *source;
-      ++curDest;
-    }
-  }
-
-  SetLength(curDest - dest);
-}
-
-void
-nsACString::Trim(const char* aSet, bool aLeading, bool aTrailing)
-{
-  NS_ASSERTION(aLeading || aTrailing, "Ineffective Trim");
-
-  const char* start;
-  const char* end;
-  uint32_t cutLen;
-
-  if (aLeading) {
-    BeginReading(&start, &end);
-    for (cutLen = 0; start < end; ++start, ++cutLen) {
-      const char* test;
-      for (test = aSet; *test; ++test) {
-        if (*test == *start) {
-          break;
-        }
-      }
-      if (!*test) {
-        break;
-      }
-    }
-    if (cutLen) {
-      NS_CStringCutData(*this, 0, cutLen);
-    }
-  }
-  if (aTrailing) {
-    uint32_t len = BeginReading(&start, &end);
-    --end;
-    for (cutLen = 0; end >= start; --end, ++cutLen) {
-      const char* test;
-      for (test = aSet; *test; ++test) {
-        if (*test == *end) {
-          break;
-        }
-      }
-      if (!*test) {
-        break;
-      }
-    }
-    if (cutLen) {
-      NS_CStringCutData(*this, len - cutLen, cutLen);
-    }
-  }
-}
-
-int32_t
-nsACString::DefaultComparator(const char_type* aStrA, const char_type* aStrB,
-                              uint32_t aLen)
-{
-  return memcmp(aStrA, aStrB, aLen);
-}
-
-int32_t
-nsACString::Compare(const char_type* aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  uint32_t selflen = NS_CStringGetData(*this, &cself);
-  uint32_t otherlen = strlen(aOther);
-  uint32_t comparelen = selflen <= otherlen ? selflen : otherlen;
-
-  int32_t result = aComparator(cself, aOther, comparelen);
-  if (result == 0) {
-    if (selflen < otherlen) {
-      return -1;
-    }
-    if (selflen > otherlen) {
-      return 1;
-    }
-  }
-  return result;
-}
-
-int32_t
-nsACString::Compare(const self_type& aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  const char_type* cother;
-  uint32_t selflen = NS_CStringGetData(*this, &cself);
-  uint32_t otherlen = NS_CStringGetData(aOther, &cother);
-  uint32_t comparelen = selflen <= otherlen ? selflen : otherlen;
-
-  int32_t result = aComparator(cself, cother, comparelen);
-  if (result == 0) {
-    if (selflen < otherlen) {
-      return -1;
-    }
-    if (selflen > otherlen) {
-      return 1;
-    }
-  }
-  return result;
-}
-
-bool
-nsACString::Equals(const char_type* aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  uint32_t selflen = NS_CStringGetData(*this, &cself);
-  uint32_t otherlen = strlen(aOther);
-
-  if (selflen != otherlen) {
-    return false;
-  }
-
-  return aComparator(cself, aOther, selflen) == 0;
-}
-
-bool
-nsACString::Equals(const self_type& aOther, ComparatorFunc aComparator) const
-{
-  const char_type* cself;
-  const char_type* cother;
-  uint32_t selflen = NS_CStringGetData(*this, &cself);
-  uint32_t otherlen = NS_CStringGetData(aOther, &cother);
-
-  if (selflen != otherlen) {
-    return false;
-  }
-
-  return aComparator(cself, cother, selflen) == 0;
-}
-
-int32_t
-nsACString::Find(const self_type& aStr, uint32_t aOffset,
-                 ComparatorFunc aComparator) const
-{
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  if (aOffset > selflen) {
-    return -1;
-  }
-
-  const char_type* other;
-  uint32_t otherlen = aStr.BeginReading(&other);
-
-  if (otherlen > selflen - aOffset) {
-    return -1;
-  }
-
-  // We want to stop searching otherlen characters before the end of the string
-  end -= otherlen;
-
-  for (const char_type* cur = begin + aOffset; cur <= end; ++cur) {
-    if (!aComparator(cur, other, otherlen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsACString::Find(const char_type* aStr, ComparatorFunc aComparator) const
-{
-  return Find(aStr, strlen(aStr), aComparator);
-}
-
-int32_t
-nsACString::Find(const char_type* aStr, uint32_t aLen,
-                 ComparatorFunc aComparator) const
-{
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  if (aLen == 0) {
-    NS_WARNING("Searching for zero-length string.");
-    return -1;
-  }
-
-  if (aLen > selflen) {
-    return -1;
-  }
-
-  // We want to stop searching otherlen characters before the end of the string
-  end -= aLen;
-
-  for (const char_type* cur = begin; cur <= end; ++cur) {
-    if (!aComparator(cur, aStr, aLen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsACString::RFind(const self_type& aStr, int32_t aOffset,
-                  ComparatorFunc aComparator) const
-{
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  const char_type* other;
-  uint32_t otherlen = aStr.BeginReading(&other);
-
-  if (selflen < otherlen) {
-    return -1;
-  }
-
-  if (aOffset < 0 || uint32_t(aOffset) > (selflen - otherlen)) {
-    end -= otherlen;
-  } else {
-    end = begin + aOffset;
-  }
-
-  for (const char_type* cur = end; cur >= begin; --cur) {
-    if (!aComparator(cur, other, otherlen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsACString::RFind(const char_type* aStr, ComparatorFunc aComparator) const
-{
-  return RFind(aStr, strlen(aStr), aComparator);
-}
-
-int32_t
-nsACString::RFind(const char_type* aStr, int32_t aLen,
-                  ComparatorFunc aComparator) const
-{
-  const char_type* begin;
-  const char_type* end;
-  uint32_t selflen = BeginReading(&begin, &end);
-
-  if (aLen <= 0) {
-    NS_WARNING("Searching for zero-length string.");
-    return -1;
-  }
-
-  if (uint32_t(aLen) > selflen) {
-    return -1;
-  }
-
-  // We want to start searching otherlen characters before the end of the string
-  end -= aLen;
-
-  for (const char_type* cur = end; cur >= begin; --cur) {
-    if (!aComparator(cur, aStr, aLen)) {
-      return cur - begin;
-    }
-  }
-  return -1;
-}
-
-int32_t
-nsACString::FindChar(char_type aChar, uint32_t aOffset) const
-{
-  const char_type* start;
-  const char_type* end;
-  uint32_t len = BeginReading(&start, &end);
-  if (aOffset > len) {
-    return -1;
-  }
-
-  const char_type* cur;
-
-  for (cur = start + aOffset; cur < end; ++cur) {
-    if (*cur == aChar) {
-      return cur - start;
-    }
-  }
-
-  return -1;
-}
-
-int32_t
-nsACString::RFindChar(char_type aChar) const
-{
-  const char* start;
-  const char* end;
-  BeginReading(&start, &end);
-
-  for (; end >= start; --end) {
-    if (*end == aChar) {
-      return end - start;
-    }
-  }
-
-  return -1;
-}
-
-void
-nsACString::AppendInt(int aInt, int32_t aRadix)
-{
-  const char* fmt;
-  switch (aRadix) {
-    case 8:
-      fmt = "%o";
-      break;
-
-    case 10:
-      fmt = "%d";
-      break;
-
-    case 16:
-      fmt = "%x";
-      break;
-
-    default:
-      NS_ERROR("Unrecognized radix");
-      fmt = "";
-  }
-
-  char buf[20];
-  int len = SprintfLiteral(buf, fmt, aInt);
-  Append(buf, len);
-}
-
-#ifndef XPCOM_GLUE_AVOID_NSPR
-int32_t
-nsACString::ToInteger(nsresult* aErrorCode, uint32_t aRadix) const
-{
-  const char* fmt;
-  switch (aRadix) {
-    case 10:
-      fmt = "%i";
-      break;
-
-    case 16:
-      fmt = "%x";
-      break;
-
-    default:
-      NS_ERROR("Unrecognized radix!");
-      *aErrorCode = NS_ERROR_INVALID_ARG;
-      return 0;
-  }
-
-  int32_t result = 0;
-  if (PR_sscanf(nsCString(*this).get(), fmt, &result) == 1) {
-    *aErrorCode = NS_OK;
-  } else {
-    *aErrorCode = NS_ERROR_FAILURE;
-  }
-
-  return result;
-}
-
-int64_t
-nsACString::ToInteger64(nsresult* aErrorCode, uint32_t aRadix) const
-{
-  const char* fmt;
-  switch (aRadix) {
-    case 10:
-      fmt = "%lli";
-      break;
-
-    case 16:
-      fmt = "%llx";
-      break;
-
-    default:
-      NS_ERROR("Unrecognized radix!");
-      *aErrorCode = NS_ERROR_INVALID_ARG;
-      return 0;
-  }
-
-  int64_t result = 0;
-  if (PR_sscanf(nsCString(*this).get(), fmt, &result) == 1) {
-    *aErrorCode = NS_OK;
-  } else {
-    *aErrorCode = NS_ERROR_FAILURE;
-  }
-
-  return result;
-}
-#endif // XPCOM_GLUE_AVOID_NSPR
-
-// Substrings
-
-nsDependentSubstring::nsDependentSubstring(const abstract_string_type& aStr,
-                                           uint32_t aStartPos)
-{
-  const char16_t* data;
-  uint32_t len = NS_StringGetData(aStr, &data);
-
-  if (aStartPos > len) {
-    aStartPos = len;
-  }
-
-  NS_StringContainerInit2(*this, data + aStartPos, len - aStartPos,
-                          NS_STRING_CONTAINER_INIT_DEPEND |
-                          NS_STRING_CONTAINER_INIT_SUBSTRING);
-}
-
-nsDependentSubstring::nsDependentSubstring(const abstract_string_type& aStr,
-                                           uint32_t aStartPos,
-                                           uint32_t aLength)
-{
-  const char16_t* data;
-  uint32_t len = NS_StringGetData(aStr, &data);
-
-  if (aStartPos > len) {
-    aStartPos = len;
-  }
-
-  if (aStartPos + aLength > len) {
-    aLength = len - aStartPos;
-  }
-
-  NS_StringContainerInit2(*this, data + aStartPos, aLength,
-                          NS_STRING_CONTAINER_INIT_DEPEND |
-                            NS_STRING_CONTAINER_INIT_SUBSTRING);
-}
-
-nsDependentCSubstring::nsDependentCSubstring(const abstract_string_type& aStr,
-                                             uint32_t aStartPos)
-{
-  const char* data;
-  uint32_t len = NS_CStringGetData(aStr, &data);
-
-  if (aStartPos > len) {
-    aStartPos = len;
-  }
-
-  NS_CStringContainerInit2(*this, data + aStartPos, len - aStartPos,
-                           NS_CSTRING_CONTAINER_INIT_DEPEND |
-                           NS_CSTRING_CONTAINER_INIT_SUBSTRING);
-}
-
-nsDependentCSubstring::nsDependentCSubstring(const abstract_string_type& aStr,
-                                             uint32_t aStartPos,
-                                             uint32_t aLength)
-{
-  const char* data;
-  uint32_t len = NS_CStringGetData(aStr, &data);
-
-  if (aStartPos > len) {
-    aStartPos = len;
-  }
-
-  if (aStartPos + aLength > len) {
-    aLength = len - aStartPos;
-  }
-
-  NS_CStringContainerInit2(*this, data + aStartPos, aLength,
-                           NS_CSTRING_CONTAINER_INIT_DEPEND |
-                           NS_CSTRING_CONTAINER_INIT_SUBSTRING);
-}
-
-// Utils
-
-char*
-ToNewUTF8String(const nsAString& aSource)
-{
-  nsCString temp;
-  CopyUTF16toUTF8(aSource, temp);
-  return NS_CStringCloneData(temp);
-}
-
-void
-CompressWhitespace(nsAString& aString)
-{
-  char16_t* start;
-  uint32_t len = NS_StringGetMutableData(aString, UINT32_MAX, &start);
-  char16_t* end = start + len;
-  char16_t* from = start;
-  char16_t* to = start;
-
-  // Skip any leading whitespace
-  while (from < end && NS_IsAsciiWhitespace(*from)) {
-    from++;
-  }
-
-  while (from < end) {
-    char16_t theChar = *from++;
-
-    if (NS_IsAsciiWhitespace(theChar)) {
-      // We found a whitespace char, so skip over any more
-      while (from < end && NS_IsAsciiWhitespace(*from)) {
-        from++;
-      }
-
-      // Turn all whitespace into spaces
-      theChar = ' ';
-    }
-
-    *to++ = theChar;
-  }
-
-  // Drop any trailing space
-  if (to > start && to[-1] == ' ') {
-    to--;
-  }
-
-  // Re-terminate the string
-  *to = '\0';
-
-  // Set the new length
-  aString.SetLength(to - start);
-}
-
-uint32_t
-ToLowerCase(nsACString& aStr)
-{
-  char* begin;
-  char* end;
-  uint32_t len = aStr.BeginWriting(&begin, &end);
-
-  for (; begin < end; ++begin) {
-    *begin = NS_ToLower(*begin);
-  }
-
-  return len;
-}
-
-uint32_t
-ToUpperCase(nsACString& aStr)
-{
-  char* begin;
-  char* end;
-  uint32_t len = aStr.BeginWriting(&begin, &end);
-
-  for (; begin < end; ++begin) {
-    *begin = NS_ToUpper(*begin);
-  }
-
-  return len;
-}
-
-uint32_t
-ToLowerCase(const nsACString& aSrc, nsACString& aDest)
-{
-  const char* begin;
-  const char* end;
-  uint32_t len = aSrc.BeginReading(&begin, &end);
-
-  char* dest;
-  NS_CStringGetMutableData(aDest, len, &dest);
-
-  for (; begin < end; ++begin, ++dest) {
-    *dest = NS_ToLower(*begin);
-  }
-
-  return len;
-}
-
-uint32_t
-ToUpperCase(const nsACString& aSrc, nsACString& aDest)
-{
-  const char* begin;
-  const char* end;
-  uint32_t len = aSrc.BeginReading(&begin, &end);
-
-  char* dest;
-  NS_CStringGetMutableData(aDest, len, &dest);
-
-  for (; begin < end; ++begin, ++dest) {
-    *dest = NS_ToUpper(*begin);
-  }
-
-  return len;
-}
-
-int32_t
-CaseInsensitiveCompare(const char* aStrA, const char* aStrB,
-                       uint32_t aLen)
-{
-  for (const char* aend = aStrA + aLen; aStrA < aend; ++aStrA, ++aStrB) {
-    char la = NS_ToLower(*aStrA);
-    char lb = NS_ToLower(*aStrB);
-
-    if (la == lb) {
-      continue;
-    }
-
-    return la < lb ? -1 : 1;
-  }
-
-  return 0;
-}
-
-bool
-ParseString(const nsACString& aSource, char aDelimiter,
-            nsTArray<nsCString>& aArray)
-{
-  int32_t start = 0;
-  int32_t end = aSource.Length();
-
-  uint32_t oldLength = aArray.Length();
-
-  for (;;) {
-    int32_t delimiter = aSource.FindChar(aDelimiter, start);
-    if (delimiter < 0) {
-      delimiter = end;
-    }
-
-    if (delimiter != start) {
-      if (!aArray.AppendElement(Substring(aSource, start, delimiter - start))) {
-        aArray.RemoveElementsAt(oldLength, aArray.Length() - oldLength);
-        return false;
-      }
-    }
-
-    if (delimiter == end) {
-      break;
-    }
-    start = ++delimiter;
-    if (start == end) {
-      break;
-    }
-  }
-
-  return true;
-}
-
-const nsDependentSubstring
-Substring(const char16_t* aStart, const char16_t* aEnd)
-{
-  MOZ_RELEASE_ASSERT(aStart <= aEnd, "Overflow!");
-  MOZ_ASSERT(uint32_t(aEnd - aStart) == uintptr_t(aEnd - aStart),
-             "string too long");
-  return nsDependentSubstring(aStart, uint32_t(aEnd - aStart));
-}
-
-const nsDependentSubstring
-StringTail(const nsAString& aStr, uint32_t aCount)
-{
-  MOZ_RELEASE_ASSERT(aStr.Length() >= aCount, "Overflow!");
-  return nsDependentSubstring(aStr, aStr.Length() - aCount, aCount);
-}
-
-const nsDependentCSubstring
-Substring(const char* aStart, const char* aEnd)
-{
-  MOZ_RELEASE_ASSERT(aStart <= aEnd, "Overflow!");
-  MOZ_ASSERT(uint32_t(aEnd - aStart) == uintptr_t(aEnd - aStart),
-             "string too long");
-  return nsDependentCSubstring(aStart, uint32_t(aEnd - aStart));
-}
-
-inline const nsDependentCSubstring
-StringTail(const nsACString& aStr, uint32_t aCount)
-{
-  MOZ_RELEASE_ASSERT(aStr.Length() >= aCount, "Overflow!");
-  return nsDependentCSubstring(aStr, aStr.Length() - aCount, aCount);
-}
deleted file mode 100644
--- a/xpcom/glue/nsStringAPI.h
+++ /dev/null
@@ -1,1573 +0,0 @@
-/* -*- 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/. */
-
-/**
- * This header provides wrapper classes around the frozen string API
- * which are roughly equivalent to the internal string classes.
- */
-
-#ifdef MOZILLA_INTERNAL_API
-#error nsStringAPI.h is only usable from non-MOZILLA_INTERNAL_API code!
-#endif
-
-#ifndef nsStringAPI_h__
-#define nsStringAPI_h__
-
-#include "mozilla/Attributes.h"
-#include "mozilla/Char16.h"
-
-#include "nsXPCOMStrings.h"
-#include "nsISupportsImpl.h"
-#include "mozilla/Logging.h"
-#include "nsTArray.h"
-
-/**
- * Comparison function for use with nsACString::Equals
- */
-NS_HIDDEN_(int32_t) CaseInsensitiveCompare(const char* aStrA, const char* aStrB,
-                                           uint32_t aLength);
-
-class nsAString
-{
-public:
-  typedef char16_t  char_type;
-  typedef nsAString self_type;
-  typedef uint32_t  size_type;
-  typedef uint32_t  index_type;
-
-  /**
-   * Returns the length, beginning, and end of a string in one operation.
-   */
-  NS_HIDDEN_(uint32_t) BeginReading(const char_type** aBegin,
-                                    const char_type** aEnd = nullptr) const;
-
-  NS_HIDDEN_(const char_type*) BeginReading() const;
-  NS_HIDDEN_(const char_type*) EndReading() const;
-
-  NS_HIDDEN_(char_type) CharAt(uint32_t aPos) const
-  {
-    NS_ASSERTION(aPos < Length(), "Out of bounds");
-    return BeginReading()[aPos];
-  }
-  NS_HIDDEN_(char_type) operator [](uint32_t aPos) const
-  {
-    return CharAt(aPos);
-  }
-  NS_HIDDEN_(char_type) First() const
-  {
-    return CharAt(0);
-  }
-  NS_HIDDEN_(char_type) Last() const
-  {
-    const char_type* data;
-    uint32_t dataLen = NS_StringGetData(*this, &data);
-    return data[dataLen - 1];
-  }
-
-  /**
-   * Get the length, begin writing, and optionally set the length of a
-   * string all in one operation.
-   *
-   * @param   newSize Size the string to this length. Pass UINT32_MAX
-   *                  to leave the length unchanged.
-   * @return  The new length of the string, or 0 if resizing failed.
-   */
-  NS_HIDDEN_(uint32_t) BeginWriting(char_type** aBegin,
-                                    char_type** aEnd = nullptr,
-                                    uint32_t aNewSize = UINT32_MAX);
-
-  NS_HIDDEN_(char_type*) BeginWriting(uint32_t = UINT32_MAX);
-  NS_HIDDEN_(char_type*) EndWriting();
-
-  NS_HIDDEN_(bool) SetLength(uint32_t aLen);
-
-  NS_HIDDEN_(size_type) Length() const
-  {
-    const char_type* data;
-    return NS_StringGetData(*this, &data);
-  }
-
-  NS_HIDDEN_(bool) IsEmpty() const { return Length() == 0; }
-
-  NS_HIDDEN_(void) SetIsVoid(bool aVal) { NS_StringSetIsVoid(*this, aVal); }
-  NS_HIDDEN_(bool) IsVoid() const { return NS_StringGetIsVoid(*this); }
-
-  NS_HIDDEN_(void) Assign(const self_type& aString)
-  {
-    NS_StringCopy(*this, aString);
-  }
-  NS_HIDDEN_(void) Assign(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_StringSetData(*this, aData, aLength);
-  }
-  NS_HIDDEN_(void) Assign(char_type aChar)
-  {
-    NS_StringSetData(*this, &aChar, 1);
-  }
-#ifdef MOZ_USE_CHAR16_WRAPPER
-  NS_HIDDEN_(void) Assign(char16ptr_t aData, size_type aLength = UINT32_MAX)
-  {
-    NS_StringSetData(*this, aData, aLength);
-  }
-#endif
-
-  NS_HIDDEN_(void) AssignLiteral(const char* aStr);
-  NS_HIDDEN_(void) AssignASCII(const char* aStr)
-  {
-    AssignLiteral(aStr);
-  }
-
-  NS_HIDDEN_(self_type&) operator=(const self_type& aString)
-  {
-    Assign(aString);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator=(const char_type* aPtr)
-  {
-    Assign(aPtr);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-#ifdef MOZ_USE_CHAR16_WRAPPER
-  NS_HIDDEN_(self_type&) operator=(char16ptr_t aPtr)
-  {
-    Assign(aPtr);
-    return *this;
-  }
-#endif
-
-  NS_HIDDEN_(void) Replace(index_type aCutStart, size_type aCutLength,
-                           const char_type* aData,
-                           size_type aLength = size_type(-1))
-  {
-    NS_StringSetDataRange(*this, aCutStart, aCutLength, aData, aLength);
-  }
-  NS_HIDDEN_(void) Replace(index_type aCutStart, size_type aCutLength,
-                           char_type aChar)
-  {
-    Replace(aCutStart, aCutLength, &aChar, 1);
-  }
-  NS_HIDDEN_(void) Replace(index_type aCutStart, size_type aCutLength,
-                           const self_type& aReadable)
-  {
-    const char_type* data;
-    uint32_t dataLen = NS_StringGetData(aReadable, &data);
-    NS_StringSetDataRange(*this, aCutStart, aCutLength, data, dataLen);
-  }
-  NS_HIDDEN_(void) SetCharAt(char_type aChar, index_type aPos)
-  {
-    Replace(aPos, 1, &aChar, 1);
-  }
-
-  NS_HIDDEN_(void) Append(char_type aChar)
-  {
-    Replace(size_type(-1), 0, aChar);
-  }
-  NS_HIDDEN_(void) Append(const char_type* aData,
-                          size_type aLength = size_type(-1))
-  {
-    Replace(size_type(-1), 0, aData, aLength);
-  }
-#ifdef MOZ_USE_CHAR16_WRAPPER
-  NS_HIDDEN_(void) Append(char16ptr_t aData, size_type aLength = size_type(-1))
-  {
-    Append(static_cast<const char16_t*>(aData), aLength);
-  }
-#endif
-  NS_HIDDEN_(void) Append(const self_type& aReadable)
-  {
-    Replace(size_type(-1), 0, aReadable);
-  }
-  NS_HIDDEN_(void) AppendLiteral(const char* aASCIIStr);
-  NS_HIDDEN_(void) AppendASCII(const char* aASCIIStr)
-  {
-    AppendLiteral(aASCIIStr);
-  }
-
-  NS_HIDDEN_(self_type&) operator+=(char_type aChar)
-  {
-    Append(aChar);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator+=(const char_type* aData)
-  {
-    Append(aData);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator+=(const self_type& aReadable)
-  {
-    Append(aReadable);
-    return *this;
-  }
-
-  NS_HIDDEN_(void) Insert(char_type aChar, index_type aPos)
-  {
-    Replace(aPos, 0, aChar);
-  }
-  NS_HIDDEN_(void) Insert(const char_type* aData, index_type aPos,
-                          size_type aLength = size_type(-1))
-  {
-    Replace(aPos, 0, aData, aLength);
-  }
-  NS_HIDDEN_(void) Insert(const self_type& aReadable, index_type aPos)
-  {
-    Replace(aPos, 0, aReadable);
-  }
-
-  NS_HIDDEN_(void) Cut(index_type aCutStart, size_type aCutLength)
-  {
-    Replace(aCutStart, aCutLength, nullptr, 0);
-  }
-
-  NS_HIDDEN_(void) Truncate(size_type aNewLength = 0)
-  {
-    NS_ASSERTION(aNewLength <= Length(), "Truncate cannot make string longer");
-    SetLength(aNewLength);
-  }
-
-  /**
-   * Remove all occurences of characters in aSet from the string.
-   */
-  NS_HIDDEN_(void) StripChars(const char* aSet);
-
-  /**
-   * Strip whitespace characters from the string.
-   */
-  NS_HIDDEN_(void) StripWhitespace() { StripChars("\b\t\r\n "); }
-
-  NS_HIDDEN_(void) Trim(const char* aSet, bool aLeading = true,
-                        bool aTrailing = true);
-
-  /**
-   * Compare strings of characters. Return 0 if the characters are equal,
-   */
-  typedef int32_t (*ComparatorFunc)(const char_type* aStrA,
-                                    const char_type* aStrB,
-                                    uint32_t aLength);
-
-  static NS_HIDDEN_(int32_t) DefaultComparator(const char_type* aStrA,
-                                               const char_type* aStrB,
-                                               uint32_t aLength);
-
-  NS_HIDDEN_(int32_t) Compare(const char_type* aOther,
-                              ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(int32_t) Compare(const self_type& aOther,
-                              ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(bool) Equals(const char_type* aOther,
-                          ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(bool) Equals(const self_type& aOther,
-                          ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(bool) operator<(const self_type& aOther) const
-  {
-    return Compare(aOther) < 0;
-  }
-  NS_HIDDEN_(bool) operator<(const char_type* aOther) const
-  {
-    return Compare(aOther) < 0;
-  }
-
-  NS_HIDDEN_(bool) operator<=(const self_type& aOther) const
-  {
-    return Compare(aOther) <= 0;
-  }
-  NS_HIDDEN_(bool) operator<=(const char_type* aOther) const
-  {
-    return Compare(aOther) <= 0;
-  }
-
-  NS_HIDDEN_(bool) operator==(const self_type& aOther) const
-  {
-    return Equals(aOther);
-  }
-  NS_HIDDEN_(bool) operator==(const char_type* aOther) const
-  {
-    return Equals(aOther);
-  }
-#ifdef MOZ_USE_CHAR16_WRAPPER
-  NS_HIDDEN_(bool) operator==(char16ptr_t aOther) const
-  {
-    return Equals(aOther);
-  }
-#endif
-
-  NS_HIDDEN_(bool) operator>=(const self_type& aOther) const
-  {
-    return Compare(aOther) >= 0;
-  }
-  NS_HIDDEN_(bool) operator>=(const char_type* aOther) const
-  {
-    return Compare(aOther) >= 0;
-  }
-
-  NS_HIDDEN_(bool) operator>(const self_type& aOther) const
-  {
-    return Compare(aOther) > 0;
-  }
-  NS_HIDDEN_(bool) operator>(const char_type* aOther) const
-  {
-    return Compare(aOther) > 0;
-  }
-
-  NS_HIDDEN_(bool) operator!=(const self_type& aOther) const
-  {
-    return !Equals(aOther);
-  }
-  NS_HIDDEN_(bool) operator!=(const char_type* aOther) const
-  {
-    return !Equals(aOther);
-  }
-
-  NS_HIDDEN_(bool) EqualsLiteral(const char* aASCIIString) const;
-  NS_HIDDEN_(bool) EqualsASCII(const char* aASCIIString) const
-  {
-    return EqualsLiteral(aASCIIString);
-  }
-
-  /**
-   * Case-insensitive match this string to a lowercase ASCII string.
-   */
-  NS_HIDDEN_(bool) LowerCaseEqualsLiteral(const char* aASCIIString) const;
-
-  /**
-   * Find the first occurrence of aStr in this string.
-   *
-   * @return the offset of aStr, or -1 if not found
-   */
-  NS_HIDDEN_(int32_t) Find(const self_type& aStr,
-                           ComparatorFunc aComparator = DefaultComparator) const
-  {
-    return Find(aStr, 0, aComparator);
-  }
-
-  /**
-   * Find the first occurrence of aStr in this string, beginning at aOffset.
-   *
-   * @return the offset of aStr, or -1 if not found
-   */
-  NS_HIDDEN_(int32_t) Find(const self_type& aStr, uint32_t aOffset,
-                           ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Find an ASCII string within this string.
-   *
-   * @return the offset of aStr, or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) Find(const char* aStr, bool aIgnoreCase = false) const
-  {
-    return Find(aStr, 0, aIgnoreCase);
-  }
-
-  NS_HIDDEN_(int32_t) Find(const char* aStr, uint32_t aOffset,
-                           bool aIgnoreCase = false) const;
-
-  /**
-   * Find the last occurrence of aStr in this string.
-   *
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const self_type& aStr,
-                            ComparatorFunc aComparator = DefaultComparator) const
-  {
-    return RFind(aStr, -1, aComparator);
-  }
-
-  /**
-   * Find the last occurrence of aStr in this string, beginning at aOffset.
-   *
-   * @param aOffset the offset from the beginning of the string to begin
-   *        searching. If aOffset < 0, search from end of this string.
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const self_type& aStr, int32_t aOffset,
-                            ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Find the last occurrence of an ASCII string within this string.
-   *
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const char* aStr, bool aIgnoreCase = false) const
-  {
-    return RFind(aStr, -1, aIgnoreCase);
-  }
-
-  /**
-   * Find the last occurrence of an ASCII string beginning at aOffset.
-   *
-   * @param aOffset the offset from the beginning of the string to begin
-   *        searching. If aOffset < 0, search from end of this string.
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const char* aStr, int32_t aOffset,
-                            bool aIgnoreCase) const;
-
-  /**
-   * Search for the offset of the first occurrence of a character in a
-   * string.
-   *
-   * @param aOffset the offset from the beginning of the string to begin
-   *        searching
-   * @return The offset of the character from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) FindChar(char_type aChar, uint32_t aOffset = 0) const;
-
-  /**
-   * Search for the offset of the last occurrence of a character in a
-   * string.
-   *
-   * @return The offset of the character from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFindChar(char_type aChar) const;
-
-  /**
-   * Append a string representation of a number.
-   */
-  NS_HIDDEN_(void) AppendInt(int aInt, int32_t aRadix = 10);
-
-#ifndef XPCOM_GLUE_AVOID_NSPR
-  /**
-   * Convert this string to an integer.
-   *
-   * @param aErrorCode pointer to contain result code.
-   * @param aRadix must be 10 or 16
-   */
-  NS_HIDDEN_(int32_t) ToInteger(nsresult* aErrorCode,
-                                uint32_t aRadix = 10) const;
-  /**
-   * Convert this string to a 64-bit integer.
-   *
-   * @param aErrorCode pointer to contain result code.
-   * @param aRadix must be 10 or 16
-   */
-  NS_HIDDEN_(int64_t) ToInteger64(nsresult* aErrorCode,
-                                  uint32_t aRadix = 10) const;
-#endif // XPCOM_GLUE_AVOID_NSPR
-
-protected:
-  // Prevent people from allocating a nsAString directly.
-  ~nsAString() {}
-};
-
-class nsACString
-{
-public:
-  typedef char       char_type;
-  typedef nsACString self_type;
-  typedef uint32_t   size_type;
-  typedef uint32_t   index_type;
-
-  /**
-   * Returns the length, beginning, and end of a string in one operation.
-   */
-  NS_HIDDEN_(uint32_t) BeginReading(const char_type** aBegin,
-                                    const char_type** aEnd = nullptr) const;
-
-  NS_HIDDEN_(const char_type*) BeginReading() const;
-  NS_HIDDEN_(const char_type*) EndReading() const;
-
-  NS_HIDDEN_(char_type) CharAt(uint32_t aPos) const
-  {
-    NS_ASSERTION(aPos < Length(), "Out of bounds");
-    return BeginReading()[aPos];
-  }
-  NS_HIDDEN_(char_type) operator [](uint32_t aPos) const
-  {
-    return CharAt(aPos);
-  }
-  NS_HIDDEN_(char_type) First() const
-  {
-    return CharAt(0);
-  }
-  NS_HIDDEN_(char_type) Last() const
-  {
-    const char_type* data;
-    uint32_t dataLen = NS_CStringGetData(*this, &data);
-    return data[dataLen - 1];
-  }
-
-  /**
-   * Get the length, begin writing, and optionally set the length of a
-   * string all in one operation.
-   *
-   * @param   newSize Size the string to this length. Pass UINT32_MAX
-   *                  to leave the length unchanged.
-   * @return  The new length of the string, or 0 if resizing failed.
-   */
-  NS_HIDDEN_(uint32_t) BeginWriting(char_type** aBegin,
-                                    char_type** aEnd = nullptr,
-                                    uint32_t aNewSize = UINT32_MAX);
-
-  NS_HIDDEN_(char_type*) BeginWriting(uint32_t aLen = UINT32_MAX);
-  NS_HIDDEN_(char_type*) EndWriting();
-
-  NS_HIDDEN_(bool) SetLength(uint32_t aLen);
-
-  NS_HIDDEN_(size_type) Length() const
-  {
-    const char_type* data;
-    return NS_CStringGetData(*this, &data);
-  }
-
-  NS_HIDDEN_(bool) IsEmpty() const { return Length() == 0; }
-
-  NS_HIDDEN_(void) SetIsVoid(bool aVal) { NS_CStringSetIsVoid(*this, aVal); }
-  NS_HIDDEN_(bool) IsVoid() const { return NS_CStringGetIsVoid(*this); }
-
-  NS_HIDDEN_(void) Assign(const self_type& aString)
-  {
-    NS_CStringCopy(*this, aString);
-  }
-  NS_HIDDEN_(void) Assign(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_CStringSetData(*this, aData, aLength);
-  }
-  NS_HIDDEN_(void) Assign(char_type aChar)
-  {
-    NS_CStringSetData(*this, &aChar, 1);
-  }
-  NS_HIDDEN_(void) AssignLiteral(const char_type* aData)
-  {
-    Assign(aData);
-  }
-  NS_HIDDEN_(void) AssignASCII(const char_type* aData)
-  {
-    Assign(aData);
-  }
-
-  NS_HIDDEN_(self_type&) operator=(const self_type& aString)
-  {
-    Assign(aString);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator=(const char_type* aPtr)
-  {
-    Assign(aPtr);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-
-  NS_HIDDEN_(void) Replace(index_type aCutStart, size_type aCutLength,
-                           const char_type* aData,
-                           size_type aLength = size_type(-1))
-  {
-    NS_CStringSetDataRange(*this, aCutStart, aCutLength, aData, aLength);
-  }
-  NS_HIDDEN_(void) Replace(index_type aCutStart, size_type aCutLength,
-                           char_type aChar)
-  {
-    Replace(aCutStart, aCutLength, &aChar, 1);
-  }
-  NS_HIDDEN_(void) Replace(index_type aCutStart, size_type aCutLength,
-                           const self_type& aReadable)
-  {
-    const char_type* data;
-    uint32_t dataLen = NS_CStringGetData(aReadable, &data);
-    NS_CStringSetDataRange(*this, aCutStart, aCutLength, data, dataLen);
-  }
-  NS_HIDDEN_(void) SetCharAt(char_type aChar, index_type aPos)
-  {
-    Replace(aPos, 1, &aChar, 1);
-  }
-
-  NS_HIDDEN_(void) Append(char_type aChar)
-  {
-    Replace(size_type(-1), 0, aChar);
-  }
-  NS_HIDDEN_(void) Append(const char_type* aData,
-                          size_type aLength = size_type(-1))
-  {
-    Replace(size_type(-1), 0, aData, aLength);
-  }
-  NS_HIDDEN_(void) Append(const self_type& aReadable)
-  {
-    Replace(size_type(-1), 0, aReadable);
-  }
-  NS_HIDDEN_(void) AppendLiteral(const char* aASCIIStr)
-  {
-    Append(aASCIIStr);
-  }
-  NS_HIDDEN_(void) AppendASCII(const char* aASCIIStr)
-  {
-    Append(aASCIIStr);
-  }
-
-  NS_HIDDEN_(self_type&) operator+=(char_type aChar)
-  {
-    Append(aChar);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator+=(const char_type* aData)
-  {
-    Append(aData);
-    return *this;
-  }
-  NS_HIDDEN_(self_type&) operator+=(const self_type& aReadable)
-  {
-    Append(aReadable);
-    return *this;
-  }
-
-  NS_HIDDEN_(void) Insert(char_type aChar, index_type aPos)
-  {
-    Replace(aPos, 0, aChar);
-  }
-  NS_HIDDEN_(void) Insert(const char_type* aData, index_type aPos,
-                          size_type aLength = size_type(-1))
-  {
-    Replace(aPos, 0, aData, aLength);
-  }
-  NS_HIDDEN_(void) Insert(const self_type& aReadable, index_type aPos)
-  {
-    Replace(aPos, 0, aReadable);
-  }
-
-  NS_HIDDEN_(void) Cut(index_type aCutStart, size_type aCutLength)
-  {
-    Replace(aCutStart, aCutLength, nullptr, 0);
-  }
-
-  NS_HIDDEN_(void) Truncate(size_type aNewLength = 0)
-  {
-    NS_ASSERTION(aNewLength <= Length(), "Truncate cannot make string longer");
-    SetLength(aNewLength);
-  }
-
-  /**
-   * Remove all occurences of characters in aSet from the string.
-   */
-  NS_HIDDEN_(void) StripChars(const char* aSet);
-
-  /**
-   * Strip whitespace characters from the string.
-   */
-  NS_HIDDEN_(void) StripWhitespace() { StripChars("\b\t\r\n "); }
-
-  NS_HIDDEN_(void) Trim(const char* aSet, bool aLeading = true,
-                        bool aTrailing = true);
-
-  /**
-   * Compare strings of characters. Return 0 if the characters are equal,
-   */
-  typedef int32_t (*ComparatorFunc)(const char_type* a,
-                                    const char_type* b,
-                                    uint32_t length);
-
-  static NS_HIDDEN_(int32_t) DefaultComparator(const char_type* aStrA,
-                                               const char_type* aStrB,
-                                               uint32_t aLength);
-
-  NS_HIDDEN_(int32_t) Compare(const char_type* aOther,
-                              ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(int32_t) Compare(const self_type& aOther,
-                              ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(bool) Equals(const char_type* aOther,
-                          ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(bool) Equals(const self_type& aOther,
-                          ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(bool) operator<(const self_type& aOther) const
-  {
-    return Compare(aOther) < 0;
-  }
-  NS_HIDDEN_(bool) operator<(const char_type* aOther) const
-  {
-    return Compare(aOther) < 0;
-  }
-
-  NS_HIDDEN_(bool) operator<=(const self_type& aOther) const
-  {
-    return Compare(aOther) <= 0;
-  }
-  NS_HIDDEN_(bool) operator<=(const char_type* aOther) const
-  {
-    return Compare(aOther) <= 0;
-  }
-
-  NS_HIDDEN_(bool) operator==(const self_type& aOther) const
-  {
-    return Equals(aOther);
-  }
-  NS_HIDDEN_(bool) operator==(const char_type* aOther) const
-  {
-    return Equals(aOther);
-  }
-
-  NS_HIDDEN_(bool) operator>=(const self_type& aOther) const
-  {
-    return Compare(aOther) >= 0;
-  }
-  NS_HIDDEN_(bool) operator>=(const char_type* aOther) const
-  {
-    return Compare(aOther) >= 0;
-  }
-
-  NS_HIDDEN_(bool) operator>(const self_type& aOther) const
-  {
-    return Compare(aOther) > 0;
-  }
-  NS_HIDDEN_(bool) operator>(const char_type* aOther) const
-  {
-    return Compare(aOther) > 0;
-  }
-
-  NS_HIDDEN_(bool) operator!=(const self_type& aOther) const
-  {
-    return !Equals(aOther);
-  }
-  NS_HIDDEN_(bool) operator!=(const char_type* aOther) const
-  {
-    return !Equals(aOther);
-  }
-
-  NS_HIDDEN_(bool) EqualsLiteral(const char_type* aOther) const
-  {
-    return Equals(aOther);
-  }
-  NS_HIDDEN_(bool) EqualsASCII(const char_type* aOther) const
-  {
-    return Equals(aOther);
-  }
-
-  /**
-   * Case-insensitive match this string to a lowercase ASCII string.
-   */
-  NS_HIDDEN_(bool) LowerCaseEqualsLiteral(const char* aASCIIString) const
-  {
-    return Equals(aASCIIString, CaseInsensitiveCompare);
-  }
-
-  /**
-   * Find the first occurrence of aStr in this string.
-   *
-   * @return the offset of aStr, or -1 if not found
-   */
-  NS_HIDDEN_(int32_t) Find(const self_type& aStr,
-                           ComparatorFunc aComparator = DefaultComparator) const
-  {
-    return Find(aStr, 0, aComparator);
-  }
-
-  /**
-   * Find the first occurrence of aStr in this string, beginning at aOffset.
-   *
-   * @return the offset of aStr, or -1 if not found
-   */
-  NS_HIDDEN_(int32_t) Find(const self_type& aStr, uint32_t aOffset,
-                           ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Find the first occurrence of aStr in this string.
-   *
-   * @return the offset of aStr, or -1 if not found
-   */
-  NS_HIDDEN_(int32_t) Find(const char_type* aStr,
-                           ComparatorFunc aComparator = DefaultComparator) const;
-
-  NS_HIDDEN_(int32_t) Find(const char_type* aStr, uint32_t aLen,
-                           ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Find the last occurrence of aStr in this string.
-   *
-   * @return The offset of the character from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const self_type& aStr,
-                            ComparatorFunc aComparator = DefaultComparator) const
-  {
-    return RFind(aStr, -1, aComparator);
-  }
-
-  /**
-   * Find the last occurrence of aStr in this string, beginning at aOffset.
-   *
-   * @param aOffset the offset from the beginning of the string to begin
-   *        searching. If aOffset < 0, search from end of this string.
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const self_type& aStr, int32_t aOffset,
-                            ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Find the last occurrence of aStr in this string.
-   *
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const char_type* aStr,
-                            ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Find the last occurrence of an ASCII string in this string,
-   * beginning at aOffset.
-   *
-   * @param aLen is the length of aStr
-   * @return The offset of aStr from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFind(const char_type* aStr, int32_t aLen,
-                            ComparatorFunc aComparator = DefaultComparator) const;
-
-  /**
-   * Search for the offset of the first occurrence of a character in a
-   * string.
-   *
-   * @param aOffset the offset from the beginning of the string to begin
-   *        searching
-   * @return The offset of the character from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) FindChar(char_type aChar, uint32_t aOffset = 0) const;
-
-  /**
-   * Search for the offset of the last occurrence of a character in a
-   * string.
-   *
-   * @return The offset of the character from the beginning of the string,
-   *         or -1 if not found.
-   */
-  NS_HIDDEN_(int32_t) RFindChar(char_type aChar) const;
-
-  /**
-   * Append a string representation of a number.
-   */
-  NS_HIDDEN_(void) AppendInt(int aInt, int32_t aRadix = 10);
-
-#ifndef XPCOM_GLUE_AVOID_NSPR
-  /**
-   * Convert this string to an integer.
-   *
-   * @param aErrorCode pointer to contain result code.
-   * @param aRadix must be 10 or 16
-   */
-  NS_HIDDEN_(int32_t) ToInteger(nsresult* aErrorCode,
-                                uint32_t aRadix = 10) const;
-  /**
-   * Convert this string to a 64-bit integer.
-   *
-   * @param aErrorCode pointer to contain result code.
-   * @param aRadix must be 10 or 16
-   */
-  NS_HIDDEN_(int64_t) ToInteger64(nsresult* aErrorCode,
-                                  uint32_t aRadix = 10) const;
-#endif // XPCOM_GLUE_AVOID_NSPR
-
-protected:
-  // Prevent people from allocating a nsAString directly.
-  ~nsACString() {}
-};
-
-/* ------------------------------------------------------------------------- */
-
-/**
- * Below we define nsStringContainer and nsCStringContainer.  These classes
- * have unspecified structure.  In most cases, your code should use
- * nsString/nsCString instead of these classes; if you prefer C-style
- * programming, then look no further.
- */
-
-class nsStringContainer
-  : public nsAString
-  , private nsStringContainer_base
-{
-};
-
-class nsCStringContainer
-  : public nsACString
-  , private nsStringContainer_base
-{
-};
-
-/**
- * The following classes are C++ helper classes that make the frozen string
- * API easier to use.
- */
-
-/**
- * Rename symbols to avoid conflicting with internal versions.
- */
-#define nsString                       nsString_external
-#define nsCString                      nsCString_external
-#define nsDependentString              nsDependentString_external
-#define nsDependentCString             nsDependentCString_external
-#define NS_ConvertASCIItoUTF16         NS_ConvertASCIItoUTF16_external
-#define NS_ConvertUTF8toUTF16          NS_ConvertUTF8toUTF16_external
-#define NS_ConvertUTF16toUTF8          NS_ConvertUTF16toUTF8_external
-#define NS_LossyConvertUTF16toASCII    NS_LossyConvertUTF16toASCII_external
-#define nsGetterCopies                 nsGetterCopies_external
-#define nsCGetterCopies                nsCGetterCopies_external
-#define nsDependentSubstring           nsDependentSubstring_external
-#define nsDependentCSubstring          nsDependentCSubstring_external
-
-/**
- * basic strings
- */
-
-class nsString : public nsStringContainer
-{
-public:
-  typedef nsString         self_type;
-  typedef nsAString        abstract_string_type;
-
-  nsString()
-  {
-    NS_StringContainerInit(*this);
-  }
-
-  nsString(const self_type& aString)
-  {
-    NS_StringContainerInit(*this);
-    NS_StringCopy(*this, aString);
-  }
-
-  explicit nsString(const abstract_string_type& aReadable)
-  {
-    NS_StringContainerInit(*this);
-    NS_StringCopy(*this, aReadable);
-  }
-
-  explicit nsString(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_StringContainerInit2(*this, aData, aLength, 0);
-  }
-
-#ifdef MOZ_USE_CHAR16_WRAPPER
-  explicit nsString(char16ptr_t aData, size_type aLength = UINT32_MAX)
-    : nsString(static_cast<const char16_t*>(aData), aLength)
-  {
-  }
-#endif
-
-  ~nsString()
-  {
-    NS_StringContainerFinish(*this);
-  }
-
-  char16ptr_t get() const
-  {
-    return char16ptr_t(BeginReading());
-  }
-
-  self_type& operator=(const self_type& aString)
-  {
-    Assign(aString);
-    return *this;
-  }
-  self_type& operator=(const abstract_string_type& aReadable)
-  {
-    Assign(aReadable);
-    return *this;
-  }
-  self_type& operator=(const char_type* aPtr)
-  {
-    Assign(aPtr);
-    return *this;
-  }
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-
-  void Adopt(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_StringContainerFinish(*this);
-    NS_StringContainerInit2(*this, aData, aLength,
-                            NS_STRING_CONTAINER_INIT_ADOPT);
-  }
-
-protected:
-  nsString(const char_type* aData, size_type aLength, uint32_t aFlags)
-  {
-    NS_StringContainerInit2(*this, aData, aLength, aFlags);
-  }
-};
-
-class nsCString : public nsCStringContainer
-{
-public:
-  typedef nsCString        self_type;
-  typedef nsACString       abstract_string_type;
-
-  nsCString()
-  {
-    NS_CStringContainerInit(*this);
-  }
-
-  nsCString(const self_type& aString)
-  {
-    NS_CStringContainerInit(*this);
-    NS_CStringCopy(*this, aString);
-  }
-
-  explicit nsCString(const abstract_string_type& aReadable)
-  {
-    NS_CStringContainerInit(*this);
-    NS_CStringCopy(*this, aReadable);
-  }
-
-  explicit nsCString(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_CStringContainerInit(*this);
-    NS_CStringSetData(*this, aData, aLength);
-  }
-
-  ~nsCString()
-  {
-    NS_CStringContainerFinish(*this);
-  }
-
-  const char_type* get() const
-  {
-    return BeginReading();
-  }
-
-  self_type& operator=(const self_type& aString)
-  {
-    Assign(aString);
-    return *this;
-  }
-  self_type& operator=(const abstract_string_type& aReadable)
-  {
-    Assign(aReadable);
-    return *this;
-  }
-  self_type& operator=(const char_type* aPtr)
-  {
-    Assign(aPtr);
-    return *this;
-  }
-  self_type& operator=(char_type aChar)
-  {
-    Assign(aChar);
-    return *this;
-  }
-
-  void Adopt(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_CStringContainerFinish(*this);
-    NS_CStringContainerInit2(*this, aData, aLength,
-                             NS_CSTRING_CONTAINER_INIT_ADOPT);
-  }
-
-protected:
-  nsCString(const char_type* aData, size_type aLength, uint32_t aFlags)
-  {
-    NS_CStringContainerInit2(*this, aData, aLength, aFlags);
-  }
-};
-
-
-/**
- * dependent strings
- */
-
-class nsDependentString : public nsString
-{
-public:
-  typedef nsDependentString         self_type;
-
-  nsDependentString() {}
-
-  explicit nsDependentString(const char_type* aData,
-                             size_type aLength = UINT32_MAX)
-    : nsString(aData, aLength, NS_CSTRING_CONTAINER_INIT_DEPEND)
-  {
-  }
-
-#ifdef MOZ_USE_CHAR16_WRAPPER
-  explicit nsDependentString(char16ptr_t aData, size_type aLength = UINT32_MAX)
-    : nsDependentString(static_cast<const char16_t*>(aData), aLength)
-  {
-  }
-#endif
-
-  void Rebind(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_StringContainerFinish(*this);
-    NS_StringContainerInit2(*this, aData, aLength,
-                            NS_STRING_CONTAINER_INIT_DEPEND);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-class nsDependentCString : public nsCString
-{
-public:
-  typedef nsDependentCString        self_type;
-
-  nsDependentCString() {}
-
-  explicit nsDependentCString(const char_type* aData,
-                              size_type aLength = UINT32_MAX)
-    : nsCString(aData, aLength, NS_CSTRING_CONTAINER_INIT_DEPEND)
-  {
-  }
-
-  void Rebind(const char_type* aData, size_type aLength = UINT32_MAX)
-  {
-    NS_CStringContainerFinish(*this);
-    NS_CStringContainerInit2(*this, aData, aLength,
-                             NS_CSTRING_CONTAINER_INIT_DEPEND);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-
-/**
- * conversion classes
- */
-
-inline void
-CopyUTF16toUTF8(const nsAString& aSource, nsACString& aDest)
-{
-  NS_UTF16ToCString(aSource, NS_CSTRING_ENCODING_UTF8, aDest);
-}
-
-inline void
-CopyUTF8toUTF16(const nsACString& aSource, nsAString& aDest)
-{
-  NS_CStringToUTF16(aSource, NS_CSTRING_ENCODING_UTF8, aDest);
-}
-
-inline void
-LossyCopyUTF16toASCII(const nsAString& aSource, nsACString& aDest)
-{
-  NS_UTF16ToCString(aSource, NS_CSTRING_ENCODING_ASCII, aDest);
-}
-
-inline void
-CopyASCIItoUTF16(const nsACString& aSource, nsAString& aDest)
-{
-  NS_CStringToUTF16(aSource, NS_CSTRING_ENCODING_ASCII, aDest);
-}
-
-char*
-ToNewUTF8String(const nsAString& aSource);
-
-class NS_ConvertASCIItoUTF16 : public nsString
-{
-public:
-  typedef NS_ConvertASCIItoUTF16    self_type;
-
-  explicit NS_ConvertASCIItoUTF16(const nsACString& aStr)
-  {
-    NS_CStringToUTF16(aStr, NS_CSTRING_ENCODING_ASCII, *this);
-  }
-
-  explicit NS_ConvertASCIItoUTF16(const char* aData,
-                                  uint32_t aLength = UINT32_MAX)
-  {
-    NS_CStringToUTF16(nsDependentCString(aData, aLength),
-                      NS_CSTRING_ENCODING_ASCII, *this);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-class NS_ConvertUTF8toUTF16 : public nsString
-{
-public:
-  typedef NS_ConvertUTF8toUTF16    self_type;
-
-  explicit NS_ConvertUTF8toUTF16(const nsACString& aStr)
-  {
-    NS_CStringToUTF16(aStr, NS_CSTRING_ENCODING_UTF8, *this);
-  }
-
-  explicit NS_ConvertUTF8toUTF16(const char* aData,
-                                 uint32_t aLength = UINT32_MAX)
-  {
-    NS_CStringToUTF16(nsDependentCString(aData, aLength),
-                      NS_CSTRING_ENCODING_UTF8, *this);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-class NS_ConvertUTF16toUTF8 : public nsCString
-{
-public:
-  typedef NS_ConvertUTF16toUTF8    self_type;
-
-  explicit NS_ConvertUTF16toUTF8(const nsAString& aStr)
-  {
-    NS_UTF16ToCString(aStr, NS_CSTRING_ENCODING_UTF8, *this);
-  }
-
-  explicit NS_ConvertUTF16toUTF8(const char16ptr_t aData,
-                                 uint32_t aLength = UINT32_MAX)
-  {
-    NS_UTF16ToCString(nsDependentString(aData, aLength),
-                      NS_CSTRING_ENCODING_UTF8, *this);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-class NS_LossyConvertUTF16toASCII : public nsCString
-{
-public:
-  typedef NS_LossyConvertUTF16toASCII    self_type;
-
-  explicit NS_LossyConvertUTF16toASCII(const nsAString& aStr)
-  {
-    NS_UTF16ToCString(aStr, NS_CSTRING_ENCODING_ASCII, *this);
-  }
-
-  explicit NS_LossyConvertUTF16toASCII(const char16ptr_t aData,
-                                       uint32_t aLength = UINT32_MAX)
-  {
-    NS_UTF16ToCString(nsDependentString(aData, aLength),
-                      NS_CSTRING_ENCODING_ASCII, *this);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-
-/**
- * literal strings
- */
-static_assert(sizeof(char16_t) == 2, "size of char16_t must be 2");
-static_assert(char16_t(-1) > char16_t(0), "char16_t must be unsigned");
-
-#define NS_LITERAL_STRING(s) \
-  static_cast<const nsString&>(nsDependentString(reinterpret_cast<const nsAString::char_type*>(s), \
-                    uint32_t((sizeof(s) / 2) - 1)))
-#define NS_LITERAL_STRING_INIT(n, s) \
-  n(reinterpret_cast<const nsAString::char_type*>(s), \
-    uint32_t((sizeof(s) / 2) - 1))
-#define NS_NAMED_LITERAL_STRING(n,s) \
-  const nsDependentString n(reinterpret_cast<const nsAString::char_type*>(s), \
-                            uint32_t((sizeof(s) / 2) - 1))
-typedef nsDependentString nsLiteralString;
-
-#define NS_LITERAL_CSTRING(s) \
-  static_cast<const nsDependentCString&>(nsDependentCString(s, uint32_t(sizeof(s) - 1)))
-#define NS_LITERAL_CSTRING_INIT(n, s) \
-  n(s, uint32_t(sizeof(s)-1))
-#define NS_NAMED_LITERAL_CSTRING(n, s) \
-  const nsDependentCString n(s, uint32_t(sizeof(s)-1))
-
-typedef nsDependentCString nsLiteralCString;
-
-
-/**
- * getter_Copies support
- *
- *    NS_IMETHOD GetBlah(char16_t**);
- *
- *    void some_function()
- *    {
- *      nsString blah;
- *      GetBlah(getter_Copies(blah));
- *      // ...
- *    }
- */
-
-class nsGetterCopies
-{
-public:
-  typedef char16_t char_type;
-
-  explicit nsGetterCopies(nsString& aStr)
-    : mString(aStr)
-    , mData(nullptr)
-  {
-  }
-
-  ~nsGetterCopies() { mString.Adopt(mData); }
-
-  operator char_type**() { return &mData; }
-
-private:
-  nsString&  mString;
-  char_type* mData;
-};
-
-inline nsGetterCopies
-getter_Copies(nsString& aString)
-{
-  return nsGetterCopies(aString);
-}
-
-class nsCGetterCopies
-{
-public:
-  typedef char char_type;
-
-  explicit nsCGetterCopies(nsCString& aStr)
-    : mString(aStr)
-    , mData(nullptr)
-  {
-  }
-
-  ~nsCGetterCopies() { mString.Adopt(mData); }
-
-  operator char_type**() { return &mData; }
-
-private:
-  nsCString& mString;
-  char_type* mData;
-};
-
-inline nsCGetterCopies
-getter_Copies(nsCString& aString)
-{
-  return nsCGetterCopies(aString);
-}
-
-
-/**
-* substrings
-*/
-
-class nsDependentSubstring : public nsStringContainer
-{
-public:
-  typedef nsDependentSubstring self_type;
-  typedef nsAString            abstract_string_type;
-
-  ~nsDependentSubstring() { NS_StringContainerFinish(*this); }
-  nsDependentSubstring() { NS_StringContainerInit(*this); }
-
-  nsDependentSubstring(const char_type* aStart, uint32_t aLength)
-  {
-    NS_StringContainerInit2(*this, aStart, aLength,
-                            NS_STRING_CONTAINER_INIT_DEPEND |
-                            NS_STRING_CONTAINER_INIT_SUBSTRING);
-  }
-
-  nsDependentSubstring(const abstract_string_type& aStr,
-                       uint32_t aStartPos);
-  nsDependentSubstring(const abstract_string_type& aStr,
-                       uint32_t aStartPos, uint32_t aLength);
-
-  void Rebind(const char_type* aStart, uint32_t aLength)
-  {
-    NS_StringContainerFinish(*this);
-    NS_StringContainerInit2(*this, aStart, aLength,
-                            NS_STRING_CONTAINER_INIT_DEPEND |
-                            NS_STRING_CONTAINER_INIT_SUBSTRING);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-class nsDependentCSubstring : public nsCStringContainer
-{
-public:
-  typedef nsDependentCSubstring self_type;
-  typedef nsACString            abstract_string_type;
-
-  ~nsDependentCSubstring() { NS_CStringContainerFinish(*this); }
-  nsDependentCSubstring() { NS_CStringContainerInit(*this); }
-
-  nsDependentCSubstring(const char_type* aStart, uint32_t aLength)
-  {
-    NS_CStringContainerInit2(*this, aStart, aLength,
-                             NS_CSTRING_CONTAINER_INIT_DEPEND |
-                             NS_CSTRING_CONTAINER_INIT_SUBSTRING);
-  }
-
-  nsDependentCSubstring(const abstract_string_type& aStr,
-                        uint32_t aStartPos);
-  nsDependentCSubstring(const abstract_string_type& aStr,
-                        uint32_t aStartPos, uint32_t aLength);
-
-  void Rebind(const char_type* aStart, uint32_t aLength)
-  {
-    NS_CStringContainerFinish(*this);
-    NS_CStringContainerInit2(*this, aStart, aLength,
-                             NS_CSTRING_CONTAINER_INIT_DEPEND |
-                             NS_CSTRING_CONTAINER_INIT_SUBSTRING);
-  }
-
-private:
-  self_type& operator=(const self_type& aString) = delete;
-};
-
-
-/**
- * Various nsDependentC?Substring constructor functions
- */
-
-// char16_t
-inline const nsDependentSubstring
-Substring(const nsAString& aStr, uint32_t aStartPos)
-{
-  return nsDependentSubstring(aStr, aStartPos);
-}
-
-inline const nsDependentSubstring
-Substring(const nsAString& aStr, uint32_t aStartPos, uint32_t aLength)
-{
-  return nsDependentSubstring(aStr, aStartPos, aLength);
-}
-
-const nsDependentSubstring
-Substring(const char16_t* aStart, const char16_t* aEnd);
-
-inline const nsDependentSubstring
-Substring(const char16_t* aStart, uint32_t aLength)
-{
-  return nsDependentSubstring(aStart, aLength);
-}
-
-inline const nsDependentSubstring
-StringHead(const nsAString& aStr, uint32_t aCount)
-{
-  return nsDependentSubstring(aStr, 0, aCount);
-}
-
-const nsDependentSubstring
-StringTail(const nsAString& aStr, uint32_t aCount);
-
-// char
-inline const nsDependentCSubstring
-Substring(const nsACString& aStr, uint32_t aStartPos)
-{
-  return nsDependentCSubstring(aStr, aStartPos);
-}
-
-inline const nsDependentCSubstring
-Substring(const nsACString& aStr, uint32_t aStartPos, uint32_t aLength)
-{
-  return nsDependentCSubstring(aStr, aStartPos, aLength);
-}
-
-const nsDependentCSubstring
-Substring(const char* aStart, const char* aEnd);
-
-inline const nsDependentCSubstring
-Substring(const char* aStart, uint32_t aLength)
-{
-  return nsDependentCSubstring(aStart, aLength);
-}
-
-inline const nsDependentCSubstring
-StringHead(const nsACString& aStr, uint32_t aCount)
-{
-  return nsDependentCSubstring(aStr, 0, aCount);
-}
-
-const nsDependentCSubstring
-StringTail(const nsACString& aStr, uint32_t aCount);
-
-
-inline bool
-StringBeginsWith(const nsAString& aSource, const nsAString& aSubstring,
-                 nsAString::ComparatorFunc aComparator = nsAString::DefaultComparator)
-{
-  return aSubstring.Length() <= aSource.Length() &&
-    StringHead(aSource, aSubstring.Length()).Equals(aSubstring, aComparator);
-}
-
-inline bool
-StringEndsWith(const nsAString& aSource, const nsAString& aSubstring,
-               nsAString::ComparatorFunc aComparator = nsAString::DefaultComparator)
-{
-  return aSubstring.Length() <= aSource.Length() &&
-    StringTail(aSource, aSubstring.Length()).Equals(aSubstring, aComparator);
-}
-
-inline bool
-StringBeginsWith(const nsACString& aSource, const nsACString& aSubstring,
-                 nsACString::ComparatorFunc aComparator = nsACString::DefaultComparator)
-{
-  return aSubstring.Length() <= aSource.Length() &&
-    StringHead(aSource, aSubstring.Length()).Equals(aSubstring, aComparator);
-}
-
-inline bool
-StringEndsWith(const nsACString& aSource, const nsACString& aSubstring,
-               nsACString::ComparatorFunc aComparator = nsACString::DefaultComparator)
-{
-  return aSubstring.Length() <= aSource.Length() &&
-    StringTail(aSource, aSubstring.Length()).Equals(aSubstring, aComparator);
-}
-
-/**
- * Trim whitespace from the beginning and end of a string; then compress
- * remaining runs of whitespace characters to a single space.
- */
-NS_HIDDEN_(void) CompressWhitespace(nsAString& aString);
-
-#define EmptyCString() nsCString()
-#define EmptyString() nsString()
-
-/**
- * Convert an ASCII string to all upper/lowercase (a-z,A-Z only). As a bonus,
- * returns the string length.
- */
-NS_HIDDEN_(uint32_t) ToLowerCase(nsACString& aStr);
-
-NS_HIDDEN_(uint32_t) ToUpperCase(nsACString& aStr);
-
-NS_HIDDEN_(uint32_t) ToLowerCase(const nsACString& aSrc, nsACString& aDest);
-
-NS_HIDDEN_(uint32_t) ToUpperCase(const nsACString& aSrc, nsACString& aDest);
-
-/**
- * The following declarations are *deprecated*, and are included here only
- * to make porting from existing code that doesn't use the frozen string API
- * easier. They may disappear in the future.
- */
-
-inline char*
-ToNewCString(const nsACString& aStr)
-{
-  return NS_CStringCloneData(aStr);
-}
-
-inline char16_t*
-ToNewUnicode(const nsAString& aStr)
-{
-  return NS_StringCloneData(aStr);
-}
-
-typedef nsString PromiseFlatString;
-typedef nsCString PromiseFlatCString;
-
-typedef nsCString nsAutoCString;
-typedef nsString nsAutoString;
-
-NS_HIDDEN_(bool) ParseString(const nsACString& aAstring, char aDelimiter,
-                             nsTArray<nsCString>& aArray);
-
-#endif // nsStringAPI_h__
--- a/xpcom/string/nsTSubstring.h
+++ b/xpcom/string/nsTSubstring.h
@@ -6,17 +6,17 @@
 // IWYU pragma: private, include "nsString.h"
 
 #include "mozilla/Casting.h"
 #include "mozilla/IntegerPrintfMacros.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/MemoryReporting.h"
 
 #ifndef MOZILLA_INTERNAL_API
-#error Cannot use internal string classes without MOZILLA_INTERNAL_API defined. Use the frozen header nsStringAPI.h instead.
+#error "Using XPCOM strings is limited to code linked into libxul."
 #endif
 
 /**
  * The base for string comparators
  */
 class nsTStringComparator_CharT
 {
 public: