diff -r 000000000000 -r 6474c204b198 dom/network/src/TCPSocketChild.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/network/src/TCPSocketChild.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,257 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <algorithm>
+#include "TCPSocketChild.h"
+#include "mozilla/unused.h"
+#include "mozilla/net/NeckoChild.h"
+#include "mozilla/dom/PBrowserChild.h"
+#include "mozilla/dom/TabChild.h"
+#include "nsIDOMTCPSocket.h"
+#include "nsJSUtils.h"
+#include "nsContentUtils.h"
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "jswrapper.h"
+
+using mozilla::net::gNeckoChild;
+
+namespace IPC {
+
+bool
+DeserializeArrayBuffer(JS::Handle<JSObject*> aObj,
+                       const InfallibleTArray<uint8_t>& aBuffer,
+                       JS::MutableHandle<JS::Value> aVal)
+{
+  mozilla::AutoSafeJSContext cx;
+  JSAutoCompartment ac(cx, aObj);
+
+  JS::Rooted<JSObject*> obj(cx, JS_NewArrayBuffer(cx, aBuffer.Length()));
+  if (!obj)
+    return false;
+  uint8_t* data = JS_GetArrayBufferData(obj);
+  if (!data)
+    return false;
+  memcpy(data, aBuffer.Elements(), aBuffer.Length());
+  aVal.set(OBJECT_TO_JSVAL(obj));
+  return true;
+}
+
+} // namespace IPC
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION(TCPSocketChildBase, mSocket)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(TCPSocketChildBase)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(TCPSocketChildBase)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TCPSocketChildBase)
+  NS_INTERFACE_MAP_ENTRY(nsITCPSocketChild)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+TCPSocketChildBase::TCPSocketChildBase()
+: mIPCOpen(false)
+{
+}
+
+TCPSocketChildBase::~TCPSocketChildBase()
+{
+}
+
+NS_IMETHODIMP_(MozExternalRefCountType) TCPSocketChild::Release(void)
+{
+  nsrefcnt refcnt = TCPSocketChildBase::Release();
+  if (refcnt == 1 && mIPCOpen) {
+    PTCPSocketChild::SendRequestDelete();
+    return 1;
+  }
+  return refcnt;
+}
+
+TCPSocketChild::TCPSocketChild()
+: mWindowObj(nullptr)
+{
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SendOpen(nsITCPSocketInternal* aSocket,
+                         const nsAString& aHost, uint16_t aPort,
+                         bool aUseSSL, const nsAString& aBinaryType,
+                         nsIDOMWindow* aWindow, JS::Handle<JS::Value> aWindowObj,
+                         JSContext* aCx)
+{
+  mSocket = aSocket;
+
+  MOZ_ASSERT(aWindowObj.isObject());
+  mWindowObj = js::CheckedUnwrap(&aWindowObj.toObject());
+  if (!mWindowObj) {
+    return NS_ERROR_FAILURE;
+  }
+  AddIPDLReference();
+  gNeckoChild->SendPTCPSocketConstructor(this);
+  PTCPSocketChild::SendOpen(nsString(aHost), aPort,
+                            aUseSSL, nsString(aBinaryType));
+  return NS_OK;
+}
+
+void
+TCPSocketChildBase::ReleaseIPDLReference()
+{
+  MOZ_ASSERT(mIPCOpen);
+  mIPCOpen = false;
+  this->Release();
+}
+
+void
+TCPSocketChildBase::AddIPDLReference()
+{
+  MOZ_ASSERT(!mIPCOpen);
+  mIPCOpen = true;
+  this->AddRef();
+}
+
+TCPSocketChild::~TCPSocketChild()
+{
+}
+
+bool
+TCPSocketChild::RecvUpdateBufferedAmount(const uint32_t& aBuffered,
+                                         const uint32_t& aTrackingNumber)
+{
+  if (NS_FAILED(mSocket->UpdateBufferedAmount(aBuffered, aTrackingNumber))) {
+    NS_ERROR("Shouldn't fail!");
+  }
+  return true;
+}
+
+bool
+TCPSocketChild::RecvCallback(const nsString& aType,
+                             const CallbackData& aData,
+                             const nsString& aReadyState)
+{
+  if (NS_FAILED(mSocket->UpdateReadyState(aReadyState)))
+    NS_ERROR("Shouldn't fail!");
+
+  nsresult rv = NS_ERROR_FAILURE;
+  if (aData.type() == CallbackData::Tvoid_t) {
+    rv = mSocket->CallListenerVoid(aType);
+
+  } else if (aData.type() == CallbackData::TTCPError) {
+    const TCPError& err(aData.get_TCPError());
+    rv = mSocket->CallListenerError(aType, err.name());
+
+  } else if (aData.type() == CallbackData::TSendableData) {
+    const SendableData& data = aData.get_SendableData();
+
+    if (data.type() == SendableData::TArrayOfuint8_t) {
+      JSContext* cx = nsContentUtils::GetSafeJSContext();
+      JSAutoRequest ar(cx);
+      JS::Rooted<JS::Value> val(cx);
+      JS::Rooted<JSObject*> window(cx, mWindowObj);
+      bool ok = IPC::DeserializeArrayBuffer(window, data.get_ArrayOfuint8_t(), &val);
+      NS_ENSURE_TRUE(ok, true);
+      rv = mSocket->CallListenerArrayBuffer(aType, val);
+
+    } else if (data.type() == SendableData::TnsString) {
+      rv = mSocket->CallListenerData(aType, data.get_nsString());
+
+    } else {
+      MOZ_CRASH("Invalid callback data type!");
+    }
+
+  } else {
+    MOZ_CRASH("Invalid callback type!");
+  }
+  NS_ENSURE_SUCCESS(rv, true);
+  return true;
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SendStartTLS()
+{
+  PTCPSocketChild::SendStartTLS();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SendSuspend()
+{
+  PTCPSocketChild::SendSuspend();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SendResume()
+{
+  PTCPSocketChild::SendResume();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SendClose()
+{
+  PTCPSocketChild::SendClose();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SendSend(JS::Handle<JS::Value> aData,
+                         uint32_t aByteOffset,
+                         uint32_t aByteLength,
+                         uint32_t aTrackingNumber,
+                         JSContext* aCx)
+{
+  if (aData.isString()) {
+    JSString* jsstr = aData.toString();
+    nsDependentJSString str;
+    bool ok = str.init(aCx, jsstr);
+    NS_ENSURE_TRUE(ok, NS_ERROR_FAILURE);
+    SendData(str, aTrackingNumber);
+  } else {
+    NS_ENSURE_TRUE(aData.isObject(), NS_ERROR_FAILURE);
+    JS::Rooted<JSObject*> obj(aCx, &aData.toObject());
+    NS_ENSURE_TRUE(JS_IsArrayBufferObject(obj), NS_ERROR_FAILURE);
+    uint32_t buflen = JS_GetArrayBufferByteLength(obj);
+    aByteOffset = std::min(buflen, aByteOffset);
+    uint32_t nbytes = std::min(buflen - aByteOffset, aByteLength);
+    uint8_t* data = JS_GetArrayBufferData(obj);
+    if (!data) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    FallibleTArray<uint8_t> fallibleArr;
+    if (!fallibleArr.InsertElementsAt(0, data + aByteOffset, nbytes)) {
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    InfallibleTArray<uint8_t> arr;
+    arr.SwapElements(fallibleArr);
+    SendData(arr, aTrackingNumber);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketChild::SetSocketAndWindow(nsITCPSocketInternal *aSocket,
+                                   JS::Handle<JS::Value> aWindowObj,
+                                   JSContext* aCx)
+{
+  mSocket = aSocket;
+  MOZ_ASSERT(aWindowObj.isObject());
+  mWindowObj = js::CheckedUnwrap(&aWindowObj.toObject());
+  if (!mWindowObj) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+bool
+TCPSocketChild::RecvRequestDelete()
+{
+  mozilla::unused << Send__delete__(this);
+  return true;
+}
+
+} // namespace dom
+} // namespace mozilla