--- a/mfbt/HashFunctions.h
+++ b/mfbt/HashFunctions.h
@@ -53,17 +53,17 @@
 namespace mozilla {
 
 /**
  * The golden ratio as a 32-bit fixed-point value.
  */
 static const uint32_t GoldenRatioU32 = 0x9E3779B9U;
 
 inline uint32_t
-RotateLeft32(uint32_t value, uint8_t bits)
+RotateBitsLeft32(uint32_t value, uint8_t bits)
 {
   MOZ_ASSERT(bits < 32);
   return (value << bits) | (value >> (32 - bits));
 }
 
 namespace detail {
 
 inline uint32_t
@@ -85,17 +85,17 @@ AddU32ToHash(uint32_t hash, uint32_t val
    *
    * The rotation length of 5 is also arbitrary, although an odd number is again
    * preferable so our hash explores the whole universe of possible rotations.
    *
    * Finally, we multiply by the golden ratio *after* xor'ing, not before.
    * Otherwise, if |hash| is 0 (as it often is for the beginning of a message),
    * the expression
    *
-   *   (GoldenRatioU32 * RotateLeft(hash, 5)) |xor| value
+   *   (GoldenRatioU32 * RotateBitsLeft(hash, 5)) |xor| value
    *
    * evaluates to |value|.
    *
    * (Number-theoretic aside: Because any odd number |m| is relatively prime to
    * our modulus (2^32), the list
    *
    *    [x * m (mod 2^32) for 0 <= x < 2^32]
    *
@@ -103,17 +103,17 @@ AddU32ToHash(uint32_t hash, uint32_t val
    * cause us to skip any possible hash values.
    *
    * It's also nice if |m| has large-ish order mod 2^32 -- that is, if the
    * smallest k such that m^k == 1 (mod 2^32) is large -- so we can safely
    * multiply our hash value by |m| a few times without negating the
    * multiplicative effect.  Our golden ratio constant has order 2^29, which is
    * more than enough for our purposes.)
    */
-  return GoldenRatioU32 * (RotateLeft32(hash, 5) ^ value);
+  return GoldenRatioU32 * (RotateBitsLeft32(hash, 5) ^ value);
 }
 
 /**
  * AddUintptrToHash takes sizeof(uintptr_t) as a template parameter.
  */
 template<size_t PtrSize>
 inline uint32_t
 AddUintptrToHash(uint32_t hash, uintptr_t value);