--- a/xpcom/string/nsTStringRepr.h
+++ b/xpcom/string/nsTStringRepr.h
@@ -252,17 +252,17 @@ public:
   // for wide strings. Call this version when you know the
   // length of 'data'.
   bool NS_FASTCALL EqualsASCII(const char* aData, size_type aLen) const;
   // An efficient comparison with ASCII that can be used even
   // for wide strings. Call this version when 'data' is
   // null-terminated.
   bool NS_FASTCALL EqualsASCII(const char* aData) const;
 
-  // EqualsLiteral must ONLY be applied to an actual literal string, or
+  // EqualsLiteral must ONLY be called with an actual literal string, or
   // a char array *constant* declared without an explicit size.
   // Do not attempt to use it with a non-constant char array variable.
   // Use EqualsASCII for that.
   // (Although this method may happen to produce expected results for other
   // char arrays that have bound one greater than the sequence of interest,
   // such use is discouraged for reasons of readability and maintainability.)
   // The template trick to acquire the array bound at compile time without
   // using a macro is due to Corey Kosak, with much thanks.
@@ -277,17 +277,17 @@ public:
   // ASCII/Literal string. The ASCII string is *not* lowercased for
   // you. If you compare to an ASCII or literal string that contains an
   // uppercase character, it is guaranteed to return false. We will
   // throw assertions too.
   bool NS_FASTCALL LowerCaseEqualsASCII(const char* aData,
                                         size_type aLen) const;
   bool NS_FASTCALL LowerCaseEqualsASCII(const char* aData) const;
 
-  // LowerCaseEqualsLiteral must ONLY be applied to an actual
+  // LowerCaseEqualsLiteral must ONLY be called with an actual
   // literal string, or a char array *constant* declared without an
   // explicit size.  Do not attempt to use it with a non-constant char array
   // variable. Use LowerCaseEqualsASCII for that.
   // (Although this method may happen to produce expected results for other
   // char arrays that have bound one greater than the sequence of interest,
   // such use is discouraged for reasons of readability and maintainability.)
   template<int N>
   bool LowerCaseEqualsLiteral(const char (&aStr)[N]) const

--- a/xpcom/string/nsTSubstring.h
+++ b/xpcom/string/nsTSubstring.h
@@ -468,34 +468,34 @@ public:
   MOZ_MUST_USE bool NS_FASTCALL AssignASCII(const char* aData,
                                             const fallible_t& aFallible)
   {
     return AssignASCII(aData,
                        mozilla::AssertedCast<size_type, size_t>(strlen(aData)),
                        aFallible);
   }
 
-  // AssignLiteral must ONLY be applied to an actual literal string, or
+  // AssignLiteral must ONLY be called with an actual literal string, or
   // a character array *constant* declared without an explicit size.
   // Do not attempt to use it with a character array variable that is not
   // constant or does not have static storage duration. Use Assign or
   // AssignASCII for those.
   //
   // This method does not need a fallible version, because it uses the
   // POD buffer of the literal as the string's buffer without allocating.
   // The literal does not need to be ASCII. If this a 16-bit string, this
   // method takes a u"" literal. (The overload on 16-bit strings that takes
   // a "" literal takes only ASCII.)
   template<int N>
   void AssignLiteral(const char_type (&aStr)[N])
   {
     AssignLiteral(aStr, N - 1);
   }
 
-  // AssignLiteral must ONLY be applied to an actual literal string, or
+  // AssignLiteral must ONLY be called with an actual literal string, or
   // a char array *constant* declared without an explicit size.
   // Do not attempt to use it with a non-constant char array variable.
   // Use AssignASCII for that.
   //
   // This method takes an 8-bit (ASCII-only!) string that is expanded
   // into a 16-bit string at run time causing a run-time allocation.
   // To avoid the run-time allocation (at the cost of the literal
   // taking twice the size in the binary), use the above overload that
@@ -588,17 +588,17 @@ public:
                                 const char* aData,
                                 size_type aLength = size_type(-1));
 
   MOZ_MUST_USE bool NS_FASTCALL ReplaceASCII(index_type aCutStart, size_type aCutLength,
                                              const char* aData,
                                              size_type aLength,
                                              const fallible_t&);
 
-  // ReplaceLiteral must ONLY be applied to an actual literal string.
+  // ReplaceLiteral must ONLY be called with an actual literal string.
   // Do not attempt to use it with a character array variable.
   // Use Replace or ReplaceASCII for that.
   template<int N>
   void ReplaceLiteral(index_type aCutStart, size_type aCutLength,
                       const char_type (&aStr)[N])
   {
     ReplaceLiteral(aCutStart, aCutLength, aStr, N - 1);
   }
@@ -636,17 +636,17 @@ public:
 
   MOZ_MUST_USE bool AppendASCII(const char* aData,
                                 size_type aLength,
                                 const fallible_t& aFallible);
 
   // Appends a literal string ("" literal in the 8-bit case and u"" literal
   // in the 16-bit case) to the string.
   //
-  // AppendLiteral must ONLY be applied to an actual literal string.
+  // AppendLiteral must ONLY be called with an actual literal string.
   // Do not attempt to use it with a character array variable.
   // Use Append or AppendASCII for that.
   template<int N>
   void AppendLiteral(const char_type (&aStr)[N])
   {
     // The case where base_string_type::mLength is zero is intentionally
     // left unoptimized (could be optimized as call to AssignLiteral),
     // because it's rare/nonexistent. If you add that optimization,
@@ -797,17 +797,17 @@ public:
   {
     Replace(aPos, 0, aStr);
   }
   void Insert(const substring_tuple_type& aTuple, index_type aPos)
   {
     Replace(aPos, 0, aTuple);
   }
 
-  // InsertLiteral must ONLY be applied to an actual literal string.
+  // InsertLiteral must ONLY be called with an actual literal string.
   // Do not attempt to use it with a character array variable.
   // Use Insert for that.
   template<int N>
   void InsertLiteral(const char_type (&aStr)[N], index_type aPos)
   {
     ReplaceLiteral(aPos, 0, aStr, N - 1);
   }