--- a/dom/indexedDB/IDBObjectStore.cpp
+++ b/dom/indexedDB/IDBObjectStore.cpp
@@ -1063,17 +1063,17 @@ IDBObjectStore::DeserializeValue(JSConte
 
   char* data = reinterpret_cast<char*>(aCloneReadInfo.mData.Elements());
   size_t dataLen = aCloneReadInfo.mData.Length();
 
   MOZ_ASSERT(!(dataLen % sizeof(uint64_t)));
 
   JSAutoRequest ar(aCx);
 
-  JSStructuredCloneData buf(0, 4096, 4096);
+  JSStructuredCloneData buf;
   if (!buf.WriteBytes(data, dataLen)) {
     return false;
   }
 
   static const JSStructuredCloneCallbacks callbacks = {
     CommonStructuredCloneReadCallback<ValueDeserializationHelper>,
     nullptr,
     nullptr,
@@ -1108,17 +1108,17 @@ IDBObjectStore::DeserializeIndexValue(JS
 
   size_t dataLen = aCloneReadInfo.mData.Length();
   char* data = reinterpret_cast<char*>(aCloneReadInfo.mData.Elements());
 
   MOZ_ASSERT(!(dataLen % sizeof(uint64_t)));
 
   JSAutoRequest ar(aCx);
 
-  JSStructuredCloneData buf(0, 4096, 4096);
+  JSStructuredCloneData buf;
   if (!buf.WriteBytes(data, dataLen)) {
     return false;
   }
 
   static const JSStructuredCloneCallbacks callbacks = {
     CommonStructuredCloneReadCallback<IndexDeserializationHelper>,
     nullptr,
     nullptr
@@ -1151,17 +1151,17 @@ IDBObjectStore::DeserializeUpgradeValue(
 
   size_t dataLen = aCloneReadInfo.mData.Length();
   char* data = reinterpret_cast<char*>(aCloneReadInfo.mData.Elements());
 
   MOZ_ASSERT(!(dataLen % sizeof(uint64_t)));
 
   JSAutoRequest ar(aCx);
 
-  JSStructuredCloneData buf(0, 4096, 4096);
+  JSStructuredCloneData buf;
   if (!buf.WriteBytes(data, dataLen)) {
     return false;
   }
 
   static JSStructuredCloneCallbacks callbacks = {
     CommonStructuredCloneReadCallback<UpgradeDeserializationHelper>,
     nullptr,
     nullptr,

--- a/dom/ipc/StructuredCloneData.cpp
+++ b/dom/ipc/StructuredCloneData.cpp
@@ -81,17 +81,17 @@ StructuredCloneData::Write(JSContext* aC
 {
   MOZ_ASSERT(!mInitialized);
 
   StructuredCloneHolder::Write(aCx, aValue, aTransfer, aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
 
-  JSStructuredCloneData data(0, 0, 0);
+  JSStructuredCloneData data;
   mBuffer->steal(data);
   mBuffer = nullptr;
   mSharedData = new SharedJSAllocatedData(Move(data));
   mInitialized = true;
 }
 
 void
 StructuredCloneData::WriteIPCParams(IPC::Message* aMsg) const
@@ -99,17 +99,17 @@ StructuredCloneData::WriteIPCParams(IPC:
   WriteParam(aMsg, Data());
 }
 
 bool
 StructuredCloneData::ReadIPCParams(const IPC::Message* aMsg,
                                    PickleIterator* aIter)
 {
   MOZ_ASSERT(!mInitialized);
-  JSStructuredCloneData data(0, 4096, 4096);
+  JSStructuredCloneData data;
   if (!ReadParam(aMsg, aIter, &data)) {
     return false;
   }
   mSharedData = new SharedJSAllocatedData(Move(data));
   mInitialized = true;
   return true;
 }
 

--- a/dom/ipc/StructuredCloneData.h
+++ b/dom/ipc/StructuredCloneData.h
@@ -26,27 +26,27 @@ class SharedJSAllocatedData final
 public:
   explicit SharedJSAllocatedData(JSStructuredCloneData&& aData)
     : mData(Move(aData))
   { }
 
   static already_AddRefed<SharedJSAllocatedData>
   CreateFromExternalData(const char* aData, size_t aDataLength)
   {
-    JSStructuredCloneData buf(0, 4096, 4096);
+    JSStructuredCloneData buf;
     buf.WriteBytes(aData, aDataLength);
     RefPtr<SharedJSAllocatedData> sharedData =
       new SharedJSAllocatedData(Move(buf));
     return sharedData.forget();
   }
 
   static already_AddRefed<SharedJSAllocatedData>
   CreateFromExternalData(const JSStructuredCloneData& aData)
   {
-    JSStructuredCloneData buf(0, 4096, 4096);
+    JSStructuredCloneData buf;
     auto iter = aData.Iter();
     while (!iter.Done()) {
       buf.WriteBytes(iter.Data(), iter.RemainingInSegment());
       iter.Advance(aData, iter.RemainingInSegment());
     }
     RefPtr<SharedJSAllocatedData> sharedData =
       new SharedJSAllocatedData(Move(buf));
     return sharedData.forget();
@@ -65,17 +65,17 @@ private:
 
 class StructuredCloneData : public StructuredCloneHolder
 {
 public:
   StructuredCloneData()
     : StructuredCloneHolder(StructuredCloneHolder::CloningSupported,
                             StructuredCloneHolder::TransferringSupported,
                             StructuredCloneHolder::DifferentProcess)
-    , mExternalData(0, 0, 0)
+    , mInitialized(false)
   {}
 
   StructuredCloneData(const StructuredCloneData&) = delete;
 
   ~StructuredCloneData()
   {}
 
   StructuredCloneData&

--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -61,20 +61,16 @@ struct void_t {
   bool operator==(const void_t&) const { return true; }
 };
 struct null_t {
   bool operator==(const null_t&) const { return true; }
 };
 
 struct SerializedStructuredCloneBuffer final
 {
-  SerializedStructuredCloneBuffer()
-    : data(0, 4096, 4096)
-  { }
-
   SerializedStructuredCloneBuffer&
   operator=(const SerializedStructuredCloneBuffer& aOther)
   {
     data.Clear();
     auto iter = aOther.data.Iter();
     while (!iter.Done()) {
       data.WriteBytes(iter.Data(), iter.RemainingInSegment());
       iter.Advance(aOther.data, iter.RemainingInSegment());

--- a/js/public/StructuredClone.h
+++ b/js/public/StructuredClone.h
@@ -142,17 +142,31 @@ struct JSStructuredCloneCallbacks {
     ReadStructuredCloneOp read;
     WriteStructuredCloneOp write;
     StructuredCloneErrorOp reportError;
     ReadTransferStructuredCloneOp readTransfer;
     TransferStructuredCloneOp writeTransfer;
     FreeTransferStructuredCloneOp freeTransfer;
 };
 
-typedef mozilla::BufferList<js::TempAllocPolicy> JSStructuredCloneData;
+class JSStructuredCloneData : public mozilla::BufferList<js::TempAllocPolicy>
+{
+    static const size_t kInitialSize = 0;
+    static const size_t kInitialCapacity = 4096;
+    static const size_t kStandardCapacity = 4096;
+
+public:
+    explicit JSStructuredCloneData(js::TempAllocPolicy aAP = js::TempAllocPolicy())
+        : BufferList(kInitialSize, kInitialCapacity, kStandardCapacity, aAP)
+    {}
+    MOZ_IMPLICIT JSStructuredCloneData(mozilla::BufferList<js::TempAllocPolicy>&& aBuffers)
+        : BufferList(Move(aBuffers))
+    {}
+    using BufferList<js::TempAllocPolicy>::BufferList;
+};
 
 /** Note: if the *data contains transferable objects, it can be read only once. */
 JS_PUBLIC_API(bool)
 JS_ReadStructuredClone(JSContext* cx, JSStructuredCloneData& data, uint32_t version,
                        JS::MutableHandleValue vp,
                        const JSStructuredCloneCallbacks* optionalCallbacks, void* closure);
 
 /**
@@ -186,23 +200,23 @@ class JS_PUBLIC_API(JSAutoStructuredClon
         NoTransferables
     } ownTransferables_;
 
     const JSStructuredCloneCallbacks* callbacks_;
     void* closure_;
 
   public:
     JSAutoStructuredCloneBuffer()
-        : data_(0, 0, 4096), version_(JS_STRUCTURED_CLONE_VERSION),
+        : version_(JS_STRUCTURED_CLONE_VERSION),
           ownTransferables_(NoTransferables),
           callbacks_(nullptr), closure_(nullptr)
     {}
 
     JSAutoStructuredCloneBuffer(const JSStructuredCloneCallbacks* callbacks, void* closure)
-        : data_(0, 0, 4096), version_(JS_STRUCTURED_CLONE_VERSION),
+        : version_(JS_STRUCTURED_CLONE_VERSION),
           ownTransferables_(NoTransferables),
           callbacks_(callbacks), closure_(closure)
     {}
 
     JSAutoStructuredCloneBuffer(JSAutoStructuredCloneBuffer&& other);
     JSAutoStructuredCloneBuffer& operator=(JSAutoStructuredCloneBuffer&& other);
 
     ~JSAutoStructuredCloneBuffer() { clear(); }

--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -2036,17 +2036,17 @@ class CloneBufferObject : public NativeO
 
         return &obj->as<CloneBufferObject>();
     }
 
     static CloneBufferObject* Create(JSContext* cx, JSAutoStructuredCloneBuffer* buffer) {
         Rooted<CloneBufferObject*> obj(cx, Create(cx));
         if (!obj)
             return nullptr;
-        auto data = js::MakeUnique<JSStructuredCloneData>(0, 0, 0);
+        auto data = js::MakeUnique<JSStructuredCloneData>();
         buffer->steal(*data.get());
         obj->setData(data.release());
         return obj;
     }
 
     JSStructuredCloneData* data() const {
         return static_cast<JSStructuredCloneData*>(getReservedSlot(DATA_SLOT).toPrivate());
     }

--- a/js/src/vm/StructuredClone.cpp
+++ b/js/src/vm/StructuredClone.cpp
@@ -678,17 +678,17 @@ SCInput::readPtr(void** p)
     if (!readNativeEndian(&u))
         return false;
     *p = reinterpret_cast<void*>(NativeEndian::swapFromLittleEndian(u));
     return true;
 }
 
 SCOutput::SCOutput(JSContext* cx)
     : cx(cx)
-    , buf(0, 0, 4096, cx)
+    , buf(cx)
 {
 }
 
 bool
 SCOutput::write(uint64_t u)
 {
     uint64_t v = NativeEndian::swapToLittleEndian(u);
     return buf.WriteBytes(reinterpret_cast<char*>(&v), sizeof(u));
@@ -2276,17 +2276,16 @@ JS_StructuredClone(JSContext* cx, Handle
                 return false;
         }
     }
 
     return buf.read(cx, vp, callbacks, closure);
 }
 
 JSAutoStructuredCloneBuffer::JSAutoStructuredCloneBuffer(JSAutoStructuredCloneBuffer&& other)
-    : data_(0, 0, 0)
 {
     ownTransferables_ = other.ownTransferables_;
     other.steal(data_, &version_, &callbacks_, &closure_);
 }
 
 JSAutoStructuredCloneBuffer&
 JSAutoStructuredCloneBuffer::operator=(JSAutoStructuredCloneBuffer&& other)
 {