--- a/dom/ipc/StructuredCloneData.cpp
+++ b/dom/ipc/StructuredCloneData.cpp
@@ -91,57 +91,30 @@ StructuredCloneData::Write(JSContext* aC
   mBuffer = nullptr;
   mSharedData = new SharedJSAllocatedData(Move(data));
   mInitialized = true;
 }
 
 void
 StructuredCloneData::WriteIPCParams(IPC::Message* aMsg) const
 {
-  size_t length = DataLength() / sizeof(uint64_t);
-  WriteParam(aMsg, length);
-
-  if (length) {
-    for (auto iter = Data().Iter(); !iter.Done(); iter.Advance(Data(), sizeof(uint64_t))) {
-      WriteParam(aMsg, *reinterpret_cast<uint64_t*>(iter.Data()));
-    }
-  }
+  WriteParam(aMsg, Data());
 }
 
 bool
 StructuredCloneData::ReadIPCParams(const IPC::Message* aMsg,
                                    PickleIterator* aIter)
 {
-  // MOZ_ASSERT(!Data());
-
-  // FIXME Fixed in later patch. See also
-  // ParamTraits<mozilla::SerializedStructuredCloneBuffer>
-  size_t dataLength = 0;
-  if (!ReadParam(aMsg, aIter, &dataLength)) {
+  MOZ_ASSERT(!mInitialized);
+  JSStructuredCloneData data(0, 4096, 4096);
+  if (!ReadParam(aMsg, aIter, &data)) {
     return false;
   }
-
-  if (!dataLength) {
-    return true;
-  }
-
-  JSStructuredCloneData buf(0, 4096, 4096);
-  uint64_t cur;
-  for (size_t i = 0; i < dataLength; ++i) {
-    if (!ReadParam(aMsg, aIter, &cur)) {
-      return false;
-    } else {
-      if (!buf.WriteBytes(reinterpret_cast<char*>(&cur), sizeof(uint64_t))) {
-        return false;
-      }
-    }
-  }
-
-  mSharedData = new SharedJSAllocatedData(Move(buf));
-
+  mSharedData = new SharedJSAllocatedData(Move(data));
+  mInitialized = true;
   return true;
 }
 
 bool
 StructuredCloneData::CopyExternalData(const char* aData,
                                       size_t aDataLength)
 {
   MOZ_ASSERT(!mInitialized);

--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -709,57 +709,68 @@ struct ParamTraits<mozilla::net::WebSock
 
   static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
   {
     return aResult->ReadIPCParams(aMsg, aIter);
   }
 };
 
 template <>
-struct ParamTraits<mozilla::SerializedStructuredCloneBuffer>
+struct ParamTraits<JSStructuredCloneData>
 {
-  typedef mozilla::SerializedStructuredCloneBuffer paramType;
+  typedef JSStructuredCloneData paramType;
 
   static void Write(Message* aMsg, const paramType& aParam)
   {
-    // XXX Use ParamTraits<JSStructuredCloneData>
-    // Fixed in later patch
-    size_t length = aParam.data.Size() / sizeof(uint64_t);
-    WriteParam(aMsg, length);
-    if (length) {
-      for (auto iter = aParam.data.Iter(); !iter.Done(); iter.Advance(aParam.data, sizeof(uint64_t))) {
-        WriteParam(aMsg, *reinterpret_cast<uint64_t*>(iter.Data()));
-      }
+    MOZ_ASSERT(!(aParam.Size() % sizeof(uint64_t)));
+    WriteParam(aMsg, aParam.Size() / sizeof(uint64_t));
+    auto iter = aParam.Iter();
+    while (!iter.Done()) {
+      aMsg->WriteBytes(iter.Data(), iter.RemainingInSegment());
+      iter.Advance(aParam, iter.RemainingInSegment());
     }
   }
 
   static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
   {
-    // XXX Use ParamTraits<JSStructuredCloneData>
-    // Fixed in later patch
+    // FIXME borrow from aIter directly
     size_t length = 0;
     if (!ReadParam(aMsg, aIter, &length)) {
       return false;
     }
 
     if (length) {
       uint64_t cur;
       for (size_t i = 0; i < length; ++i) {
         if (!ReadParam(aMsg, aIter, &cur)) {
           return false;
         } else {
-          if (!aResult->data.WriteBytes(reinterpret_cast<char*>(&cur),
-                                       sizeof(uint64_t))) {
+          if (!aResult->WriteBytes(reinterpret_cast<char*>(&cur), sizeof(uint64_t))) {
             return false;
           }
         }
       }
     }
+    return true;
+  }
+};
 
-    return true;
+template <>
+struct ParamTraits<mozilla::SerializedStructuredCloneBuffer>
+{
+  typedef mozilla::SerializedStructuredCloneBuffer paramType;
+
+  static void Write(Message* aMsg, const paramType& aParam)
+  {
+    WriteParam(aMsg, aParam.data);
+  }
+
+  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+  {
+    return ReadParam(aMsg, aIter, &aResult->data);
   }
 
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     LogParam(aParam.data.Size(), aLog);
   }
 };