--- a/mfbt/Range.h
+++ b/mfbt/Range.h
@@ -21,16 +21,24 @@ class Range
   const RangedPtr<T> mEnd;
 
 public:
   Range() : mStart(nullptr, 0), mEnd(nullptr, 0) {}
   Range(T* aPtr, size_t aLength)
     : mStart(aPtr, aPtr, aPtr + aLength),
       mEnd(aPtr + aLength, aPtr, aPtr + aLength)
   {}
+  Range(const RangedPtr<T>& aStart, const RangedPtr<T>& aEnd)
+    : mStart(aStart.get(), aStart.get(), aEnd.get()),
+      mEnd(aEnd.get(), aStart.get(), aEnd.get())
+  {
+    // Only accept two RangedPtrs within the same range.
+    aStart.checkIdenticalRange(aEnd);
+    MOZ_ASSERT(aStart <= aEnd);
+  }
 
   RangedPtr<T> start() const { return mStart; }
   RangedPtr<T> end() const { return mEnd; }
   size_t length() const { return mEnd - mStart; }
 
   T& operator[](size_t aOffset) const { return mStart[aOffset]; }
 
   explicit operator bool() const { return mStart != nullptr; }

--- a/mfbt/RangedPtr.h
+++ b/mfbt/RangedPtr.h
@@ -112,30 +112,35 @@ public:
   {
     checkSanity();
   }
 
   T* get() const { return mPtr; }
 
   explicit operator bool() const { return mPtr != nullptr; }
 
+  void checkIdenticalRange(const RangedPtr<T>& aOther) const
+  {
+    MOZ_ASSERT(mRangeStart == aOther.mRangeStart);
+    MOZ_ASSERT(mRangeEnd == aOther.mRangeEnd);
+  }
+
   /*
    * You can only assign one RangedPtr into another if the two pointers have
    * the same valid range:
    *
    *   char arr1[] = "hi";
    *   char arr2[] = "bye";
    *   RangedPtr<char> p1(arr1, 2);
    *   p1 = RangedPtr<char>(arr1 + 1, arr1, arr1 + 2); // works
    *   p1 = RangedPtr<char>(arr2, 3);                  // asserts
    */
   RangedPtr<T>& operator=(const RangedPtr<T>& aOther)
   {
-    MOZ_ASSERT(mRangeStart == aOther.mRangeStart);
-    MOZ_ASSERT(mRangeEnd == aOther.mRangeEnd);
+    checkIdenticalRange(aOther);
     mPtr = aOther.mPtr;
     checkSanity();
     return *this;
   }
 
   RangedPtr<T> operator+(size_t aInc) const
   {
     MOZ_ASSERT(aInc <= size_t(-1) / sizeof(T));