diff -r 000000000000 -r 6474c204b198 dom/network/src/TCPSocketParent.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/network/src/TCPSocketParent.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,300 @@
+/* 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 "TCPSocketParent.h"
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "nsJSUtils.h"
+#include "nsIDOMTCPSocket.h"
+#include "nsCxPusher.h"
+#include "mozilla/unused.h"
+#include "mozilla/AppProcessChecker.h"
+#include "mozilla/net/NeckoCommon.h"
+#include "mozilla/net/PNeckoParent.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/TabParent.h"
+#include "nsIScriptSecurityManager.h"
+
+namespace IPC {
+
+//Defined in TCPSocketChild.cpp
+extern bool
+DeserializeArrayBuffer(JS::Handle<JSObject*> aObj,
+                       const InfallibleTArray<uint8_t>& aBuffer,
+                       JS::MutableHandle<JS::Value> aVal);
+
+}
+
+namespace mozilla {
+namespace dom {
+
+static void
+FireInteralError(mozilla::net::PTCPSocketParent* aActor, uint32_t aLineNo)
+{
+  mozilla::unused <<
+      aActor->SendCallback(NS_LITERAL_STRING("onerror"),
+                           TCPError(NS_LITERAL_STRING("InvalidStateError")),
+                           NS_LITERAL_STRING("connecting"));
+}
+
+NS_IMPL_CYCLE_COLLECTION(TCPSocketParentBase, mSocket, mIntermediary)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(TCPSocketParentBase)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(TCPSocketParentBase)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TCPSocketParentBase)
+  NS_INTERFACE_MAP_ENTRY(nsITCPSocketParent)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+TCPSocketParentBase::TCPSocketParentBase()
+: mIPCOpen(false)
+{
+}
+
+TCPSocketParentBase::~TCPSocketParentBase()
+{
+}
+
+void
+TCPSocketParentBase::ReleaseIPDLReference()
+{
+  MOZ_ASSERT(mIPCOpen);
+  mIPCOpen = false;
+  this->Release();
+}
+
+void
+TCPSocketParentBase::AddIPDLReference()
+{
+  MOZ_ASSERT(!mIPCOpen);
+  mIPCOpen = true;
+  this->AddRef();
+}
+
+NS_IMETHODIMP_(MozExternalRefCountType) TCPSocketParent::Release(void)
+{
+  nsrefcnt refcnt = TCPSocketParentBase::Release();
+  if (refcnt == 1 && mIPCOpen) {
+    mozilla::unused << PTCPSocketParent::SendRequestDelete();
+    return 1;
+  }
+  return refcnt;
+}
+
+bool
+TCPSocketParent::RecvOpen(const nsString& aHost, const uint16_t& aPort, const bool& aUseSSL,
+                          const nsString& aBinaryType)
+{
+  // We don't have browser actors in xpcshell, and hence can't run automated
+  // tests without this loophole.
+  if (net::UsingNeckoIPCSecurity() &&
+      !AssertAppProcessPermission(Manager()->Manager(), "tcp-socket")) {
+    FireInteralError(this, __LINE__);
+    return true;
+  }
+
+  // Obtain App ID
+  uint32_t appId = nsIScriptSecurityManager::NO_APP_ID;
+  const PContentParent *content = Manager()->Manager();
+  const InfallibleTArray<PBrowserParent*>& browsers = content->ManagedPBrowserParent();
+  if (browsers.Length() > 0) {
+    TabParent *tab = static_cast<TabParent*>(browsers[0]);
+    appId = tab->OwnAppId();
+  }
+
+  nsresult rv;
+  mIntermediary = do_CreateInstance("@mozilla.org/tcp-socket-intermediary;1", &rv);
+  if (NS_FAILED(rv)) {
+    FireInteralError(this, __LINE__);
+    return true;
+  }
+
+  rv = mIntermediary->Open(this, aHost, aPort, aUseSSL, aBinaryType, appId,
+                           getter_AddRefs(mSocket));
+  if (NS_FAILED(rv) || !mSocket) {
+    FireInteralError(this, __LINE__);
+    return true;
+  }
+
+  return true;
+}
+
+NS_IMETHODIMP
+TCPSocketParent::InitJS(JS::Handle<JS::Value> aIntermediary, JSContext* aCx)
+{
+  MOZ_ASSERT(aIntermediary.isObject());
+  mIntermediaryObj = &aIntermediary.toObject();
+  return NS_OK;
+}
+
+bool
+TCPSocketParent::RecvStartTLS()
+{
+  NS_ENSURE_TRUE(mSocket, true);
+  nsresult rv = mSocket->UpgradeToSecure();
+  NS_ENSURE_SUCCESS(rv, true);
+  return true;
+}
+
+bool
+TCPSocketParent::RecvSuspend()
+{
+  NS_ENSURE_TRUE(mSocket, true);
+  nsresult rv = mSocket->Suspend();
+  NS_ENSURE_SUCCESS(rv, true);
+  return true;
+}
+
+bool
+TCPSocketParent::RecvResume()
+{
+  NS_ENSURE_TRUE(mSocket, true);
+  nsresult rv = mSocket->Resume();
+  NS_ENSURE_SUCCESS(rv, true);
+  return true;
+}
+
+bool
+TCPSocketParent::RecvData(const SendableData& aData,
+                          const uint32_t& aTrackingNumber)
+{
+  NS_ENSURE_TRUE(mIntermediary, true);
+
+  nsresult rv;
+  switch (aData.type()) {
+    case SendableData::TArrayOfuint8_t: {
+      AutoSafeJSContext cx;
+      JSAutoRequest ar(cx);
+      JS::Rooted<JS::Value> val(cx);
+      JS::Rooted<JSObject*> obj(cx, mIntermediaryObj);
+      IPC::DeserializeArrayBuffer(obj, aData.get_ArrayOfuint8_t(), &val);
+      rv = mIntermediary->OnRecvSendArrayBuffer(val, aTrackingNumber);
+      NS_ENSURE_SUCCESS(rv, true);
+      break;
+    }
+
+    case SendableData::TnsString:
+      rv = mIntermediary->OnRecvSendString(aData.get_nsString(), aTrackingNumber);
+      NS_ENSURE_SUCCESS(rv, true);
+      break;
+
+    default:
+      MOZ_CRASH("unexpected SendableData type");
+  }
+  return true;
+}
+
+bool
+TCPSocketParent::RecvClose()
+{
+  NS_ENSURE_TRUE(mSocket, true);
+  nsresult rv = mSocket->Close();
+  NS_ENSURE_SUCCESS(rv, true);
+  return true;
+}
+
+NS_IMETHODIMP
+TCPSocketParent::SendEvent(const nsAString& aType, JS::Handle<JS::Value> aDataVal,
+                           const nsAString& aReadyState, JSContext* aCx)
+{
+  if (!mIPCOpen) {
+    NS_WARNING("Dropping callback due to no IPC connection");
+    return NS_OK;
+  }
+
+  CallbackData data;
+  if (aDataVal.isString()) {
+    JSString* jsstr = aDataVal.toString();
+    nsDependentJSString str;
+    if (!str.init(aCx, jsstr)) {
+      FireInteralError(this, __LINE__);
+      return NS_ERROR_OUT_OF_MEMORY;
+    }
+    data = SendableData(str);
+
+  } else if (aDataVal.isUndefined() || aDataVal.isNull()) {
+    data = mozilla::void_t();
+
+  } else if (aDataVal.isObject()) {
+    JS::Rooted<JSObject *> obj(aCx, &aDataVal.toObject());
+    if (JS_IsArrayBufferObject(obj)) {
+      uint32_t nbytes = JS_GetArrayBufferByteLength(obj);
+      uint8_t* buffer = JS_GetArrayBufferData(obj);
+      if (!buffer) {
+        FireInteralError(this, __LINE__);
+        return NS_ERROR_OUT_OF_MEMORY;
+      }
+      FallibleTArray<uint8_t> fallibleArr;
+      if (!fallibleArr.InsertElementsAt(0, buffer, nbytes)) {
+        FireInteralError(this, __LINE__);
+        return NS_ERROR_OUT_OF_MEMORY;
+      }
+      InfallibleTArray<uint8_t> arr;
+      arr.SwapElements(fallibleArr);
+      data = SendableData(arr);
+
+    } else {
+      nsDependentJSString name;
+
+      JS::Rooted<JS::Value> val(aCx);
+      if (!JS_GetProperty(aCx, obj, "name", &val)) {
+        NS_ERROR("No name property on supposed error object");
+      } else if (JSVAL_IS_STRING(val)) {
+        if (!name.init(aCx, JSVAL_TO_STRING(val))) {
+          NS_WARNING("couldn't initialize string");
+        }
+      }
+
+      data = TCPError(name);
+    }
+  } else {
+    NS_ERROR("Unexpected JS value encountered");
+    FireInteralError(this, __LINE__);
+    return NS_ERROR_FAILURE;
+  }
+  mozilla::unused <<
+      PTCPSocketParent::SendCallback(nsString(aType), data,
+                                     nsString(aReadyState));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketParent::SetSocketAndIntermediary(nsIDOMTCPSocket *socket,
+                                          nsITCPSocketIntermediary *intermediary,
+                                          JSContext* cx)
+{
+  mSocket = socket;
+  mIntermediary = intermediary;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPSocketParent::SendUpdateBufferedAmount(uint32_t aBufferedAmount,
+                                          uint32_t aTrackingNumber)
+{
+  mozilla::unused << PTCPSocketParent::SendUpdateBufferedAmount(aBufferedAmount,
+                                                                aTrackingNumber);
+  return NS_OK;
+}
+
+void
+TCPSocketParent::ActorDestroy(ActorDestroyReason why)
+{
+  if (mSocket) {
+    mSocket->Close();
+  }
+  mSocket = nullptr;
+  mIntermediaryObj = nullptr;
+  mIntermediary = nullptr;
+}
+
+bool
+TCPSocketParent::RecvRequestDelete()
+{
+  mozilla::unused << Send__delete__(this);
+  return true;
+}
+
+} // namespace dom
+} // namespace mozilla