Add m-esr52 at 52.6.0

157 files changed, 13510 insertions, 0 deletions

diff --git a/ipc/ipdl/test/cxx/IPDLUnitTestProcessChild.cpp b/ipc/ipdl/test/cxx/IPDLUnitTestProcessChild.cpp
new file mode 100644
index 000000000..7123e3db8
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTestProcessChild.cpp
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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 "mozilla/ipc/IOThreadChild.h"
+
+#include "IPDLUnitTestProcessChild.h"
+#include "IPDLUnitTests.h"
+
+#include "nsRegion.h"
+
+using mozilla::ipc::IOThreadChild;
+
+namespace mozilla {
+namespace _ipdltest {
+
+bool
+IPDLUnitTestProcessChild::Init()
+{
+    IPDLUnitTestChildInit(IOThreadChild::channel(),
+                          ParentPid(),
+                          IOThreadChild::message_loop());
+
+    if (NS_FAILED(nsRegion::InitStatic()))
+      return false;
+
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTestProcessChild.h b/ipc/ipdl/test/cxx/IPDLUnitTestProcessChild.h
new file mode 100644
index 000000000..693cc7360
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTestProcessChild.h
@@ -0,0 +1,32 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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/. */
+
+#ifndef mozilla__ipdltest_IPDLUnitTestThreadChild_h
+#define mozilla__ipdltest_IPDLUnitTestThreadChild_h 1
+
+#include "mozilla/ipc/ProcessChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+class IPDLUnitTestProcessChild : public mozilla::ipc::ProcessChild
+{
+  typedef mozilla::ipc::ProcessChild ProcessChild;
+
+public:
+  explicit IPDLUnitTestProcessChild(ProcessId aParentPid) :
+    ProcessChild(aParentPid)
+  { }
+
+  ~IPDLUnitTestProcessChild()
+  { }
+
+  virtual bool Init();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+#endif // ifndef mozilla__ipdltest_IPDLUnitTestThreadChild_h
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTestSubprocess.cpp b/ipc/ipdl/test/cxx/IPDLUnitTestSubprocess.cpp
new file mode 100644
index 000000000..87fe0ddc7
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTestSubprocess.cpp
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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 "IPDLUnitTestSubprocess.h"
+
+using mozilla::ipc::GeckoChildProcessHost;
+
+namespace mozilla {
+namespace _ipdltest {
+
+IPDLUnitTestSubprocess::IPDLUnitTestSubprocess() :
+    GeckoChildProcessHost(GeckoProcessType_IPDLUnitTest)
+{
+}
+
+IPDLUnitTestSubprocess::~IPDLUnitTestSubprocess()
+{
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTestSubprocess.h b/ipc/ipdl/test/cxx/IPDLUnitTestSubprocess.h
new file mode 100644
index 000000000..cdb212df2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTestSubprocess.h
@@ -0,0 +1,37 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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/. */
+
+#ifndef mozilla__ipdltest_IPDLUnitTestTestSubprocess_h
+#define mozilla__ipdltest_IPDLUnitTestTestSubprocess_h 1
+
+
+#include "mozilla/ipc/GeckoChildProcessHost.h"
+
+namespace mozilla {
+namespace _ipdltest {
+//-----------------------------------------------------------------------------
+
+class IPDLUnitTestSubprocess : public mozilla::ipc::GeckoChildProcessHost
+{
+public:
+  IPDLUnitTestSubprocess();
+  ~IPDLUnitTestSubprocess();
+
+  /**
+   * Asynchronously launch the plugin process.
+   */
+  // Could override parent Launch, but don't need to here
+  //bool Launch();
+
+private:
+  DISALLOW_EVIL_CONSTRUCTORS(IPDLUnitTestSubprocess);
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_IPDLUnitTestTestSubprocess_h
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTestTypes.h b/ipc/ipdl/test/cxx/IPDLUnitTestTypes.h
new file mode 100644
index 000000000..6da135a0a
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTestTypes.h
@@ -0,0 +1,44 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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/. */
+
+#ifndef mozilla__ipdltest_IPDLUnitTestTypes_h
+#define mozilla__ipdltest_IPDLUnitTestTypes_h
+
+#include "mozilla/ipc/ProtocolUtils.h" // ActorDestroyReason
+
+namespace mozilla {
+namespace _ipdltest {
+
+struct DirtyRect
+{
+  int x; int y; int w; int h;
+};
+
+}
+}
+
+namespace IPC {
+template<>
+struct ParamTraits<mozilla::_ipdltest::DirtyRect>
+{
+  typedef mozilla::_ipdltest::DirtyRect paramType;
+  static void Write(Message* aMsg, const paramType& aParam) {
+    WriteParam(aMsg, aParam.x);
+    WriteParam(aMsg, aParam.y);
+    WriteParam(aMsg, aParam.w);
+    WriteParam(aMsg, aParam.h);
+  }
+  static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
+  {
+    return (ReadParam(aMsg, aIter, &aResult->x) &&
+            ReadParam(aMsg, aIter, &aResult->y) &&
+            ReadParam(aMsg, aIter, &aResult->w) &&
+            ReadParam(aMsg, aIter, &aResult->h));
+  }
+};
+}
+
+
+#endif // ifndef mozilla__ipdltest_IPDLUnitTestTypes_h
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTestUtils.h b/ipc/ipdl/test/cxx/IPDLUnitTestUtils.h
new file mode 100644
index 000000000..ad9da374d
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTestUtils.h
@@ -0,0 +1,27 @@
+
+#ifndef mozilla__ipdltest_IPDLUnitTestUtils
+#define mozilla__ipdltest_IPDLUnitTestUtils 1
+
+namespace mozilla {
+namespace _ipdltest {
+
+struct Bad {};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+namespace IPC {
+
+template<>
+struct ParamTraits<mozilla::_ipdltest::Bad>
+{
+  typedef mozilla::_ipdltest::Bad paramType;
+
+  // Defined in TestActorPunning.cpp.
+  static void Write(Message* aMsg, const paramType& aParam);
+  static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult);
+};
+
+} // namespace IPC
+
+#endif // mozilla__ipdltest_IPDLUnitTestUtils
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTests.h b/ipc/ipdl/test/cxx/IPDLUnitTests.h
new file mode 100644
index 000000000..544bc0ffb
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTests.h
@@ -0,0 +1,93 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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/. */
+
+#ifndef mozilla__ipdltest_IPDLUnitTests_h
+#define mozilla__ipdltest_IPDLUnitTests_h 1
+
+#include "base/message_loop.h"
+#include "base/process.h"
+#include "chrome/common/ipc_channel.h"
+
+#include "nsIAppShell.h"
+
+#include "nsCOMPtr.h"
+#include "nsDebug.h"
+#include "nsServiceManagerUtils.h" // do_GetService()
+#include "nsWidgetsCID.h"       // NS_APPSHELL_CID
+#include "nsXULAppAPI.h"
+
+
+#define MOZ_IPDL_TESTFAIL_LABEL "TEST-UNEXPECTED-FAIL"
+#define MOZ_IPDL_TESTPASS_LABEL "TEST-PASS"
+#define MOZ_IPDL_TESTINFO_LABEL "TEST-INFO"
+
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// both processes
+const char* IPDLUnitTestName();
+
+// NB: these are named like the similar functions in
+// xpcom/test/TestHarness.h.  The names should nominally be kept in
+// sync.
+
+inline void fail(const char* fmt, ...)
+{
+  va_list ap;
+
+  fprintf(stderr, MOZ_IPDL_TESTFAIL_LABEL " | %s | ", IPDLUnitTestName());
+
+  va_start(ap, fmt);
+  vfprintf(stderr, fmt, ap);
+  va_end(ap);
+
+  fputc('\n', stderr);
+
+  NS_RUNTIMEABORT("failed test");
+}
+
+inline void passed(const char* fmt, ...)
+{
+  va_list ap;
+
+  printf(MOZ_IPDL_TESTPASS_LABEL " | %s | ", IPDLUnitTestName());
+
+  va_start(ap, fmt);
+  vprintf(fmt, ap);
+  va_end(ap);
+
+  fputc('\n', stdout);
+}
+
+//-----------------------------------------------------------------------------
+// parent process only
+
+class IPDLUnitTestSubprocess;
+
+extern void* gParentActor;
+extern IPDLUnitTestSubprocess* gSubprocess;
+
+void IPDLUnitTestMain(void* aData);
+
+void QuitParent();
+
+//-----------------------------------------------------------------------------
+// child process only
+
+extern void* gChildActor;
+
+void IPDLUnitTestChildInit(IPC::Channel* transport,
+                           base::ProcessId parentPid,
+                           MessageLoop* worker);
+
+void QuitChild();
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_IPDLUnitTests_h
diff --git a/ipc/ipdl/test/cxx/IPDLUnitTests.template.cpp b/ipc/ipdl/test/cxx/IPDLUnitTests.template.cpp
new file mode 100644
index 000000000..6a91033bf
--- /dev/null
+++ b/ipc/ipdl/test/cxx/IPDLUnitTests.template.cpp
@@ -0,0 +1,390 @@
+//
+// Autogenerated from Python template.  Hands off.
+//
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "IPDLUnitTests.h"
+
+#include "base/command_line.h"
+#include "base/string_util.h"
+#include "base/task.h"
+#include "base/thread.h"
+
+#include "nsRegion.h"
+
+#include "IPDLUnitTestSubprocess.h"
+
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${INCLUDES}
+//-----------------------------------------------------------------------------
+
+using namespace std;
+
+using base::Thread;
+
+namespace mozilla {
+namespace _ipdltest {
+
+void* gParentActor;
+IPDLUnitTestSubprocess* gSubprocess;
+
+void* gChildActor;
+
+// Note: in threaded mode, this will be non-null (for both parent and
+// child, since they share one set of globals).  
+Thread* gChildThread;
+MessageLoop *gParentMessageLoop;
+bool gParentDone;
+bool gChildDone;
+
+void
+DeleteChildActor();
+
+//-----------------------------------------------------------------------------
+// data/functions accessed by both parent and child processes
+
+char* gIPDLUnitTestName = nullptr;
+
+const char*
+IPDLUnitTestName()
+{
+    if (!gIPDLUnitTestName) {
+#if defined(OS_WIN)
+        vector<wstring> args =
+            CommandLine::ForCurrentProcess()->GetLooseValues();
+        gIPDLUnitTestName = ::strdup(WideToUTF8(args[0]).c_str());
+#elif defined(OS_POSIX)
+        vector<string> argv = CommandLine::ForCurrentProcess()->argv();
+        gIPDLUnitTestName = ::moz_xstrdup(argv[1].c_str());
+#else
+#  error Sorry
+#endif
+    }
+    return gIPDLUnitTestName;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+namespace {
+
+enum IPDLUnitTestType {
+    NoneTest = 0,
+
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${ENUM_VALUES}
+    
+    LastTest = ${LAST_ENUM}
+//-----------------------------------------------------------------------------
+};
+
+
+IPDLUnitTestType
+IPDLUnitTestFromString(const char* const aString)
+{
+    if (!aString)
+        return static_cast<IPDLUnitTestType>(0);
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${STRING_TO_ENUMS}
+//-----------------------------------------------------------------------------
+    else
+        return static_cast<IPDLUnitTestType>(0);
+}
+
+
+const char*
+IPDLUnitTestToString(IPDLUnitTestType aTest)
+{
+    switch (aTest) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${ENUM_TO_STRINGS}
+//-----------------------------------------------------------------------------
+
+    default:
+        return nullptr;
+    }
+}
+
+
+IPDLUnitTestType
+IPDLUnitTest()
+{
+    return IPDLUnitTestFromString(::mozilla::_ipdltest::IPDLUnitTestName());
+}
+
+
+} // namespace <anon>
+
+
+//-----------------------------------------------------------------------------
+// parent process only
+
+namespace mozilla {
+namespace _ipdltest {
+
+void
+DeferredParentShutdown();
+
+void
+IPDLUnitTestThreadMain(char *testString);
+
+void
+IPDLUnitTestMain(void* aData)
+{
+    char* testString = reinterpret_cast<char*>(aData);
+
+    // Check if we are to run the test using threads instead:
+    const char *prefix = "thread:";
+    const int prefixLen = strlen(prefix);
+    if (!strncmp(testString, prefix, prefixLen)) {
+        IPDLUnitTestThreadMain(testString + prefixLen);
+        return;
+    }
+
+    IPDLUnitTestType test = IPDLUnitTestFromString(testString);
+    if (!test) {
+        // use this instead of |fail()| because we don't know what the test is
+        fprintf(stderr, MOZ_IPDL_TESTFAIL_LABEL "| %s | unknown unit test %s\n",
+                "<--->", testString);
+        NS_RUNTIMEABORT("can't continue");
+    }
+    gIPDLUnitTestName = testString;
+
+    // Check whether this test is enabled for processes:
+    switch (test) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${PARENT_ENABLED_CASES_PROC}
+//-----------------------------------------------------------------------------
+
+    default:
+        fail("not reached");
+        return;                 // unreached
+    }
+
+    printf(MOZ_IPDL_TESTINFO_LABEL "| running test | %s\n", gIPDLUnitTestName);
+
+    std::vector<std::string> testCaseArgs;
+    testCaseArgs.push_back(testString);
+
+    gSubprocess = new IPDLUnitTestSubprocess();
+    if (!gSubprocess->SyncLaunch(testCaseArgs))
+        fail("problem launching subprocess");
+
+    IPC::Channel* transport = gSubprocess->GetChannel();
+    if (!transport)
+        fail("no transport");
+
+    base::ProcessId child = base::GetProcId(gSubprocess->GetChildProcessHandle());
+
+    switch (test) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${PARENT_MAIN_CASES_PROC}
+//-----------------------------------------------------------------------------
+
+    default:
+        fail("not reached");
+        return;                 // unreached
+    }
+}
+
+void
+IPDLUnitTestThreadMain(char *testString)
+{
+    IPDLUnitTestType test = IPDLUnitTestFromString(testString);
+    if (!test) {
+        // use this instead of |fail()| because we don't know what the test is
+        fprintf(stderr, MOZ_IPDL_TESTFAIL_LABEL "| %s | unknown unit test %s\n",
+                "<--->", testString);
+        NS_RUNTIMEABORT("can't continue");
+    }
+    gIPDLUnitTestName = testString;
+
+    // Check whether this test is enabled for threads:
+    switch (test) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${PARENT_ENABLED_CASES_THREAD}
+//-----------------------------------------------------------------------------
+
+    default:
+        fail("not reached");
+        return;                 // unreached
+    }
+
+    printf(MOZ_IPDL_TESTINFO_LABEL "| running test | %s\n", gIPDLUnitTestName);
+
+    std::vector<std::string> testCaseArgs;
+    testCaseArgs.push_back(testString);
+
+    gChildThread = new Thread("ParentThread");
+    if (!gChildThread->Start())
+        fail("starting parent thread");
+
+    gParentMessageLoop = MessageLoop::current();
+    MessageLoop *childMessageLoop = gChildThread->message_loop();
+
+    switch (test) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${PARENT_MAIN_CASES_THREAD}
+//-----------------------------------------------------------------------------
+
+    default:
+        fail("not reached");
+        return;                 // unreached
+    }
+}
+
+void
+DeleteParentActor()
+{
+    if (!gParentActor)
+        return;
+
+    switch (IPDLUnitTest()) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${PARENT_DELETE_CASES}
+//-----------------------------------------------------------------------------
+    default:  ::mozilla::_ipdltest::fail("???");
+    }
+}
+
+void
+QuitXPCOM()
+{
+  DeleteParentActor();
+
+  static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
+  nsCOMPtr<nsIAppShell> appShell (do_GetService(kAppShellCID));
+  appShell->Exit();
+}
+
+void
+DeleteSubprocess(MessageLoop* uiLoop)
+{
+  // pong to QuitXPCOM
+  delete gSubprocess;
+  uiLoop->PostTask(NewRunnableFunction(QuitXPCOM));
+}
+
+void
+DeferredParentShutdown()
+{
+    // ping to DeleteSubprocess
+    XRE_GetIOMessageLoop()->PostTask(
+        NewRunnableFunction(DeleteSubprocess, MessageLoop::current()));
+}
+
+void 
+TryThreadedShutdown()
+{
+    // Stop if either: 
+    // - the child has not finished, 
+    // - the parent has not finished,
+    // - or this code has already executed.
+    // Remember: this TryThreadedShutdown() task is enqueued
+    // by both parent and child (though always on parent's msg loop).
+    if (!gChildDone || !gParentDone || !gChildThread)
+        return;
+
+    delete gChildThread;
+    gChildThread = 0;
+    DeferredParentShutdown();
+}
+
+void 
+ChildCompleted()
+{
+    // Executes on the parent message loop once child has completed.
+    gChildDone = true;
+    TryThreadedShutdown();
+}
+
+void
+QuitParent()
+{
+    if (gChildThread) {
+        gParentDone = true;
+        MessageLoop::current()->PostTask(
+            NewRunnableFunction(TryThreadedShutdown));
+    } else {
+        // defer "real" shutdown to avoid *Channel::Close() racing with the
+        // deletion of the subprocess
+        MessageLoop::current()->PostTask(
+            NewRunnableFunction(DeferredParentShutdown));
+    }
+}
+
+static void
+ChildDie()
+{
+    DeleteChildActor();
+    XRE_ShutdownChildProcess();
+}
+
+void
+QuitChild()
+{
+    if (gChildThread) { // Threaded-mode test
+        gParentMessageLoop->PostTask(
+            NewRunnableFunction(ChildCompleted));
+    } else { // Process-mode test
+        MessageLoop::current()->PostTask(
+            NewRunnableFunction(ChildDie));
+    }
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+//-----------------------------------------------------------------------------
+// child process only
+
+namespace mozilla {
+namespace _ipdltest {
+
+void
+DeleteChildActor()
+{
+    if (!gChildActor)
+        return;
+
+    switch (IPDLUnitTest()) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${CHILD_DELETE_CASES}
+//-----------------------------------------------------------------------------
+    default:  ::mozilla::_ipdltest::fail("???");
+    }
+}
+
+void
+IPDLUnitTestChildInit(IPC::Channel* transport,
+                      base::ProcessId parentPid,
+                      MessageLoop* worker)
+{
+    switch (IPDLUnitTest()) {
+//-----------------------------------------------------------------------------
+//===== TEMPLATED =====
+${CHILD_INIT_CASES}
+//-----------------------------------------------------------------------------
+
+    default:
+        fail("not reached");
+        return;                 // unreached
+    }
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/Makefile.in b/ipc/ipdl/test/cxx/Makefile.in
new file mode 100644
index 000000000..8c9cdaa99
--- /dev/null
+++ b/ipc/ipdl/test/cxx/Makefile.in
@@ -0,0 +1,46 @@
+# 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/.
+
+IPDLTESTSRCS = $(filter Test%,$(CPPSRCS))
+IPDLTESTS = $(IPDLTESTSRCS:.cpp=)
+
+EXTRA_PROTOCOLS = \
+  TestBridgeSub \
+  TestEndpointBridgeSub \
+  $(NULL)
+
+IPDLTESTHDRS = $(addprefix $(srcdir)/,$(addsuffix .h,$(IPDLTESTS)))
+
+TESTER_TEMPLATE := $(srcdir)/IPDLUnitTests.template.cpp
+GENTESTER := $(srcdir)/genIPDLUnitTests.py
+
+include $(topsrcdir)/config/rules.mk
+
+
+IPDLUNITTEST_BIN = $(DEPTH)/dist/bin/ipdlunittest$(BIN_SUFFIX)
+
+IPDLUnitTests.cpp : Makefile.in moz.build $(GENTESTER) $(TESTER_TEMPLATE) $(IPDLTESTHDRS)
+	$(PYTHON) $(GENTESTER) $(TESTER_TEMPLATE) -t $(IPDLTESTS) -e $(EXTRA_PROTOCOLS) > $@
+
+check-proc::
+	@$(EXIT_ON_ERROR)  \
+	for test in $(IPDLTESTS); do  \
+		 $(RUN_TEST_PROGRAM) $(IPDLUNITTEST_BIN) $$test ;  \
+	done
+
+check-thread::
+	@$(EXIT_ON_ERROR)  \
+	for test in $(IPDLTESTS); do  \
+		 $(RUN_TEST_PROGRAM) $(IPDLUNITTEST_BIN) thread:$$test ;  \
+	done
+
+check:: check-proc check-thread
+
+check-valgrind::
+	@$(EXIT_ON_ERROR)  \
+	for test in $(IPDLTESTS); do  \
+		 $(RUN_TEST_PROGRAM) -g -d \
+                   valgrind -a '--leak-check=full --trace-children=yes -q' \
+                   $(IPDLUNITTEST_BIN) $$test ;  \
+	done
diff --git a/ipc/ipdl/test/cxx/PTestActorPunning.ipdl b/ipc/ipdl/test/cxx/PTestActorPunning.ipdl
new file mode 100644
index 000000000..54deb277a
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestActorPunning.ipdl
@@ -0,0 +1,39 @@
+
+include protocol PTestActorPunningPunned;
+include protocol PTestActorPunningSub;
+include "mozilla/_ipdltest/IPDLUnitTestUtils.h";
+
+using struct mozilla::_ipdltest::Bad from "mozilla/_ipdltest/IPDLUnitTestUtils.h";
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestActorPunning {
+    manages PTestActorPunningPunned;
+    manages PTestActorPunningSub;
+
+child:
+    async Start();
+
+parent:
+    async PTestActorPunningPunned();
+    async PTestActorPunningSub();
+    async Pun(PTestActorPunningSub a, Bad bad);
+    async __delete__();
+
+
+state PING:
+    send Start goto CONSTRUCTING;
+
+state CONSTRUCTING:
+    recv PTestActorPunningPunned goto CONSTRUCTING;
+    recv PTestActorPunningSub goto CONSTRUCTING;
+    recv Pun goto DEAD;
+    // We never make it past this transition, --> error.
+
+state DEAD:
+    recv __delete__;
+};
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestActorPunningPunned.ipdl b/ipc/ipdl/test/cxx/PTestActorPunningPunned.ipdl
new file mode 100644
index 000000000..a6b875920
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestActorPunningPunned.ipdl
@@ -0,0 +1,15 @@
+
+include protocol PTestActorPunning;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestActorPunningPunned {
+    manager PTestActorPunning;
+
+child:
+    async __delete__();
+};
+
+} // namespace mozilla
+} // namespace _ipdltes
diff --git a/ipc/ipdl/test/cxx/PTestActorPunningSub.ipdl b/ipc/ipdl/test/cxx/PTestActorPunningSub.ipdl
new file mode 100644
index 000000000..1441219c3
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestActorPunningSub.ipdl
@@ -0,0 +1,16 @@
+
+include protocol PTestActorPunning;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestActorPunningSub {
+    manager PTestActorPunning;
+
+child:
+    async Bad();
+    async __delete__();
+};
+
+} // namespace mozilla
+} // namespace _ipdltes
diff --git a/ipc/ipdl/test/cxx/PTestBadActor.ipdl b/ipc/ipdl/test/cxx/PTestBadActor.ipdl
new file mode 100644
index 000000000..841d89ff6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestBadActor.ipdl
@@ -0,0 +1,18 @@
+include protocol PTestBadActorSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+// Test that a parent sending a reentrant __delete__ message
+// is not killed if a child's message races with the reply.
+
+intr protocol PTestBadActor {
+  manages PTestBadActorSub;
+
+child:
+  async PTestBadActorSub();
+  async __delete__();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl b/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
new file mode 100644
index 000000000..99c78f4ac
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestBadActorSub.ipdl
@@ -0,0 +1,17 @@
+include protocol PTestBadActor;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestBadActorSub {
+  manager PTestBadActor;
+
+child:
+  intr __delete__();
+
+parent:
+  async Ping();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestBridgeMain.ipdl b/ipc/ipdl/test/cxx/PTestBridgeMain.ipdl
new file mode 100644
index 000000000..229820b17
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestBridgeMain.ipdl
@@ -0,0 +1,26 @@
+include protocol PTestBridgeMainSub;
+include protocol PTestBridgeSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestBridgeMain {
+    child spawns PTestBridgeSub;
+    child opens PTestBridgeMainSub;
+
+child:
+    async Start();
+
+parent:
+    async __delete__();
+
+state START:
+    send Start goto DEAD;
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl b/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
new file mode 100644
index 000000000..67e50fdd4
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestBridgeMainSub.ipdl
@@ -0,0 +1,33 @@
+include protocol PTestBridgeMain;
+include protocol PTestBridgeSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+// (Bridge protocols can have different semantics than the endpoints
+// they bridge)
+intr protocol PTestBridgeMainSub {
+    bridges PTestBridgeMain, PTestBridgeSub;
+
+child:
+    async Hi();
+    intr HiRpc();
+
+parent:
+    async Hello();
+    sync HelloSync();
+    intr HelloRpc();
+    async __delete__();
+
+state START:       recv Hello goto HI;
+state HI:          send Hi goto HELLO_SYNC;
+state HELLO_SYNC:  recv HelloSync goto HELLO_RPC;
+state HELLO_RPC:   answer HelloRpc goto HI_RPC;
+state HI_RPC:      call HiRpc goto DEAD;
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestBridgeSub.ipdl b/ipc/ipdl/test/cxx/PTestBridgeSub.ipdl
new file mode 100644
index 000000000..6c798c84e
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestBridgeSub.ipdl
@@ -0,0 +1,25 @@
+include protocol PTestBridgeMainSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestBridgeSub {
+child:
+    async Ping();
+
+parent:
+    async BridgeEm();
+    async __delete__();
+
+state START:
+    send Ping goto BRIDGEEM;
+state BRIDGEEM:
+    recv BridgeEm goto DEAD;
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestCancel.ipdl b/ipc/ipdl/test/cxx/PTestCancel.ipdl
new file mode 100644
index 000000000..3a6b46b43
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestCancel.ipdl
@@ -0,0 +1,36 @@
+namespace mozilla {
+namespace _ipdltest {
+
+nested(upto inside_sync) sync protocol PTestCancel
+{
+// Test1
+child:
+    nested(inside_sync) sync Test1_1();
+parent:
+    async Done1();
+
+// Test2
+child:
+    async Start2();
+    nested(inside_sync) sync Test2_2();
+parent:
+    sync Test2_1();
+
+// Test3
+child:
+    nested(inside_sync) sync Test3_1();
+parent:
+    async Start3();
+    nested(inside_sync) sync Test3_2();
+
+parent:
+    async Done();
+
+child:
+    nested(inside_sync) sync CheckChild() returns (uint32_t reply);
+parent:
+    nested(inside_sync) sync CheckParent() returns (uint32_t reply);
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl b/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
new file mode 100644
index 000000000..eae428211
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestCrashCleanup.ipdl
@@ -0,0 +1,22 @@
+// See bug 538586: if the top-level protocol's actor is deleted before
+// the "connection error" notification comes in from the IO thread,
+// IPDL teardown never occurs, even if Channel::Close() is called
+// after the error.
+
+namespace mozilla {
+namespace _ipdltest {
+
+// NB: needs to be RPC so that the parent blocks on the child's crash.
+intr protocol PTestCrashCleanup {
+child:
+    intr DIEDIEDIE();
+    async __delete__();
+
+state ALIVE:
+    call DIEDIEDIE goto CRASH;
+state CRASH:
+    send __delete__;
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestDataStructures.ipdl b/ipc/ipdl/test/cxx/PTestDataStructures.ipdl
new file mode 100644
index 000000000..59bf74652
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDataStructures.ipdl
@@ -0,0 +1,132 @@
+include protocol PTestDataStructuresSub;
+include PTestDataStructuresCommon;
+
+include "mozilla/GfxMessageUtils.h";
+
+namespace mozilla {
+namespace _ipdltest {
+
+sync protocol PTestDataStructures {
+    manages PTestDataStructuresSub;
+
+child:
+    async PTestDataStructuresSub(int i);
+
+    async Start();
+
+parent:
+    async __delete__();
+
+    sync Test1(int[] i1)
+        returns (int[] o1);
+
+    sync Test2(PTestDataStructuresSub[] i1)
+        returns (PTestDataStructuresSub[] o1);
+
+    sync Test3(IntDouble i1,
+               IntDouble i2)
+        returns (IntDouble o1,
+                 IntDouble o2);
+
+    sync Test4(IntDouble[] i1)
+        returns (IntDouble[] o1);
+
+    sync Test5(IntDoubleArrays i1,
+               IntDoubleArrays i2,
+               IntDoubleArrays i3)
+        returns (IntDoubleArrays o1,
+                 IntDoubleArrays o2,
+                 IntDoubleArrays o3);
+
+    sync Test6(IntDoubleArrays[] i1)
+        returns (IntDoubleArrays[] o1);
+
+    sync Test7_0(ActorWrapper a1)
+        returns (ActorWrapper o1);
+
+    sync Test7(Actors i1,
+               Actors i2,
+               Actors i3)
+        returns (Actors o1,
+                 Actors o2,
+                 Actors o3);
+
+    sync Test8(Actors[] i1)
+        returns (Actors[] o1);
+
+    sync Test9(Unions i1,
+               Unions i2,
+               Unions i3,
+               Unions i4)
+        returns (Unions o1,
+                 Unions o2,
+                 Unions o3,
+                 Unions o4);
+
+    sync Test10(Unions[] i1)
+        returns (Unions[] o1);
+
+    sync Test11(SIntDouble i)
+        returns (SIntDouble o);
+
+    sync Test12(SIntDoubleArrays i)
+        returns (SIntDoubleArrays o);
+
+    sync Test13(SActors i)
+        returns (SActors o);
+
+    sync Test14(Structs i)
+        returns (Structs o);
+
+    sync Test15(WithStructs i1,
+                WithStructs i2,
+                WithStructs i3,
+                WithStructs i4,
+                WithStructs i5)
+        returns (WithStructs o1,
+                 WithStructs o2,
+                 WithStructs o3,
+                 WithStructs o4,
+                 WithStructs o5);
+
+    sync Test16(WithUnions i)
+        returns (WithUnions o);
+
+    sync Test17(Op[] ops);
+
+    // test that the ParamTraits<nsTArray>::Read() workaround for
+    // nsTArray's incorrect memmove() semantics works properly
+    // (nsIntRegion isn't memmove()able)
+    sync Test18(nsIntRegion[] ops);
+
+    sync Dummy(ShmemUnion su) returns (ShmemUnion rsu);
+
+state CONSTRUCTING:
+    send PTestDataStructuresSub goto CONSTRUCTING;
+    send Start goto TEST1;
+state TEST1:   recv Test1 goto TEST2;
+state TEST2:   recv Test2 goto TEST3;
+state TEST3:   recv Test3 goto TEST4;
+state TEST4:   recv Test4 goto TEST5;
+state TEST5:   recv Test5 goto TEST6;
+state TEST6:   recv Test6 goto TEST7;
+state TEST7:   recv Test7 goto TEST8;
+state TEST8:   recv Test8 goto TEST9;
+state TEST9:   recv Test9 goto TEST10;
+state TEST10:  recv Test10 goto TEST11;
+state TEST11:  recv Test11 goto TEST12;
+state TEST12:  recv Test12 goto TEST13;
+state TEST13:  recv Test13 goto TEST14;
+state TEST14:  recv Test14 goto TEST15;
+state TEST15:  recv Test15 goto TEST16;
+state TEST16:  recv Test16 goto TEST17;
+state TEST17:  recv Test17 goto TEST18;
+state TEST18:  recv Test18 goto DEAD;
+
+state DEAD:
+    recv __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
diff --git a/ipc/ipdl/test/cxx/PTestDataStructuresCommon.ipdlh b/ipc/ipdl/test/cxx/PTestDataStructuresCommon.ipdlh
new file mode 100644
index 000000000..891b0c991
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDataStructuresCommon.ipdlh
@@ -0,0 +1,107 @@
+include protocol PTestDataStructuresSub;
+
+using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
+using nsIntRegion from "nsRegion.h";
+
+namespace mozilla {
+namespace _foo {
+
+union IntDouble {
+    int;
+    double;
+};
+
+struct SIntDouble {
+    int i;
+    double d;
+};
+
+union IntDoubleArrays {
+    int;
+    int[];
+    double[];
+};
+
+struct SIntDoubleArrays {
+    int i;
+    int[] ai;
+    double[] ad;
+};
+
+struct ActorWrapper {
+    PTestDataStructuresSub actor;
+};
+
+union Actors {
+    int;
+    int[];
+    PTestDataStructuresSub[];
+};
+
+struct SActors {
+    int i;
+    int[] ai;
+    PTestDataStructuresSub[] ap;
+};
+
+union Unions {
+    int;
+    int[];
+    PTestDataStructuresSub[];
+    Actors[];
+};
+
+struct Structs {
+    int i;
+    int[] ai;
+    PTestDataStructuresSub[] ap;
+    SActors[] aa;
+};
+
+union WithStructs {
+    int;
+    int[];
+    PTestDataStructuresSub[];
+    SActors[];
+    Structs[];
+};
+
+struct WithUnions {
+    int i;
+    int[] ai;
+    PTestDataStructuresSub[] ap;
+    Actors[] aa;
+    Unions[] au;
+};
+
+struct CommonAttrs { bool dummy; };
+struct FooAttrs { int dummy; };
+struct BarAttrs { float dummy; };
+union SpecificAttrs {
+    FooAttrs;
+    BarAttrs;
+};
+struct Attrs {
+    CommonAttrs common;
+    SpecificAttrs specific;
+};
+struct SetAttrs {
+    PTestDataStructuresSub x;
+    Attrs attrs;
+};
+union Op { null_t; SetAttrs; };
+
+struct ShmemStruct {
+    int i;
+    Shmem mem;
+};
+
+union ShmemUnion {
+    int;
+    Shmem;
+};
+
+struct Empty { };
+
+} // namespace _foo
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestDataStructuresSub.ipdl b/ipc/ipdl/test/cxx/PTestDataStructuresSub.ipdl
new file mode 100644
index 000000000..7a4e87d83
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDataStructuresSub.ipdl
@@ -0,0 +1,15 @@
+include PTestDataStructuresCommon;
+include protocol PTestDataStructures;
+
+namespace mozilla {
+namespace _ipdltest {
+
+sync protocol PTestDataStructuresSub {
+    manager PTestDataStructures;
+
+parent:
+    sync __delete__();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestDemon.ipdl b/ipc/ipdl/test/cxx/PTestDemon.ipdl
new file mode 100644
index 000000000..25fa5d0f9
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDemon.ipdl
@@ -0,0 +1,21 @@
+namespace mozilla {
+namespace _ipdltest {
+
+nested(upto inside_cpow) sync protocol PTestDemon
+{
+child:
+    async Start();
+
+both:
+    async AsyncMessage(int n);
+    nested(inside_sync) sync HiPrioSyncMessage();
+
+parent:
+    sync SyncMessage(int n);
+
+    nested(inside_cpow) async UrgentAsyncMessage(int n);
+    nested(inside_cpow) sync UrgentSyncMessage(int n);
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestDesc.ipdl b/ipc/ipdl/test/cxx/PTestDesc.ipdl
new file mode 100644
index 000000000..835c8c62d
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDesc.ipdl
@@ -0,0 +1,31 @@
+include protocol PTestDescSub;
+include protocol PTestDescSubsub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestDesc {
+    manages PTestDescSub; 
+child:
+    intr PTestDescSub(nullable PTestDescSubsub dummy);
+
+    async Test(PTestDescSubsub a);
+
+    async __delete__();
+
+parent:
+    async Ok(PTestDescSubsub a);
+
+
+state CONSTRUCT:
+    call PTestDescSub goto TEST;
+state TEST:
+    send Test goto ACK;
+state ACK:
+    recv Ok goto DEAD;
+state DEAD:
+    send __delete__;
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestDescSub.ipdl b/ipc/ipdl/test/cxx/PTestDescSub.ipdl
new file mode 100644
index 000000000..67d4fe166
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDescSub.ipdl
@@ -0,0 +1,18 @@
+include protocol PTestDesc;
+include protocol PTestDescSubsub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestDescSub {
+    manager PTestDesc;
+    manages PTestDescSubsub;
+
+child:
+    async __delete__();
+
+    intr PTestDescSubsub();
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestDescSubsub.ipdl b/ipc/ipdl/test/cxx/PTestDescSubsub.ipdl
new file mode 100644
index 000000000..c449f2744
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestDescSubsub.ipdl
@@ -0,0 +1,15 @@
+
+include protocol PTestDescSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestDescSubsub {
+    manager PTestDescSub;
+
+child:
+    intr __delete__();
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestEndpointBridgeMain.ipdl b/ipc/ipdl/test/cxx/PTestEndpointBridgeMain.ipdl
new file mode 100644
index 000000000..e8026a0d0
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestEndpointBridgeMain.ipdl
@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+include protocol PTestEndpointBridgeMainSub;
+include protocol PTestEndpointBridgeSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestEndpointBridgeMain {
+  child spawns PTestEndpointBridgeSub;
+
+child:
+  async Start();
+
+parent:
+  async Bridged(Endpoint<PTestEndpointBridgeMainSubParent> endpoint);
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestEndpointBridgeMainSub.ipdl b/ipc/ipdl/test/cxx/PTestEndpointBridgeMainSub.ipdl
new file mode 100644
index 000000000..7364057ac
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestEndpointBridgeMainSub.ipdl
@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+include protocol PTestEndpointBridgeMain;
+include protocol PTestEndpointBridgeSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+// (Bridge protocols can have different semantics than the endpoints
+// they bridge)
+intr protocol PTestEndpointBridgeMainSub {
+child:
+  async Hi();
+  intr HiRpc();
+
+parent:
+  async Hello();
+  sync HelloSync();
+  intr HelloRpc();
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestEndpointBridgeSub.ipdl b/ipc/ipdl/test/cxx/PTestEndpointBridgeSub.ipdl
new file mode 100644
index 000000000..0bc09b70e
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestEndpointBridgeSub.ipdl
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+include protocol PTestEndpointBridgeMainSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestEndpointBridgeSub {
+child:
+  async Ping();
+
+  async Bridged(Endpoint<PTestEndpointBridgeMainSubChild> endpoint);
+
+parent:
+  async BridgeEm();
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestEndpointOpens.ipdl b/ipc/ipdl/test/cxx/PTestEndpointOpens.ipdl
new file mode 100644
index 000000000..7be99ddd2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestEndpointOpens.ipdl
@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+include protocol PTestEndpointOpensOpened;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestEndpointOpens {
+child:
+  async Start();
+
+parent:
+  async StartSubprotocol(Endpoint<PTestEndpointOpensOpenedParent> endpoint);
+
+  async __delete__();
+};
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestEndpointOpensOpened.ipdl b/ipc/ipdl/test/cxx/PTestEndpointOpensOpened.ipdl
new file mode 100644
index 000000000..e14c0cb8a
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestEndpointOpensOpened.ipdl
@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+namespace mozilla {
+namespace _ipdltest2 {
+
+// (Opens protocols can have different semantics than the endpoints
+// that opened them)
+intr protocol PTestEndpointOpensOpened {
+child:
+    async Hi();
+    intr HiRpc();
+
+parent:
+    async Hello();
+    sync HelloSync();
+    intr HelloRpc();
+    async __delete__();
+
+state START:       recv Hello goto HI;
+state HI:          send Hi goto HELLO_SYNC;
+state HELLO_SYNC:  recv HelloSync goto HELLO_RPC;
+state HELLO_RPC:   answer HelloRpc goto HI_RPC;
+state HI_RPC:      call HiRpc goto DEAD;
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest2
diff --git a/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl b/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
new file mode 100644
index 000000000..94b9da081
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestFailedCtor.ipdl
@@ -0,0 +1,19 @@
+include protocol PTestFailedCtorSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestFailedCtor {
+    manages PTestFailedCtorSub; 
+child:
+    intr PTestFailedCtorSub();
+    async __delete__();
+
+state CONSTRUCT:
+    call PTestFailedCtorSub goto DEAD;
+state DEAD:
+    send __delete__;
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl b/ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl
new file mode 100644
index 000000000..b1d18a05f
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestFailedCtorSub.ipdl
@@ -0,0 +1,18 @@
+include protocol PTestFailedCtor;
+include protocol PTestFailedCtorSubsub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestFailedCtorSub {
+    manager PTestFailedCtor;
+    manages PTestFailedCtorSubsub;
+
+parent:
+    async PTestFailedCtorSubsub();
+    sync Sync();
+    async __delete__();
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl b/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
new file mode 100644
index 000000000..654170d97
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestFailedCtorSubsub.ipdl
@@ -0,0 +1,15 @@
+
+include protocol PTestFailedCtorSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestFailedCtorSubsub {
+    manager PTestFailedCtorSub;
+
+parent:
+     async __delete__();
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestHandle.ipdl b/ipc/ipdl/test/cxx/PTestHandle.ipdl
new file mode 100644
index 000000000..aad92bae1
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestHandle.ipdl
@@ -0,0 +1,14 @@
+include protocol PTestJSON;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestHandle {
+    manager PTestJSON;
+
+child:
+    async __delete__();
+};
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestHangs.ipdl b/ipc/ipdl/test/cxx/PTestHangs.ipdl
new file mode 100644
index 000000000..b1b43fa75
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestHangs.ipdl
@@ -0,0 +1,40 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestHangs {
+both:
+    intr StackFrame();
+
+parent:
+    async Nonce();
+
+child:
+    async Start();
+    intr Hang();
+    async __delete__();
+
+
+state START:
+    send Start goto RACE;
+
+state RACE:
+    recv Nonce goto RACE1;
+    call StackFrame goto RACE2;
+state RACE1:
+    call StackFrame goto FRAME2;
+state RACE2:
+    recv Nonce goto FRAME2;
+
+// So as to test unwinding the RPC stack
+state FRAME2: answer StackFrame goto FRAME3;
+state FRAME3: call StackFrame goto FRAME4;
+state FRAME4: answer StackFrame goto HANG;
+state HANG:   call Hang goto DEATH;
+
+state DEATH:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestHighestPrio.ipdl b/ipc/ipdl/test/cxx/PTestHighestPrio.ipdl
new file mode 100644
index 000000000..0192f59b2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestHighestPrio.ipdl
@@ -0,0 +1,18 @@
+namespace mozilla {
+namespace _ipdltest {
+
+nested(upto inside_cpow) sync protocol PTestHighestPrio
+{
+parent:
+  nested(inside_cpow) async Msg1();
+  nested(inside_sync) sync Msg2();
+  nested(inside_cpow) async Msg3();
+  nested(inside_cpow) sync Msg4();
+
+child:
+  async Start();
+  nested(inside_sync) sync StartInner();
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestIndirectProtocolParam.ipdlh b/ipc/ipdl/test/cxx/PTestIndirectProtocolParam.ipdlh
new file mode 100644
index 000000000..a81fcdee4
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParam.ipdlh
@@ -0,0 +1,15 @@
+include protocol PTestIndirectProtocolParamSecond;

+

+namespace mozilla {

+namespace _ipdltest {

+

+struct IndirectParamStruct {

+    PTestIndirectProtocolParamSecond actor;

+};

+

+union IndirectParamUnion {

+    IndirectParamStruct;

+};

+

+}

+}

diff --git a/ipc/ipdl/test/cxx/PTestIndirectProtocolParamFirst.ipdl b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamFirst.ipdl
new file mode 100644
index 000000000..228ec04e8
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamFirst.ipdl
@@ -0,0 +1,19 @@
+include protocol PTestIndirectProtocolParamManage;

+// FIXME/bug 792908 protocol PTestIndirectProtocolParamSecond is

+// already included in PTestIndirectProtocolParam.ipdlh

+include protocol PTestIndirectProtocolParamSecond;

+include PTestIndirectProtocolParam;

+

+namespace mozilla {

+namespace _ipdltest {

+

+sync protocol PTestIndirectProtocolParamFirst {

+    manager PTestIndirectProtocolParamManage;

+parent:

+    sync Test(IndirectParamUnion actor);

+both:

+    async __delete__();

+};

+

+}

+}

diff --git a/ipc/ipdl/test/cxx/PTestIndirectProtocolParamManage.ipdl b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamManage.ipdl
new file mode 100644
index 000000000..db7c828a2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamManage.ipdl
@@ -0,0 +1,17 @@
+include protocol PTestIndirectProtocolParamFirst;

+include protocol PTestIndirectProtocolParamSecond;

+

+namespace mozilla {

+namespace _ipdltest {

+

+sync protocol PTestIndirectProtocolParamManage {

+    manages PTestIndirectProtocolParamFirst;

+    manages PTestIndirectProtocolParamSecond;

+both:

+    async PTestIndirectProtocolParamFirst();

+    async PTestIndirectProtocolParamSecond();

+    async __delete__();

+};

+

+}

+}

diff --git a/ipc/ipdl/test/cxx/PTestIndirectProtocolParamSecond.ipdl b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamSecond.ipdl
new file mode 100644
index 000000000..ed21f58f8
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestIndirectProtocolParamSecond.ipdl
@@ -0,0 +1,13 @@
+include protocol PTestIndirectProtocolParamManage;

+

+namespace mozilla {

+namespace _ipdltest {

+

+sync protocol PTestIndirectProtocolParamSecond {

+    manager PTestIndirectProtocolParamManage;

+both:

+    async __delete__();

+};

+

+}

+}

diff --git a/ipc/ipdl/test/cxx/PTestInterruptErrorCleanup.ipdl b/ipc/ipdl/test/cxx/PTestInterruptErrorCleanup.ipdl
new file mode 100644
index 000000000..95f933bba
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestInterruptErrorCleanup.ipdl
@@ -0,0 +1,11 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestInterruptErrorCleanup {
+child:
+    intr Error();
+    intr __delete__();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl b/ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
new file mode 100644
index 000000000..bf71a251c
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestInterruptRaces.ipdl
@@ -0,0 +1,82 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestInterruptRaces {
+both:
+    intr Race() returns (bool hasReply);
+    intr StackFrame() returns ();
+    intr StackFrame3() returns ();
+
+parent:
+    sync StartRace();
+    intr Parent();
+    sync GetAnsweredParent() returns (bool answeredParent);
+
+child:
+    async Start();
+    async Wakeup();
+    async Wakeup3();
+    intr Child();
+    async __delete__();
+
+state START:
+    send Start goto TEST1;
+
+// First test: race while no other messages are on the Interrupt stack
+state TEST1:
+    recv StartRace goto RACE1;
+state RACE1:
+    call Race goto DUMMY1_1;
+    answer Race goto DUMMY1_2;
+state DUMMY1_1:
+    answer Race goto TEST2;
+state DUMMY1_2:
+    call Race goto TEST2;
+
+// Second test: race while other messages are on the Interrupt stack
+state TEST2:
+    call StackFrame goto MORESTACK;
+state MORESTACK:
+    answer StackFrame goto STARTRACE;
+state STARTRACE:
+    send Wakeup goto RACE2;
+state RACE2:
+    call Race goto DUMMY2_1;
+    answer Race goto DUMMY2_2;
+state DUMMY2_1:
+    answer Race goto TEST3;
+state DUMMY2_2:
+    call Race goto TEST3;
+
+// Third test: resolve race using custom policy
+state TEST3:
+    call StackFrame3 goto MORESTACK3;
+state MORESTACK3:
+    answer StackFrame3 goto STARTRACE3;
+state STARTRACE3:
+    send Wakeup3 goto RACE3;
+state RACE3:
+    call Child goto DUMMY3_1;
+    answer Parent goto DUMMY3_2;
+state DUMMY3_1:
+    // the parent receives this from the child in this state
+    recv GetAnsweredParent goto CHECK;
+    // this transition is never taken (if the custom race resolution
+    // works correctly)
+    answer Parent goto CHECK;
+state DUMMY3_2:
+    call Child goto CHECK;
+state CHECK:
+    // the child sends this from this state
+    recv GetAnsweredParent goto DYING;
+    // because of deferred processing, the parent receives the child's
+    // message here
+    answer Parent goto DYING;
+
+
+state DYING:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestInterruptShutdownRace.ipdl b/ipc/ipdl/test/cxx/PTestInterruptShutdownRace.ipdl
new file mode 100644
index 000000000..10b377487
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestInterruptShutdownRace.ipdl
@@ -0,0 +1,34 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestInterruptShutdownRace {
+parent:
+    sync StartDeath();
+    async Orphan();
+
+child:
+    async Start();
+    intr Exit();
+    async __delete__();
+
+state START:
+    send Start goto START_DEATH;
+
+state START_DEATH:
+    recv StartDeath goto EXITING;
+
+state EXITING:
+    recv Orphan goto QUITTING1;
+    call Exit goto QUITTING2;
+
+state QUITTING1:
+    call Exit goto DEAD;
+state QUITTING2:
+    recv Orphan goto DEAD;
+
+state DEAD:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestJSON.ipdl b/ipc/ipdl/test/cxx/PTestJSON.ipdl
new file mode 100644
index 000000000..6e8f3c1de
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestJSON.ipdl
@@ -0,0 +1,54 @@
+include protocol PTestHandle;
+
+using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
+using struct mozilla::null_t from "ipc/IPCMessageUtils.h";
+
+namespace mozilla {
+namespace _ipdltest {
+
+union Key {
+//    int;
+//    double;
+    nsString;
+};
+
+struct KeyValue {
+    Key key;
+    JSONVariant value;
+};
+
+union JSONVariant {
+    void_t;
+    null_t;
+    bool;
+    int;
+    double;
+    nsString;
+    PTestHandle;
+    KeyValue[];
+    JSONVariant[];
+};
+
+sync protocol PTestJSON {
+    manages PTestHandle;
+
+child:
+    async Start();
+
+parent:
+    async PTestHandle();
+    sync Test(JSONVariant i)
+        returns (JSONVariant o);
+    async __delete__();
+
+state START:
+    send Start goto TEST;
+
+state TEST:
+    recv PTestHandle goto TEST;
+    recv Test goto TEST;
+    recv __delete__;
+};
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestLatency.ipdl b/ipc/ipdl/test/cxx/PTestLatency.ipdl
new file mode 100644
index 000000000..d0c9750d8
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestLatency.ipdl
@@ -0,0 +1,75 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+intr protocol PTestLatency {
+
+child:
+    async __delete__();
+    async Ping();
+    async Ping5();
+    intr Rpc();
+    async Spam();
+    intr Synchro();
+    async CompressedSpam(uint32_t seqno) compress;
+    intr Synchro2() returns (uint32_t lastSeqno,
+                            uint32_t numMessagesDispatched);
+
+parent:
+    async Pong();
+    async Pong5();
+
+state START:
+    // if the timing resolution is too low, abort the test
+    send __delete__;
+    // otherwise, kick off the ping/pong trials
+    send Ping goto PONG;
+
+    // Trial 1: single ping/pong latency
+state PING:
+    send Ping goto PONG;
+    send Ping5 goto PING4;
+
+state PONG:
+    recv Pong goto PING;
+
+    // Trial 2: "overlapped" ping/pong latency
+state PING5:
+    send Ping5 goto PING4;
+    call Rpc goto RPC;
+
+state PING4: send Ping5 goto PING3;
+state PING3: send Ping5 goto PING2;
+state PING2: send Ping5 goto PING1;
+state PING1: send Ping5 goto PONG1;
+
+state PONG1: recv Pong5 goto PONG2;
+state PONG2: recv Pong5 goto PONG3;
+state PONG3: recv Pong5 goto PONG4;
+state PONG4: recv Pong5 goto PONG5;
+state PONG5: recv Pong5 goto PING5;
+
+    // Trial 3: lotsa RPC
+state RPC:
+    call Rpc goto RPC;
+    send Spam goto SPAM;
+
+    // Trial 4: lots of sequential asyn messages, which tests pipelining
+state SPAM:
+    send Spam goto SPAM;
+    call Synchro goto COMPRESSED_SPAM;
+
+    // Trial 5: lots of async spam, but compressed to cut down on
+    // dispatch overhead
+state COMPRESSED_SPAM:          // compressed spam, mmm
+    send CompressedSpam goto COMPRESSED_SPAM;
+    call Synchro2 goto DONE;
+
+state DONE:
+    send __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestManyChildAllocs.ipdl b/ipc/ipdl/test/cxx/PTestManyChildAllocs.ipdl
new file mode 100644
index 000000000..767af85a2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestManyChildAllocs.ipdl
@@ -0,0 +1,19 @@
+include protocol PTestManyChildAllocsSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestManyChildAllocs {
+    manages PTestManyChildAllocsSub;
+
+child:
+    async Go();                       // start allocating
+
+parent:
+    async Done();
+
+    async PTestManyChildAllocsSub();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestManyChildAllocsSub.ipdl b/ipc/ipdl/test/cxx/PTestManyChildAllocsSub.ipdl
new file mode 100644
index 000000000..e3d9c98df
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestManyChildAllocsSub.ipdl
@@ -0,0 +1,19 @@
+include protocol PTestManyChildAllocs;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestManyChildAllocsSub {
+    manager PTestManyChildAllocs;
+
+child:
+    async __delete__();
+
+parent:
+    async Hello();
+
+    // empty
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestMultiMgrs.ipdl b/ipc/ipdl/test/cxx/PTestMultiMgrs.ipdl
new file mode 100644
index 000000000..6322bb1a3
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrs.ipdl
@@ -0,0 +1,34 @@
+include protocol PTestMultiMgrsLeft;
+include protocol PTestMultiMgrsRight;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestMultiMgrs {
+    manages PTestMultiMgrsLeft;
+    manages PTestMultiMgrsRight;
+
+parent:
+    async OK();
+
+child:
+    async PTestMultiMgrsLeft();
+    async PTestMultiMgrsRight();
+    async Check();
+    async __delete__();
+
+state START:
+    send PTestMultiMgrsLeft goto CONSTRUCT_RIGHT;
+state CONSTRUCT_RIGHT:
+    send PTestMultiMgrsRight goto CHILD_CHECK;
+state CHILD_CHECK:
+    send Check goto CHILD_ACK;
+state CHILD_ACK:
+    recv OK goto DONE;
+
+state DONE:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestMultiMgrsBottom.ipdl b/ipc/ipdl/test/cxx/PTestMultiMgrsBottom.ipdl
new file mode 100644
index 000000000..9c474f446
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrsBottom.ipdl
@@ -0,0 +1,18 @@
+include protocol PTestMultiMgrsLeft;
+include protocol PTestMultiMgrsRight;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestMultiMgrsBottom {
+    manager PTestMultiMgrsLeft or PTestMultiMgrsRight;
+
+child:
+    async __delete__();
+
+state DOA:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestMultiMgrsLeft.ipdl b/ipc/ipdl/test/cxx/PTestMultiMgrsLeft.ipdl
new file mode 100644
index 000000000..830176272
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrsLeft.ipdl
@@ -0,0 +1,24 @@
+include protocol PTestMultiMgrs;
+include protocol PTestMultiMgrsBottom;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestMultiMgrsLeft {
+    manager PTestMultiMgrs;
+
+    manages PTestMultiMgrsBottom;
+
+child:
+    async PTestMultiMgrsBottom();
+    async __delete__();
+
+state START:
+    send PTestMultiMgrsBottom goto DONE;
+
+state DONE:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestMultiMgrsRight.ipdl b/ipc/ipdl/test/cxx/PTestMultiMgrsRight.ipdl
new file mode 100644
index 000000000..36b0771b7
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestMultiMgrsRight.ipdl
@@ -0,0 +1,24 @@
+include protocol PTestMultiMgrs;
+include protocol PTestMultiMgrsBottom;
+
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestMultiMgrsRight {
+    manager PTestMultiMgrs;
+
+    manages PTestMultiMgrsBottom;
+
+child:
+    async PTestMultiMgrsBottom();
+    async __delete__();
+
+state START:
+    send PTestMultiMgrsBottom goto DONE;
+
+state DONE:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl b/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
new file mode 100644
index 000000000..f0f067e0b
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestNestedLoops.ipdl
@@ -0,0 +1,34 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+intr protocol PTestNestedLoops {
+
+child:
+    async Start();
+    intr R();
+    async __delete__();
+
+parent:
+    async Nonce();
+
+
+state START:
+    send Start goto RACE;
+
+state RACE:
+    recv Nonce goto RACE1;
+    call R goto RACE2;
+state RACE1:
+    call R goto DEAD;
+state RACE2:
+    recv Nonce goto DEAD;
+
+state DEAD:
+    send __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestOpens.ipdl b/ipc/ipdl/test/cxx/PTestOpens.ipdl
new file mode 100644
index 000000000..2717328fa
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestOpens.ipdl
@@ -0,0 +1,25 @@
+include protocol PTestOpensOpened;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestOpens {
+    // This channel is opened and parked on a non-main thread
+    child opens PTestOpensOpened;
+
+child:
+    async Start();
+
+parent:
+    async __delete__();
+
+state START:
+    send Start goto DEAD;
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl b/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
new file mode 100644
index 000000000..04b633634
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestOpensOpened.ipdl
@@ -0,0 +1,28 @@
+namespace mozilla {
+namespace _ipdltest2 {
+
+// (Opens protocols can have different semantics than the endpoints
+// that opened them)
+intr protocol PTestOpensOpened {
+child:
+    async Hi();
+    intr HiRpc();
+
+parent:
+    async Hello();
+    sync HelloSync();
+    intr HelloRpc();
+    async __delete__();
+
+state START:       recv Hello goto HI;
+state HI:          send Hi goto HELLO_SYNC;
+state HELLO_SYNC:  recv HelloSync goto HELLO_RPC;
+state HELLO_RPC:   answer HelloRpc goto HI_RPC;
+state HI_RPC:      call HiRpc goto DEAD;
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest2
diff --git a/ipc/ipdl/test/cxx/PTestPriority.ipdl b/ipc/ipdl/test/cxx/PTestPriority.ipdl
new file mode 100644
index 000000000..edb98365b
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestPriority.ipdl
@@ -0,0 +1,14 @@
+namespace mozilla {
+namespace _ipdltest {
+
+sync protocol PTestPriority {
+parent:
+    prio(high) async Msg1();
+    prio(high) sync Msg2();
+
+child:
+    prio(high) async Msg3();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestRPC.ipdl b/ipc/ipdl/test/cxx/PTestRPC.ipdl
new file mode 100644
index 000000000..f51ee2735
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestRPC.ipdl
@@ -0,0 +1,21 @@
+namespace mozilla {
+namespace _ipdltest {
+
+nested(upto inside_sync) sync protocol PTestRPC
+{
+parent:
+    nested(inside_sync) sync Test1_Start() returns (uint32_t result);
+    nested(inside_sync) sync Test1_InnerEvent() returns (uint32_t result);
+    async Test2_Start();
+    nested(inside_sync) sync Test2_OutOfOrder();
+
+child:
+    async Start();
+    nested(inside_sync) sync Test1_InnerQuery() returns (uint32_t result);
+    nested(inside_sync) sync Test1_NoReenter() returns (uint32_t result);
+    nested(inside_sync) sync Test2_FirstUrgent();
+    nested(inside_sync) sync Test2_SecondUrgent();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestRaceDeadlock.ipdl b/ipc/ipdl/test/cxx/PTestRaceDeadlock.ipdl
new file mode 100644
index 000000000..1e4f57450
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestRaceDeadlock.ipdl
@@ -0,0 +1,20 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestRaceDeadlock {
+both:
+    async StartRace();
+
+parent:
+    intr Lose();
+
+child:
+    intr Win();
+    intr Rpc();
+    async __delete__();
+
+/* Tests that race resolution does not cause deadlocks */
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestRaceDeferral.ipdl b/ipc/ipdl/test/cxx/PTestRaceDeferral.ipdl
new file mode 100644
index 000000000..ada6df4c6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestRaceDeferral.ipdl
@@ -0,0 +1,45 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestRaceDeferral {
+parent:
+    intr Lose();
+
+child:
+    async StartRace();
+    intr Win();
+    intr Rpc();
+    async __delete__();
+
+// Test that messages deferred due to race resolution are
+// re-considered when the winner makes later RPCs
+
+// IPDL's type system can't express this protocol because the race
+// resolution causes state to diverge for multiple steps, so we'll
+// leave it "stateless"
+/*
+state START:
+    send StartRace goto DEFER;
+state DEFER:
+    call Win goto PARENT;
+    answer Lose goto CHILD;
+
+state PARENT:
+    // 'Lose' is received here but deferred
+    call Rpc goto PARENT_LOSE;
+state PARENT_LOSE:
+    // Calling 'Rpc' undefers 'Lose', and it wins the "race" with 'Rpc'
+    answer Lose goto DONE;
+
+state CHILD:
+    call Win goto CHILD_RPC;
+state CHILD_RPC:
+    call Rpc goto DONE;
+
+state DONE:
+    send __delete__;
+*/
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestRacyInterruptReplies.ipdl b/ipc/ipdl/test/cxx/PTestRacyInterruptReplies.ipdl
new file mode 100644
index 000000000..56e700b85
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestRacyInterruptReplies.ipdl
@@ -0,0 +1,41 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestRacyInterruptReplies {
+child:
+    intr R_() returns (int replyNum);
+    async _A();
+    async ChildTest();
+    async __delete__();
+
+parent:
+    intr _R() returns (int replyNum);
+    async A_();
+
+state PARENT_START:
+    call R_ goto PARENT_S1;
+
+state PARENT_S1:
+    recv A_ goto PARENT_S2;
+
+state PARENT_S2:
+    call R_ goto CHILD_TEST;
+
+state CHILD_TEST:
+    send ChildTest goto CHILD_START;
+
+state CHILD_START:
+    answer _R goto CHILD_S1;
+
+state CHILD_S1:
+    send _A goto CHILD_S2;
+
+state CHILD_S2:
+    answer _R goto DYING;
+
+state DYING:
+    send __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl b/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
new file mode 100644
index 000000000..4dd5fe54f
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestRacyReentry.ipdl
@@ -0,0 +1,21 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+intr protocol PTestRacyReentry {
+
+parent:
+    intr E();
+    async __delete__();
+
+child:
+    async Start();
+
+    async N();
+    intr H();
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestRacyUndefer.ipdl b/ipc/ipdl/test/cxx/PTestRacyUndefer.ipdl
new file mode 100644
index 000000000..8863d6179
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestRacyUndefer.ipdl
@@ -0,0 +1,28 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+intr protocol PTestRacyUndefer {
+
+child:
+    async Start();
+
+    async AwakenSpam();
+    async AwakenRaceWinTwice();
+
+    intr Race();
+
+    async __delete__();
+
+parent:
+
+    intr Spam();
+    intr RaceWinTwice();
+
+    async Done();
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestSanity.ipdl b/ipc/ipdl/test/cxx/PTestSanity.ipdl
new file mode 100644
index 000000000..50249b741
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestSanity.ipdl
@@ -0,0 +1,28 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestSanity {
+
+child:
+    async Ping(int zero, float zeroPtFive, int8_t dummy);
+    async __delete__();
+
+parent:
+    async Pong(int one, float zeroPtTwoFive, uint8_t dummy);
+
+
+state PING:
+    send Ping goto PONG;
+
+state PONG:
+    recv Pong goto DEAD;
+
+state DEAD:
+    send __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestSelfManage.ipdl b/ipc/ipdl/test/cxx/PTestSelfManage.ipdl
new file mode 100644
index 000000000..69eb4f55c
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestSelfManage.ipdl
@@ -0,0 +1,22 @@
+include protocol PTestSelfManageRoot;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestSelfManage {
+    manager PTestSelfManageRoot or PTestSelfManage;
+    manages PTestSelfManage;
+
+child:
+    async PTestSelfManage();
+    async __delete__();
+
+state LIVE:
+    send PTestSelfManage goto LIVE;
+    send __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestSelfManageRoot.ipdl b/ipc/ipdl/test/cxx/PTestSelfManageRoot.ipdl
new file mode 100644
index 000000000..429f8bfc8
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestSelfManageRoot.ipdl
@@ -0,0 +1,23 @@
+include protocol PTestSelfManage;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestSelfManageRoot {
+    manages PTestSelfManage;
+
+child:
+    async PTestSelfManage();
+    async __delete__();
+
+state LIVE:
+    send PTestSelfManage goto DEAD;
+
+state DEAD:
+    send __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestShmem.ipdl b/ipc/ipdl/test/cxx/PTestShmem.ipdl
new file mode 100644
index 000000000..46a1958e2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestShmem.ipdl
@@ -0,0 +1,22 @@
+namespace mozilla {
+namespace _ipdltest {
+
+protocol PTestShmem {
+child:
+    async Give(Shmem mem, Shmem unsafe, size_t expectedSize);
+
+parent:
+    async Take(Shmem mem, Shmem unsafe, size_t expectedSize);
+    async __delete__();
+
+
+state GIVING:
+    send Give goto TAKING;
+
+state TAKING:
+    recv Take goto TAKING;
+    recv __delete__;
+};
+
+}
+}
diff --git a/ipc/ipdl/test/cxx/PTestShutdown.ipdl b/ipc/ipdl/test/cxx/PTestShutdown.ipdl
new file mode 100644
index 000000000..e4d8d0dbe
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestShutdown.ipdl
@@ -0,0 +1,37 @@
+include protocol PTestShutdownSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestShutdown {
+    manages PTestShutdownSub;
+
+child:
+    async Start();
+
+parent:
+    // NB: we test deletion and crashing only, not shutdown, because
+    // crashing is the same code path as shutdown, and other IPDL unit
+    // tests check shutdown semantics
+    async PTestShutdownSub(bool expectCrash);
+
+    // Used to synchronize between parent and child, to avoid races
+    // around flushing socket write queues
+    sync Sync();
+
+    async __delete__();
+
+
+state START:
+    send Start goto TESTING;
+
+state TESTING:
+    recv PTestShutdownSub goto TESTING;
+    recv Sync goto DYING;
+
+state DYING:
+    recv __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl b/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
new file mode 100644
index 000000000..39d45d9ed
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestShutdownSub.ipdl
@@ -0,0 +1,30 @@
+include protocol PTestShutdown;
+include protocol PTestShutdownSubsub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestShutdownSub {
+    manager PTestShutdown;
+    manages PTestShutdownSubsub;
+
+both:
+    intr StackFrame();
+
+parent:
+    async PTestShutdownSubsub(bool expectParentDeleted);
+    sync __delete__();
+
+state CREATING:
+    recv PTestShutdownSubsub goto CREATING;
+    answer StackFrame goto DUMMYFRAME;
+
+state DUMMYFRAME:
+    call StackFrame goto DEAD;
+
+state DEAD:
+    recv __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestShutdownSubsub.ipdl b/ipc/ipdl/test/cxx/PTestShutdownSubsub.ipdl
new file mode 100644
index 000000000..91031ab41
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestShutdownSubsub.ipdl
@@ -0,0 +1,17 @@
+include protocol PTestShutdownSub;
+
+namespace mozilla {
+namespace _ipdltest {
+
+sync protocol PTestShutdownSubsub {
+    manager PTestShutdownSub;
+
+parent:
+    sync __delete__();
+
+state LIVE:
+    recv __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestStackHooks.ipdl b/ipc/ipdl/test/cxx/PTestStackHooks.ipdl
new file mode 100644
index 000000000..1f3af068f
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestStackHooks.ipdl
@@ -0,0 +1,56 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+intr protocol PTestStackHooks {
+child:
+    async Start();
+
+    // These tests are more fruitful running child->parent, because
+    // children can send |sync| messages
+parent:
+    async Async();
+    sync Sync();
+    intr Rpc();
+
+both:
+    intr StackFrame();
+
+parent:
+    async __delete__();
+
+
+state START:
+    send Start goto TEST1;
+
+state TEST1:
+    recv Async goto TEST2;
+
+state TEST2:
+    recv Sync goto TEST3;
+
+state TEST3:
+    answer Rpc goto TEST4;
+
+state TEST4:
+    answer StackFrame goto TEST4_2;
+state TEST4_2:
+    call StackFrame goto TEST4_3;
+state TEST4_3:
+    recv Async goto TEST5;
+
+state TEST5:
+    answer StackFrame goto TEST5_2;
+state TEST5_2:
+    call StackFrame goto TEST5_3;
+state TEST5_3:
+    recv Sync goto DEAD;
+
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestSyncError.ipdl b/ipc/ipdl/test/cxx/PTestSyncError.ipdl
new file mode 100644
index 000000000..05b68ff35
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestSyncError.ipdl
@@ -0,0 +1,28 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+sync protocol PTestSyncError {
+
+child:
+    async Start();
+
+parent:
+    sync Error();
+    async __delete__();
+
+
+state START:
+    send Start goto SYNC_ERROR;
+
+state SYNC_ERROR:
+    recv Error goto DEAD;
+
+state DEAD:
+    recv __delete__;
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestSyncHang.ipdl b/ipc/ipdl/test/cxx/PTestSyncHang.ipdl
new file mode 100644
index 000000000..eefcf2c5e
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestSyncHang.ipdl
@@ -0,0 +1,15 @@
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+protocol PTestSyncHang {
+
+child:
+    async __delete__();
+
+};
+
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/PTestSyncWakeup.ipdl b/ipc/ipdl/test/cxx/PTestSyncWakeup.ipdl
new file mode 100644
index 000000000..3d873cdf5
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestSyncWakeup.ipdl
@@ -0,0 +1,41 @@
+namespace mozilla {
+namespace _ipdltest {
+
+intr protocol PTestSyncWakeup {
+both:
+    intr StackFrame();
+
+child:
+    async Start();
+    async Note1();
+    async Note2();
+
+parent:
+    sync Sync1();
+    sync Sync2();
+    async __delete__();
+
+
+state START:
+    send Start goto TEST1;
+
+state TEST1:
+    recv Sync1 goto TEST1_P2;
+state TEST1_P2:
+    send Note1 goto TEST2;
+
+state TEST2:
+    answer StackFrame goto TEST2_P2;
+state TEST2_P2:
+    call StackFrame goto TEST2_P3;
+state TEST2_P3:
+    recv Sync2 goto TEST2_P4;
+state TEST2_P4:
+    send Note2 goto DONE;
+
+state DONE:
+    recv __delete__;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestUrgency.ipdl b/ipc/ipdl/test/cxx/PTestUrgency.ipdl
new file mode 100644
index 000000000..79b479ca2
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestUrgency.ipdl
@@ -0,0 +1,19 @@
+namespace mozilla {
+namespace _ipdltest {
+
+nested(upto inside_cpow) sync protocol PTestUrgency
+{
+parent:
+    nested(inside_sync) sync Test1() returns (uint32_t result);
+    async Test2();
+    sync Test3() returns (uint32_t result);
+    sync FinalTest_Begin();
+
+child:
+    async Start();
+    nested(inside_sync) sync Reply1() returns (uint32_t result);
+    nested(inside_sync) sync Reply2() returns (uint32_t result);
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/PTestUrgentHangs.ipdl b/ipc/ipdl/test/cxx/PTestUrgentHangs.ipdl
new file mode 100644
index 000000000..8ce8d1747
--- /dev/null
+++ b/ipc/ipdl/test/cxx/PTestUrgentHangs.ipdl
@@ -0,0 +1,28 @@
+namespace mozilla {
+namespace _ipdltest {
+
+nested(upto inside_cpow) sync protocol PTestUrgentHangs
+{
+parent:
+    nested(inside_sync) sync Test1_2();
+
+    nested(inside_sync) sync TestInner();
+    nested(inside_cpow) sync TestInnerUrgent();
+
+child:
+    nested(inside_sync) sync Test1_1();
+    nested(inside_sync) sync Test1_3();
+
+    nested(inside_sync) sync Test2();
+
+    nested(inside_sync) sync Test3();
+
+    async Test4();
+    nested(inside_sync) sync Test4_1();
+
+    async Test5();
+    nested(inside_sync) sync Test5_1();
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/README.txt b/ipc/ipdl/test/cxx/README.txt
new file mode 100644
index 000000000..0fe6c0732
--- /dev/null
+++ b/ipc/ipdl/test/cxx/README.txt
@@ -0,0 +1,61 @@
+To add a new IPDL C++ unit test, you need to create (at least) the
+following files (for a test "TestFoo"):
+
+  - PTestFoo.ipdl, specifying the top-level protocol used for the test
+
+  - TestFoo.h, declaring the top-level parent/child actors used for
+    the test
+
+  - TestFoo.cpp, defining the top-level actors
+
+  - (make sure all are in the namespace mozilla::_ipdltest)
+
+Next
+
+  - add PTestFoo.ipdl to ipdl.mk
+
+  - append TestFoo to the variable IPDLTESTS in Makefile.in
+
+You must define three methods in your |TestFooParent| class:
+
+  - static methods |bool RunTestInProcesses()| and
+    |bool RunTestInThreads()|.  These methods control whether
+    to execute the test using actors in separate processes and
+    threads respectively.  Generally, both should return true.
+
+  - an instance method |void Main()|.  The test harness wil first
+    initialize the processes or threads, create and open both actors,
+    and then kick off the test using |Main()|.  Make sure you define
+    it.
+
+If your test passes its criteria, please call
+|MOZ_IPDL_TESTPASS("msg")| and "exit gracefully".
+
+If your tests fails, please call |MOZ_IPDL_TESTFAIL("msg")| and "exit
+ungracefully", preferably by abort()ing.
+
+
+If all goes well, running
+
+  make -C $OBJDIR/ipc/ipdl/test/cxx
+
+will update the file IPDLUnitTests.cpp (the test launcher), and your
+new code will be built automatically.
+
+
+You can launch your new test by invoking one of
+
+  make -C $OBJDIR/ipc/ipdl/test/cxx check-proc     (test process-based tests)
+  make -C $OBJDIR/ipc/ipdl/test/cxx check-threads  (test thread-based tests)
+  make -C $OBJDIR/ipc/ipdl/test/cxx check          (tests both)
+
+If you want to launch only your test, run
+
+  cd $OBJDIR/dist/bin
+  ./run-mozilla.sh ./ipdlunittest TestFoo          (test in two processes, if appl.)
+  ./run-mozilla.sh ./ipdlunittest thread:TestFoo   (test in two threads, if appl.)
+
+
+For a bare-bones example of adding a test, take a look at
+PTestSanity.ipdl, TestSanity.h, TestSanity.cpp, and how "TestSanity"
+is included in ipdl.mk and Makefile.in.
diff --git a/ipc/ipdl/test/cxx/TestActorPunning.cpp b/ipc/ipdl/test/cxx/TestActorPunning.cpp
new file mode 100644
index 000000000..eb6fa412f
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestActorPunning.cpp
@@ -0,0 +1,128 @@
+#include "TestActorPunning.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#include "mozilla/Unused.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+void
+TestActorPunningParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+bool
+TestActorPunningParent::RecvPun(PTestActorPunningSubParent* a, const Bad& bad)
+{
+    if (a->SendBad())
+        fail("bad!");
+    fail("shouldn't have received this message in the first place");
+    return true;
+}
+
+PTestActorPunningPunnedParent*
+TestActorPunningParent::AllocPTestActorPunningPunnedParent()
+{
+    return new TestActorPunningPunnedParent();
+}
+
+bool
+TestActorPunningParent::DeallocPTestActorPunningPunnedParent(PTestActorPunningPunnedParent* a)
+{
+    delete a;
+    return true;
+}
+
+PTestActorPunningSubParent*
+TestActorPunningParent::AllocPTestActorPunningSubParent()
+{
+    return new TestActorPunningSubParent();
+}
+
+bool
+TestActorPunningParent::DeallocPTestActorPunningSubParent(PTestActorPunningSubParent* a)
+{
+    delete a;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+PTestActorPunningPunnedChild*
+TestActorPunningChild::AllocPTestActorPunningPunnedChild()
+{
+    return new TestActorPunningPunnedChild();
+}
+
+bool
+TestActorPunningChild::DeallocPTestActorPunningPunnedChild(PTestActorPunningPunnedChild*)
+{
+    fail("should have died by now");
+    return true;
+}
+
+PTestActorPunningSubChild*
+TestActorPunningChild::AllocPTestActorPunningSubChild()
+{
+    return new TestActorPunningSubChild();
+}
+
+bool
+TestActorPunningChild::DeallocPTestActorPunningSubChild(PTestActorPunningSubChild*)
+{
+    fail("should have died by now");
+    return true;
+}
+
+bool
+TestActorPunningChild::RecvStart()
+{
+    SendPTestActorPunningSubConstructor();
+    SendPTestActorPunningPunnedConstructor();
+    PTestActorPunningSubChild* a = SendPTestActorPunningSubConstructor();
+    // We can't assert whether this succeeds or fails, due to race
+    // conditions.
+    SendPun(a, Bad());
+    return true;
+}
+
+bool
+TestActorPunningSubChild::RecvBad()
+{
+    fail("things are going really badly right now");
+    return true;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+namespace IPC {
+using namespace mozilla::_ipdltest;
+using namespace mozilla::ipc;
+
+/*static*/ void
+ParamTraits<Bad>::Write(Message* aMsg, const paramType& aParam)
+{
+    // Skip past the sentinel for the actor as well as the actor.
+    int32_t* ptr = aMsg->GetInt32PtrForTest(2 * sizeof(int32_t));
+    ActorHandle* ah = reinterpret_cast<ActorHandle*>(ptr);
+    if (ah->mId != -3)
+        fail("guessed wrong offset (value is %d, should be -3)", ah->mId);
+    ah->mId = -2;
+}
+
+/*static*/ bool
+ParamTraits<Bad>::Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
+{
+    return true;
+}
+
+} // namespace IPC
+
diff --git a/ipc/ipdl/test/cxx/TestActorPunning.h b/ipc/ipdl/test/cxx/TestActorPunning.h
new file mode 100644
index 000000000..5ebf2e7f4
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestActorPunning.h
@@ -0,0 +1,110 @@
+#ifndef mozilla__ipdltest_TestActorPunning_h
+#define mozilla__ipdltest_TestActorPunning_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestActorPunningParent.h"
+#include "mozilla/_ipdltest/PTestActorPunningPunnedParent.h"
+#include "mozilla/_ipdltest/PTestActorPunningSubParent.h"
+#include "mozilla/_ipdltest/PTestActorPunningChild.h"
+#include "mozilla/_ipdltest/PTestActorPunningPunnedChild.h"
+#include "mozilla/_ipdltest/PTestActorPunningSubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestActorPunningParent :
+    public PTestActorPunningParent
+{
+public:
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:
+    PTestActorPunningPunnedParent* AllocPTestActorPunningPunnedParent() override;
+    bool DeallocPTestActorPunningPunnedParent(PTestActorPunningPunnedParent* a) override;
+
+    PTestActorPunningSubParent* AllocPTestActorPunningSubParent() override;
+    bool DeallocPTestActorPunningSubParent(PTestActorPunningSubParent* a) override;
+
+    virtual bool RecvPun(PTestActorPunningSubParent* a, const Bad& bad) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown == why)
+            fail("should have died from error!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+class TestActorPunningPunnedParent :
+    public PTestActorPunningPunnedParent
+{
+public:
+    TestActorPunningPunnedParent() {}
+    virtual ~TestActorPunningPunnedParent() {}
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+};
+
+class TestActorPunningSubParent :
+    public PTestActorPunningSubParent
+{
+public:
+    TestActorPunningSubParent() {}
+    virtual ~TestActorPunningSubParent() {}
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+};
+
+
+class TestActorPunningChild :
+    public PTestActorPunningChild
+{
+public:
+    TestActorPunningChild() {}
+    virtual ~TestActorPunningChild() {}
+
+protected:
+    PTestActorPunningPunnedChild* AllocPTestActorPunningPunnedChild() override;
+    bool DeallocPTestActorPunningPunnedChild(PTestActorPunningPunnedChild* a) override;
+
+    PTestActorPunningSubChild* AllocPTestActorPunningSubChild() override;
+    bool DeallocPTestActorPunningSubChild(PTestActorPunningSubChild* a) override;
+
+    virtual bool RecvStart() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        fail("should have been killed off!");
+    }
+};
+
+class TestActorPunningPunnedChild :
+    public PTestActorPunningPunnedChild
+{
+public:
+    TestActorPunningPunnedChild() {}
+    virtual ~TestActorPunningPunnedChild() {}
+};
+
+class TestActorPunningSubChild :
+    public PTestActorPunningSubChild
+{
+public:
+    TestActorPunningSubChild() {}
+    virtual ~TestActorPunningSubChild() {}
+
+    virtual bool RecvBad() override;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestActorPunning_h
diff --git a/ipc/ipdl/test/cxx/TestBadActor.cpp b/ipc/ipdl/test/cxx/TestBadActor.cpp
new file mode 100644
index 000000000..bc1cf6f6d
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestBadActor.cpp
@@ -0,0 +1,51 @@
+#include "TestBadActor.h"
+#include "IPDLUnitTests.h"
+#include "mozilla/Unused.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+void
+TestBadActorParent::Main()
+{
+  // This test is designed to test a race condition where the child sends us
+  // a message on an actor that we've already destroyed. The child process
+  // should die, and the parent process should not abort.
+
+  PTestBadActorSubParent* child = SendPTestBadActorSubConstructor();
+  if (!child)
+    fail("Sending constructor");
+
+  Unused << child->Call__delete__(child);
+}
+
+PTestBadActorSubParent*
+TestBadActorParent::AllocPTestBadActorSubParent()
+{
+  return new TestBadActorSubParent();
+}
+
+bool
+TestBadActorSubParent::RecvPing()
+{
+  fail("Shouldn't have received ping.");
+  return false;
+}
+
+PTestBadActorSubChild*
+TestBadActorChild::AllocPTestBadActorSubChild()
+{
+  return new TestBadActorSubChild();
+}
+
+bool
+TestBadActorChild::RecvPTestBadActorSubConstructor(PTestBadActorSubChild* actor)
+{
+  if (!actor->SendPing()) {
+    fail("Couldn't send ping to an actor which supposedly isn't dead yet.");
+  }
+  return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestBadActor.h b/ipc/ipdl/test/cxx/TestBadActor.h
new file mode 100644
index 000000000..9b1258ff6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestBadActor.h
@@ -0,0 +1,91 @@
+#ifndef mozilla__ipdltest_TestBadActor_h
+#define mozilla__ipdltest_TestBadActor_h
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestBadActorParent.h"
+#include "mozilla/_ipdltest/PTestBadActorChild.h"
+
+#include "mozilla/_ipdltest/PTestBadActorSubParent.h"
+#include "mozilla/_ipdltest/PTestBadActorSubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+class TestBadActorParent
+  : public PTestBadActorParent
+{
+public:
+  TestBadActorParent() { }
+  virtual ~TestBadActorParent() { }
+
+  static bool RunTestInProcesses() { return true; }
+  static bool RunTestInThreads() { return false; }
+
+  void Main();
+
+protected:
+  virtual void ActorDestroy(ActorDestroyReason why) override
+  {
+    if (AbnormalShutdown != why)
+      fail("unexpected destruction");
+    passed("ok");
+    QuitParent();
+  }
+
+  virtual PTestBadActorSubParent*
+  AllocPTestBadActorSubParent();
+
+  virtual bool
+  DeallocPTestBadActorSubParent(PTestBadActorSubParent* actor) {
+    delete actor;
+    return true;
+  }
+};
+
+class TestBadActorSubParent
+  : public PTestBadActorSubParent
+{
+public:
+  TestBadActorSubParent() { }
+  virtual ~TestBadActorSubParent() { }
+
+protected:
+  virtual void ActorDestroy(ActorDestroyReason why) override {}
+  virtual bool RecvPing();
+};
+
+class TestBadActorChild
+  : public PTestBadActorChild
+{
+public:
+  TestBadActorChild() { }
+  virtual ~TestBadActorChild() { }
+
+protected:
+  virtual PTestBadActorSubChild*
+  AllocPTestBadActorSubChild();
+
+  virtual bool
+  DeallocPTestBadActorSubChild(PTestBadActorSubChild* actor)
+  {
+    delete actor;
+    return true;
+  }
+
+  virtual bool
+  RecvPTestBadActorSubConstructor(PTestBadActorSubChild* actor);
+};
+
+class TestBadActorSubChild
+  : public PTestBadActorSubChild
+{
+public:
+  TestBadActorSubChild() { }
+  virtual ~TestBadActorSubChild() { }
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+#endif // mozilla__ipdltest_TestBadActor_h
diff --git a/ipc/ipdl/test/cxx/TestBridgeMain.cpp b/ipc/ipdl/test/cxx/TestBridgeMain.cpp
new file mode 100644
index 000000000..9b1590a46
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestBridgeMain.cpp
@@ -0,0 +1,227 @@
+#include "TestBridgeMain.h"
+
+#include "base/task.h"
+#include "IPDLUnitTests.h"      // fail etc.
+#include "IPDLUnitTestSubprocess.h"
+
+#include "nsAutoPtr.h"
+
+using namespace std;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+//-----------------------------------------------------------------------------
+// main process
+void
+TestBridgeMainParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+PTestBridgeMainSubParent*
+TestBridgeMainParent::AllocPTestBridgeMainSubParent(Transport* transport,
+                                                    ProcessId otherPid)
+{
+    nsAutoPtr<TestBridgeMainSubParent> a(new TestBridgeMainSubParent(transport));
+    if (!a->Open(transport, otherPid, XRE_GetIOMessageLoop(), ipc::ParentSide)) {
+        return nullptr;
+    }
+    return a.forget();
+}
+
+void
+TestBridgeMainParent::ActorDestroy(ActorDestroyReason why)
+{
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");  
+    passed("ok");
+    QuitParent();
+}
+
+bool
+TestBridgeMainSubParent::RecvHello()
+{
+    return SendHi();
+}
+
+bool
+TestBridgeMainSubParent::RecvHelloSync()
+{
+    return true;
+}
+
+bool
+TestBridgeMainSubParent::AnswerHelloRpc()
+{
+    return CallHiRpc();
+}
+
+void
+TestBridgeMainSubParent::ActorDestroy(ActorDestroyReason why)
+{
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");
+
+    // ActorDestroy() is just a callback from IPDL-generated code,
+    // which needs the top-level actor (this) to stay alive a little
+    // longer so other things can be cleaned up.
+    MessageLoop::current()->PostTask(
+        do_AddRef(new DeleteTask<TestBridgeMainSubParent>(this)));
+}
+
+//-----------------------------------------------------------------------------
+// sub process --- child of main
+TestBridgeMainChild* gBridgeMainChild;
+
+TestBridgeMainChild::TestBridgeMainChild()
+    : mSubprocess(nullptr)
+{
+    gBridgeMainChild = this;
+}
+
+bool
+TestBridgeMainChild::RecvStart()
+{
+    vector<string> subsubArgs;
+    subsubArgs.push_back("TestBridgeSub");
+
+    mSubprocess = new IPDLUnitTestSubprocess();
+    if (!mSubprocess->SyncLaunch(subsubArgs))
+        fail("problem launching subprocess");
+
+    IPC::Channel* transport = mSubprocess->GetChannel();
+    if (!transport)
+        fail("no transport");
+
+    TestBridgeSubParent* bsp = new TestBridgeSubParent();
+    bsp->Open(transport, base::GetProcId(mSubprocess->GetChildProcessHandle()));
+
+    bsp->Main();
+    return true;
+}
+
+void
+TestBridgeMainChild::ActorDestroy(ActorDestroyReason why)
+{
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");  
+    // NB: this is kosher because QuitChild() joins with the IO thread
+    XRE_GetIOMessageLoop()->PostTask(
+        do_AddRef(new DeleteTask<IPDLUnitTestSubprocess>(mSubprocess)));
+    QuitChild();
+}
+
+void
+TestBridgeSubParent::Main()
+{
+    if (!SendPing())
+        fail("sending Ping");
+}
+
+bool
+TestBridgeSubParent::RecvBridgeEm()
+{
+    if (NS_FAILED(PTestBridgeMainSub::Bridge(gBridgeMainChild, this)))
+        fail("bridging Main and Sub");
+    return true;
+}
+
+void
+TestBridgeSubParent::ActorDestroy(ActorDestroyReason why)
+{
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");
+    gBridgeMainChild->Close();
+
+    // ActorDestroy() is just a callback from IPDL-generated code,
+    // which needs the top-level actor (this) to stay alive a little
+    // longer so other things can be cleaned up.
+    MessageLoop::current()->PostTask(
+        do_AddRef(new DeleteTask<TestBridgeSubParent>(this)));
+}
+
+//-----------------------------------------------------------------------------
+// subsub process --- child of sub
+
+static TestBridgeSubChild* gBridgeSubChild;
+
+TestBridgeSubChild::TestBridgeSubChild()
+{
+    gBridgeSubChild = this;   
+}
+
+bool
+TestBridgeSubChild::RecvPing()
+{
+    if (!SendBridgeEm())
+        fail("sending BridgeEm");
+    return true;
+}
+
+PTestBridgeMainSubChild*
+TestBridgeSubChild::AllocPTestBridgeMainSubChild(Transport* transport,
+                                                 ProcessId otherPid)
+{
+    nsAutoPtr<TestBridgeMainSubChild> a(new TestBridgeMainSubChild(transport));
+    if (!a->Open(transport, otherPid, XRE_GetIOMessageLoop(), ipc::ChildSide)) {
+        return nullptr;
+    }
+
+    if (!a->SendHello())
+        fail("sending Hello");
+
+    return a.forget();
+}
+
+void
+TestBridgeSubChild::ActorDestroy(ActorDestroyReason why)
+{
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");
+    QuitChild();
+}
+
+bool
+TestBridgeMainSubChild::RecvHi()
+{
+    if (!SendHelloSync())
+        fail("sending HelloSync");
+    if (!CallHelloRpc())
+        fail("calling HelloRpc");
+    if (!mGotHi)
+        fail("didn't answer HiRpc");
+
+    // Need to close the channel without message-processing frames on
+    // the C++ stack
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestBridgeMainSubChild::Close));
+    return true;
+}
+
+bool
+TestBridgeMainSubChild::AnswerHiRpc()
+{
+    mGotHi = true;              // d00d
+    return true;
+}
+
+void
+TestBridgeMainSubChild::ActorDestroy(ActorDestroyReason why)
+{
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");  
+
+    gBridgeSubChild->Close();
+
+    // ActorDestroy() is just a callback from IPDL-generated code,
+    // which needs the top-level actor (this) to stay alive a little
+    // longer so other things can be cleaned up.
+    MessageLoop::current()->PostTask(
+        do_AddRef(new DeleteTask<TestBridgeMainSubChild>(this)));
+}
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/TestBridgeMain.h b/ipc/ipdl/test/cxx/TestBridgeMain.h
new file mode 100644
index 000000000..a5c7c10cb
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestBridgeMain.h
@@ -0,0 +1,149 @@
+#ifndef mozilla__ipdltest_TestBridgeMain_h
+#define mozilla__ipdltest_TestBridgeMain_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestBridgeMainParent.h"
+#include "mozilla/_ipdltest/PTestBridgeMainChild.h"
+
+#include "mozilla/_ipdltest/PTestBridgeSubParent.h"
+#include "mozilla/_ipdltest/PTestBridgeSubChild.h"
+
+#include "mozilla/_ipdltest/PTestBridgeMainSubParent.h"
+#include "mozilla/_ipdltest/PTestBridgeMainSubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// "Main" process
+//
+class TestBridgeMainParent :
+    public PTestBridgeMainParent
+{
+public:
+    TestBridgeMainParent() {}
+    virtual ~TestBridgeMainParent() {}
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:
+    virtual PTestBridgeMainSubParent*
+    AllocPTestBridgeMainSubParent(Transport* transport,
+                                  ProcessId otherProcess) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+class TestBridgeMainSubParent :
+    public PTestBridgeMainSubParent
+{
+public:
+    explicit TestBridgeMainSubParent(Transport* aTransport)
+        : mTransport(aTransport)
+    {}
+    virtual ~TestBridgeMainSubParent() {}
+
+protected:
+    virtual bool RecvHello() override;
+    virtual bool RecvHelloSync() override;
+    virtual bool AnswerHelloRpc() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+
+    Transport* mTransport;
+};
+
+//-----------------------------------------------------------------------------
+// "Sub" process --- child of "main"
+//
+class TestBridgeSubParent;
+
+class TestBridgeMainChild :
+    public PTestBridgeMainChild
+{
+public:
+    TestBridgeMainChild();
+    virtual ~TestBridgeMainChild() {}
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual PTestBridgeMainSubChild*
+    AllocPTestBridgeMainSubChild(Transport* transport,
+                                 ProcessId otherProcess) override
+    {
+        // This shouldn't be called. It's just a byproduct of testing that
+        // the right code is generated for a bridged protocol that's also
+        // opened, but we only test bridging here.
+        MOZ_CRASH();
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+
+    IPDLUnitTestSubprocess* mSubprocess;
+};
+
+class TestBridgeSubParent :
+    public PTestBridgeSubParent
+{
+public:
+    TestBridgeSubParent() {}
+    virtual ~TestBridgeSubParent() {}
+
+    void Main();
+
+protected:
+    virtual bool RecvBridgeEm() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+//-----------------------------------------------------------------------------
+// "Subsub" process --- child of "sub"
+//
+class TestBridgeSubChild :
+    public PTestBridgeSubChild
+{
+public:
+    TestBridgeSubChild();
+    virtual ~TestBridgeSubChild() {}
+
+protected:
+    virtual bool RecvPing() override;
+
+    virtual PTestBridgeMainSubChild*
+    AllocPTestBridgeMainSubChild(Transport* transport,
+                                 ProcessId otherProcess) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+class TestBridgeMainSubChild :
+    public PTestBridgeMainSubChild
+{
+public:
+    explicit TestBridgeMainSubChild(Transport* aTransport)
+        : mGotHi(false)
+        , mTransport(aTransport)
+    {}
+    virtual ~TestBridgeMainSubChild() {}
+
+protected:
+    virtual bool RecvHi() override;
+    virtual bool AnswerHiRpc() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+
+    bool mGotHi;
+    Transport* mTransport;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestBridgeMain_h
diff --git a/ipc/ipdl/test/cxx/TestCancel.cpp b/ipc/ipdl/test/cxx/TestCancel.cpp
new file mode 100644
index 000000000..8f983b3de
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestCancel.cpp
@@ -0,0 +1,168 @@
+#include "TestCancel.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestCancelParent::TestCancelParent()
+{
+    MOZ_COUNT_CTOR(TestCancelParent);
+}
+
+TestCancelParent::~TestCancelParent()
+{
+    MOZ_COUNT_DTOR(TestCancelParent);
+}
+
+void
+TestCancelParent::Main()
+{
+    if (SendTest1_1())
+	fail("sending Test1_1");
+
+    uint32_t value = 0;
+    if (!SendCheckChild(&value))
+	fail("Test1 CheckChild");
+
+    if (value != 12)
+	fail("Test1 CheckChild reply");
+}
+
+bool
+TestCancelParent::RecvDone1()
+{
+    if (!SendStart2())
+	fail("sending Start2");
+
+    return true;
+}
+
+bool
+TestCancelParent::RecvTest2_1()
+{
+    if (SendTest2_2())
+	fail("sending Test2_2");
+
+    return true;
+}
+
+bool
+TestCancelParent::RecvStart3()
+{
+    if (SendTest3_1())
+	fail("sending Test3_1");
+
+    uint32_t value = 0;
+    if (!SendCheckChild(&value))
+	fail("Test1 CheckChild");
+
+    if (value != 12)
+	fail("Test1 CheckChild reply");
+
+    return true;
+}
+
+bool
+TestCancelParent::RecvTest3_2()
+{
+    GetIPCChannel()->CancelCurrentTransaction();
+    return true;
+}
+
+bool
+TestCancelParent::RecvDone()
+{
+    MessageLoop::current()->PostTask(
+	NewNonOwningRunnableMethod(this, &TestCancelParent::Close));
+    return true;
+}
+
+bool
+TestCancelParent::RecvCheckParent(uint32_t *reply)
+{
+    *reply = 12;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+bool
+TestCancelChild::RecvTest1_1()
+{
+    GetIPCChannel()->CancelCurrentTransaction();
+
+    uint32_t value = 0;
+    if (!SendCheckParent(&value))
+	fail("Test1 CheckParent");
+
+    if (value != 12)
+	fail("Test1 CheckParent reply");
+
+    if (!SendDone1())
+	fail("Test1 CheckParent");
+
+    return true;
+}
+
+bool
+TestCancelChild::RecvStart2()
+{
+    if (!SendTest2_1())
+	fail("sending Test2_1");
+
+    if (!SendStart3())
+	fail("sending Start3");
+
+    return true;
+}
+
+bool
+TestCancelChild::RecvTest2_2()
+{
+    GetIPCChannel()->CancelCurrentTransaction();
+    return true;
+}
+
+bool
+TestCancelChild::RecvTest3_1()
+{
+    if (SendTest3_2())
+	fail("sending Test3_2");
+
+    uint32_t value = 0;
+    if (!SendCheckParent(&value))
+	fail("Test1 CheckParent");
+
+    if (value != 12)
+	fail("Test1 CheckParent reply");
+
+    if (!SendDone())
+	fail("sending Done");
+
+    return true;
+}
+
+bool
+TestCancelChild::RecvCheckChild(uint32_t *reply)
+{
+    *reply = 12;
+    return true;
+}
+
+TestCancelChild::TestCancelChild()
+{
+    MOZ_COUNT_CTOR(TestCancelChild);
+}
+
+TestCancelChild::~TestCancelChild()
+{
+    MOZ_COUNT_DTOR(TestCancelChild);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestCancel.h b/ipc/ipdl/test/cxx/TestCancel.h
new file mode 100644
index 000000000..8cd51acd1
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestCancel.h
@@ -0,0 +1,66 @@
+#ifndef mozilla__ipdltest_TestCancel_h
+#define mozilla__ipdltest_TestCancel_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestCancelParent.h"
+#include "mozilla/_ipdltest/PTestCancelChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestCancelParent :
+    public PTestCancelParent
+{
+public:
+    TestCancelParent();
+    virtual ~TestCancelParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+    virtual bool RecvDone1() override;
+    virtual bool RecvTest2_1() override;
+    virtual bool RecvStart3() override;
+    virtual bool RecvTest3_2() override;
+    virtual bool RecvDone() override;
+
+    virtual bool RecvCheckParent(uint32_t *reply) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestCancelChild :
+    public PTestCancelChild
+{
+public:
+    TestCancelChild();
+    virtual ~TestCancelChild();
+
+    virtual bool RecvTest1_1() override;
+    virtual bool RecvStart2() override;
+    virtual bool RecvTest2_2() override;
+    virtual bool RecvTest3_1() override;
+
+    virtual bool RecvCheckChild(uint32_t *reply) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestCancel_h
diff --git a/ipc/ipdl/test/cxx/TestCrashCleanup.cpp b/ipc/ipdl/test/cxx/TestCrashCleanup.cpp
new file mode 100644
index 000000000..2f335daae
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestCrashCleanup.cpp
@@ -0,0 +1,116 @@
+#include "TestCrashCleanup.h"
+
+#include "base/task.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#include "IPDLUnitTestSubprocess.h"
+
+using mozilla::CondVar;
+using mozilla::Mutex;
+using mozilla::MutexAutoLock;
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+namespace {
+
+// NB: this test does its own shutdown, rather than going through
+// QuitParent(), because it's testing degenerate edge cases
+
+void DeleteSubprocess(Mutex* mutex, CondVar* cvar)
+{
+    MutexAutoLock lock(*mutex);
+
+    delete gSubprocess;
+    gSubprocess = nullptr;
+
+    cvar->Notify();
+}
+
+void DeleteTheWorld()
+{
+    delete static_cast<TestCrashCleanupParent*>(gParentActor);
+    gParentActor = nullptr;
+
+    // needs to be synchronous to avoid affecting event ordering on
+    // the main thread
+    Mutex mutex("TestCrashCleanup.DeleteTheWorld.mutex");
+    CondVar cvar(mutex, "TestCrashCleanup.DeleteTheWorld.cvar");
+
+    MutexAutoLock lock(mutex);
+
+    XRE_GetIOMessageLoop()->PostTask(
+      NewRunnableFunction(DeleteSubprocess, &mutex, &cvar));
+
+    cvar.Wait();
+}
+
+void Done()
+{
+  static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
+  nsCOMPtr<nsIAppShell> appShell (do_GetService(kAppShellCID));
+  appShell->Exit();
+
+  passed(__FILE__);
+}
+
+} // namespace <anon>
+
+TestCrashCleanupParent::TestCrashCleanupParent() : mCleanedUp(false)
+{
+    MOZ_COUNT_CTOR(TestCrashCleanupParent);
+}
+
+TestCrashCleanupParent::~TestCrashCleanupParent()
+{
+    MOZ_COUNT_DTOR(TestCrashCleanupParent);
+
+    if (!mCleanedUp)
+        fail("should have been ActorDestroy()d!");
+}
+
+void
+TestCrashCleanupParent::Main()
+{
+    // NB: has to be enqueued before IO thread's error notification
+    MessageLoop::current()->PostTask(
+        NewRunnableFunction(DeleteTheWorld));
+
+    if (CallDIEDIEDIE())
+        fail("expected an error!");
+
+    Close();
+
+    MessageLoop::current()->PostTask(NewRunnableFunction(Done));
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+TestCrashCleanupChild::TestCrashCleanupChild()
+{
+    MOZ_COUNT_CTOR(TestCrashCleanupChild);
+}
+
+TestCrashCleanupChild::~TestCrashCleanupChild()
+{
+    MOZ_COUNT_DTOR(TestCrashCleanupChild);
+}
+
+bool
+TestCrashCleanupChild::AnswerDIEDIEDIE()
+{
+    _exit(0);
+    NS_RUNTIMEABORT("unreached");
+    return false;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestCrashCleanup.h b/ipc/ipdl/test/cxx/TestCrashCleanup.h
new file mode 100644
index 000000000..b64b2c628
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestCrashCleanup.h
@@ -0,0 +1,58 @@
+#ifndef mozilla__ipdltest_TestCrashCleanup_h
+#define mozilla__ipdltest_TestCrashCleanup_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestCrashCleanupParent.h"
+#include "mozilla/_ipdltest/PTestCrashCleanupChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestCrashCleanupParent :
+    public PTestCrashCleanupParent
+{
+public:
+    TestCrashCleanupParent();
+    virtual ~TestCrashCleanupParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:    
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (AbnormalShutdown != why)
+            fail("unexpected destruction!");
+        mCleanedUp = true;
+    }
+
+    bool mCleanedUp;
+};
+
+
+class TestCrashCleanupChild :
+    public PTestCrashCleanupChild
+{
+public:
+    TestCrashCleanupChild();
+    virtual ~TestCrashCleanupChild();
+
+protected:
+    virtual bool AnswerDIEDIEDIE() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        fail("should have 'crashed'!");
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestCrashCleanup_h
diff --git a/ipc/ipdl/test/cxx/TestDataStructures.cpp b/ipc/ipdl/test/cxx/TestDataStructures.cpp
new file mode 100644
index 000000000..fe0d5918a
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestDataStructures.cpp
@@ -0,0 +1,984 @@
+#include "TestDataStructures.h"
+
+#include "mozilla/Unused.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+typedef InfallibleTArray<nsIntRegion> RegionArray;
+
+namespace mozilla {
+namespace _ipdltest {
+
+static const uint32_t nactors = 10;
+
+#define test_assert(_cond, _msg) \
+    if (!(_cond)) fail(_msg)
+
+template<typename T>
+static void
+assert_arrays_equal(const InfallibleTArray<T>& a, const InfallibleTArray<T>& b)
+{
+    test_assert(a == b, "arrays equal");
+}
+
+inline static TestDataStructuresSub&
+Cast(PTestDataStructuresSubParent* a)
+{
+    return *static_cast<TestDataStructuresSub*>(a);
+}
+
+inline static TestDataStructuresSub&
+Cast(PTestDataStructuresSubChild* a)
+{
+    return *static_cast<TestDataStructuresSub*>(a);
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestDataStructuresParent::TestDataStructuresParent()
+{
+    MOZ_COUNT_CTOR(TestDataStructuresParent);
+}
+
+TestDataStructuresParent::~TestDataStructuresParent()
+{
+    MOZ_COUNT_DTOR(TestDataStructuresParent);
+}
+
+void
+TestDataStructuresParent::Main()
+{
+    for (uint32_t i = 0; i < nactors; ++i)
+        if (!SendPTestDataStructuresSubConstructor(i))
+            fail("can't alloc actor");
+
+    if (!SendStart())
+        fail("can't send Start()");
+}
+
+bool
+TestDataStructuresParent::DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor)
+{
+    test_assert(Cast(actor).mI == Cast(mKids[0]).mI,
+                "dtor sent to wrong actor");
+    mKids.RemoveElementAt(0);
+    delete actor;
+    if (mKids.Length() > 0)
+        return true;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest1(
+        InfallibleTArray<int>&& ia,
+        InfallibleTArray<int>* oa)
+{
+    test_assert(5 == ia.Length(), "wrong length");
+    for (int i = 0; i < 5; ++i)
+        test_assert(i == ia[i], "wrong value");
+
+    *oa = ia;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest2(
+        InfallibleTArray<PTestDataStructuresSubParent*>&& i1,
+        InfallibleTArray<PTestDataStructuresSubParent*>* o1)
+{
+    test_assert(nactors == i1.Length(), "wrong #actors");
+    for (uint32_t i = 0; i < i1.Length(); ++i)
+        test_assert(i == Cast(i1[i]).mI, "wrong mI value");
+    *o1 = i1;
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest3(
+        const IntDouble& i1,
+        const IntDouble& i2,
+        IntDouble* o1,
+        IntDouble* o2)
+{   
+    test_assert(42 == i1.get_int(), "wrong value");
+    test_assert(4.0 == i2.get_double(), "wrong value");
+
+    *o1 = i1;
+    *o2 = i2;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest4(
+        InfallibleTArray<IntDouble>&& i1,
+        InfallibleTArray<IntDouble>* o1)
+{
+    test_assert(4 == i1.Length(), "wrong length");
+    test_assert(1 == i1[0].get_int(), "wrong value");
+    test_assert(2.0 == i1[1].get_double(), "wrong value");
+    test_assert(3 == i1[2].get_int(), "wrong value");
+    test_assert(4.0 == i1[3].get_double(), "wrong value");    
+
+    *o1 = i1;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest5(
+        const IntDoubleArrays& i1,
+        const IntDoubleArrays& i2,
+        const IntDoubleArrays& i3,
+        IntDoubleArrays* o1,
+        IntDoubleArrays* o2,
+        IntDoubleArrays* o3)
+{
+    test_assert(42 == i1.get_int(), "wrong value");
+
+    const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
+    test_assert(3 == i2a.Length(), "wrong length");
+    test_assert(1 == i2a[0], "wrong value");
+    test_assert(2 == i2a[1], "wrong value");
+    test_assert(3 == i2a[2], "wrong value");
+
+    const InfallibleTArray<double>& i3a = i3.get_ArrayOfdouble();
+    test_assert(3 == i3a.Length(), "wrong length");
+    test_assert(1.0 == i3a[0], "wrong value");
+    test_assert(2.0 == i3a[1], "wrong value");
+    test_assert(3.0 == i3a[2], "wrong value");
+
+    *o1 = i1;
+    *o2 = i2a;
+    *o3 = i3a;
+
+    return true;
+}
+
+bool
+TestDataStructuresParent::RecvTest7_0(const ActorWrapper& i1,
+                                      ActorWrapper* o1)
+{
+    if (i1.actorChild() != nullptr)
+        fail("child side actor should always be null");
+
+    if (i1.actorParent() != mKids[0])
+        fail("should have got back same actor on parent side");
+
+    o1->actorParent() = mKids[0];
+    // malicious behavior
+    o1->actorChild() =
+        reinterpret_cast<PTestDataStructuresSubChild*>(uintptr_t(0xdeadbeef));
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest6(
+        InfallibleTArray<IntDoubleArrays>&& i1,
+        InfallibleTArray<IntDoubleArrays>* o1)
+{
+    test_assert(3 == i1.Length(), "wrong length");
+
+    IntDoubleArrays id1(i1[0]);
+    test_assert(42 == id1.get_int(), "wrong value");
+
+    InfallibleTArray<int> i2a(i1[1].get_ArrayOfint());
+    test_assert(3 == i2a.Length(), "wrong length");
+    test_assert(1 == i2a[0], "wrong value");
+    test_assert(2 == i2a[1], "wrong value");
+    test_assert(3 == i2a[2], "wrong value");
+
+    InfallibleTArray<double> i3a(i1[2].get_ArrayOfdouble());
+    test_assert(3 == i3a.Length(), "wrong length");
+    test_assert(1.0 == i3a[0], "wrong value");
+    test_assert(2.0 == i3a[1], "wrong value");
+    test_assert(3.0 == i3a[2], "wrong value");
+
+    o1->AppendElement(id1);
+    o1->AppendElement(IntDoubleArrays(i2a));
+    o1->AppendElement(IntDoubleArrays(i3a));
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest7(
+        const Actors& i1,
+        const Actors& i2,
+        const Actors& i3,
+        Actors* o1,
+        Actors* o2,
+        Actors* o3)
+{
+    test_assert(42 == i1.get_int(), "wrong value");
+
+    InfallibleTArray<int> i2a(i2.get_ArrayOfint());
+    test_assert(3 == i2a.Length(), "wrong length");
+    test_assert(1 == i2a[0], "wrong value");
+    test_assert(2 == i2a[1], "wrong value");
+    test_assert(3 == i2a[2], "wrong value");
+
+    assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
+
+    *o1 = 42;
+    *o2 = i2a;
+    *o3 = mKids;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest8(
+        InfallibleTArray<Actors>&& i1,
+        InfallibleTArray<Actors>* o1)
+{
+    test_assert(3 == i1.Length(), "wrong length");
+    test_assert(42 == i1[0].get_int(), "wrong value");
+
+    const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
+    test_assert(3 == i2a.Length(), "wrong length");
+    test_assert(1 == i2a[0], "wrong value");
+    test_assert(2 == i2a[1], "wrong value");
+    test_assert(3 == i2a[2], "wrong value");
+
+    assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
+
+    *o1 = i1;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest9(
+        const Unions& i1,
+        const Unions& i2,
+        const Unions& i3,
+        const Unions& i4,
+        Unions* o1,
+        Unions* o2,
+        Unions* o3,
+        Unions* o4)
+{
+    test_assert(42 == i1.get_int(), "wrong value");
+
+    const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
+    test_assert(3 == i2a.Length(), "wrong length");
+    test_assert(1 == i2a[0], "wrong value");
+    test_assert(2 == i2a[1], "wrong value");
+    test_assert(3 == i2a[2], "wrong value");
+
+    assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
+
+    const InfallibleTArray<PTestDataStructuresSubParent*>& i4a = 
+        i4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
+    assert_arrays_equal(mKids, i4a);
+
+    *o1 = i1;
+    *o2 = i2;
+    *o3 = i3;
+    *o4 = i4;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest10(
+        InfallibleTArray<Unions>&& i1,
+        InfallibleTArray<Unions>* o1)
+{
+    test_assert(42 == i1[0].get_int(), "wrong value");
+
+    const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
+    test_assert(3 == i2a.Length(), "wrong length");
+    test_assert(1 == i2a[0], "wrong value");
+    test_assert(2 == i2a[1], "wrong value");
+    test_assert(3 == i2a[2], "wrong value");
+
+    assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
+
+    const InfallibleTArray<PTestDataStructuresSubParent*>& i4a = 
+        i1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
+    assert_arrays_equal(mKids, i4a);
+
+    *o1 = i1;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest11(
+            const SIntDouble& i,
+            SIntDouble* o)
+{
+    test_assert(1 == i.i(), "wrong value");
+    test_assert(2.0 == i.d(), "wrong value");
+    *o = i;
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest12(
+            const SIntDoubleArrays& i,
+            SIntDoubleArrays* o)
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);
+    ai.AppendElement(2);
+    ai.AppendElement(3);
+
+    InfallibleTArray<double> ad;
+    ad.AppendElement(.5);
+    ad.AppendElement(1.0);
+    ad.AppendElement(2.0);
+
+    test_assert(42 == i.i(), "wrong value");
+    assert_arrays_equal(ai, i.ai());
+    assert_arrays_equal(ad, i.ad());
+
+    *o = i;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest13(
+            const SActors& i,
+            SActors* o)
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    test_assert(42 == i.i(), "wrong value");
+    assert_arrays_equal(ai, i.ai());
+    assert_arrays_equal(mKids, i.apParent());
+
+    *o = i;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest14(
+            const Structs& i,
+            Structs* o)
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    test_assert(42 == i.i(), "wrong value");
+    assert_arrays_equal(ai, i.ai());
+    assert_arrays_equal(mKids, i.apParent());
+
+    const SActors& ia = i.aa()[0];
+    test_assert(42 == ia.i(), "wrong value");
+    assert_arrays_equal(ai, ia.ai());
+    assert_arrays_equal(mKids, ia.apParent());
+
+    *o = i;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest15(
+            const WithStructs& i1,
+            const WithStructs& i2,
+            const WithStructs& i3,
+            const WithStructs& i4,
+            const WithStructs& i5,
+            WithStructs* o1,
+            WithStructs* o2,
+            WithStructs* o3,
+            WithStructs* o4,
+            WithStructs* o5)
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    test_assert(i1 == int(42), "wrong value");
+    assert_arrays_equal(i2.get_ArrayOfint(), ai);
+    assert_arrays_equal(i3.get_ArrayOfPTestDataStructuresSubParent(), mKids);
+
+    const SActors& ia = i4.get_ArrayOfSActors()[0];
+    test_assert(42 == ia.i(), "wrong value");
+    assert_arrays_equal(ai, ia.ai());
+    assert_arrays_equal(mKids, ia.apParent());
+
+    const Structs& is = i5.get_ArrayOfStructs()[0];
+    test_assert(42 == is.i(), "wrong value");
+    assert_arrays_equal(ai, is.ai());
+    assert_arrays_equal(mKids, is.apParent());   
+
+    const SActors& isa = is.aa()[0];
+    test_assert(42 == isa.i(), "wrong value");
+    assert_arrays_equal(ai, isa.ai());
+    assert_arrays_equal(mKids, isa.apParent());
+
+    *o1 = i1;
+    *o2 = i2;
+    *o3 = i3;
+    *o4 = i4;
+    *o5 = i5;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest16(
+            const WithUnions& i,
+            WithUnions* o)
+{
+    test_assert(i.i() == 42, "wrong value");
+
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+    assert_arrays_equal(ai, i.ai());
+
+    assert_arrays_equal(i.apParent(), mKids);
+
+    assert_arrays_equal(mKids, i.aa()[0].get_ArrayOfPTestDataStructuresSubParent());
+
+    const InfallibleTArray<Unions>& iau = i.au();
+    test_assert(iau[0] == 42, "wrong value");
+    assert_arrays_equal(ai, iau[1].get_ArrayOfint());
+    assert_arrays_equal(mKids, iau[2].get_ArrayOfPTestDataStructuresSubParent());
+    assert_arrays_equal(mKids,
+                        iau[3].get_ArrayOfActors()[0]
+                        .get_ArrayOfPTestDataStructuresSubParent());
+
+    *o = i;
+
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest17(InfallibleTArray<Op>&& sa)
+{
+    test_assert(sa.Length() == 1 && Op::TSetAttrs == sa[0].type(),
+                "wrong value");
+    return true;
+}
+
+bool TestDataStructuresParent::RecvTest18(RegionArray&& ra)
+{
+    for (RegionArray::index_type i = 0; i < ra.Length(); ++i) {
+        // if |ra| has been realloc()d and given a different allocator
+        // chunk, this loop will nondeterministically crash or iloop.
+        for (auto iter = ra[i].RectIter(); !iter.Done(); iter.Next()) {
+            Unused << iter.Get();
+        }
+    }
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestDataStructuresChild::TestDataStructuresChild()
+{
+    MOZ_COUNT_CTOR(TestDataStructuresChild);
+}
+
+TestDataStructuresChild::~TestDataStructuresChild()
+{
+    MOZ_COUNT_DTOR(TestDataStructuresChild);
+}
+
+bool
+TestDataStructuresChild::RecvStart()
+{
+    puts("[TestDataStructuresChild] starting");
+
+    Test1();
+    Test2();
+    Test3();
+    Test4();
+    Test5();
+    Test6();
+    Test7_0();
+    Test7();
+    Test8();
+    Test9();
+    Test10();
+    Test11();
+    Test12();
+    Test13();
+    Test14();
+    Test15();
+    Test16();
+    Test17();
+    if (OtherPid() != base::GetCurrentProcId()) {
+        //FIXME/bug 703317 allocation of nsIntRegion uses a global
+        //region pool which breaks threads
+        Test18();
+    }
+
+    for (uint32_t i = 0; i < nactors; ++i)
+        if (!PTestDataStructuresSubChild::Send__delete__(mKids[i]))
+            fail("can't send dtor");
+
+    Close();
+
+    return true;
+}
+
+void
+TestDataStructuresChild::Test1()
+{
+    InfallibleTArray<int> ia;
+
+    for (int i = 0; i < 5; ++i)
+        ia.AppendElement(i);
+
+    InfallibleTArray<int> oa;
+    if (!SendTest1(ia, &oa))
+        fail("can't send Test1");
+
+    assert_arrays_equal(ia, oa);
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test2()
+{
+    InfallibleTArray<PTestDataStructuresSubChild*> oa;
+    if (!SendTest2(mKids, &oa))
+        fail("can't send Test2");
+    assert_arrays_equal(mKids, oa);
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test3()
+{
+    int i1i = 42;
+    double i2d = 4.0;
+    IntDouble i1(i1i);
+    IntDouble i2(i2d);
+    IntDouble o1, o2;
+
+    SendTest3(i1, i2, &o1, &o2);
+
+    test_assert(i1i == o1.get_int(), "wrong value");
+    test_assert(i2d == o2.get_double(), "wrong value");
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test4()
+{
+    InfallibleTArray<IntDouble> i1;
+    i1.AppendElement(IntDouble(int(1)));
+    i1.AppendElement(IntDouble(2.0));
+    i1.AppendElement(IntDouble(int(3)));
+    i1.AppendElement(IntDouble(4.0));
+
+    InfallibleTArray<IntDouble> o1;
+    if (!SendTest4(i1, &o1))
+        fail("can't send Test4");
+
+    // TODO Union::operator==()
+    test_assert(i1.Length() == o1.Length(), "wrong length");
+    test_assert(1 == o1[0].get_int(), "wrong value");
+    test_assert(2.0 == o1[1].get_double(), "wrong value");
+    test_assert(3 == o1[2].get_int(), "wrong value");
+    test_assert(4.0 == o1[3].get_double(), "wrong value");
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test5()
+{
+    IntDoubleArrays i1(int(42));
+    InfallibleTArray<int> i2;
+    i2.AppendElement(1); i2.AppendElement(2); i2.AppendElement(3);
+    InfallibleTArray<double> i3;
+    i3.AppendElement(1.0); i3.AppendElement(2.0); i3.AppendElement(3.0);
+
+    IntDoubleArrays o1, o2, o3;
+    if (!SendTest5(i1, IntDoubleArrays(i2), IntDoubleArrays(i3),
+                   &o1, &o2, &o3))
+        fail("can't send Test5");
+
+    test_assert(42 == o1.get_int(), "wrong value");
+    assert_arrays_equal(i2, o2.get_ArrayOfint());
+    assert_arrays_equal(i3, o3.get_ArrayOfdouble());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test6()
+{
+    IntDoubleArrays id1(int(42));
+    InfallibleTArray<int> id2;
+    id2.AppendElement(1); id2.AppendElement(2); id2.AppendElement(3);
+    InfallibleTArray<double> id3;
+    id3.AppendElement(1.0); id3.AppendElement(2.0); id3.AppendElement(3.0);
+
+    InfallibleTArray<IntDoubleArrays> i1;
+    i1.AppendElement(id1);
+    i1.AppendElement(IntDoubleArrays(id2));
+    i1.AppendElement(IntDoubleArrays(id3));
+
+    InfallibleTArray<IntDoubleArrays> o1;
+    if (!SendTest6(i1, &o1))
+        fail("can't send Test6");
+
+    test_assert(3 == o1.Length(), "wrong length");
+    IntDoubleArrays od1(o1[0]);
+    InfallibleTArray<int> od2(o1[1].get_ArrayOfint());
+    InfallibleTArray<double> od3(o1[2].get_ArrayOfdouble());
+
+    test_assert(42 == od1.get_int(), "wrong value");
+    assert_arrays_equal(id2, od2);
+    assert_arrays_equal(id3, od3);
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test7_0()
+{
+    ActorWrapper iaw;
+    if (iaw.actorChild() != nullptr || iaw.actorParent() != nullptr)
+        fail("actor members should be null initially");
+
+    iaw.actorChild() = mKids[0];
+    if (iaw.actorParent() != nullptr)
+        fail("parent should be null on child side after set");
+
+    ActorWrapper oaw;
+    if (!SendTest7_0(iaw, &oaw))
+        fail("sending Test7_0");
+
+    if (oaw.actorParent() != nullptr)
+        fail("parent accessor on actor-struct members should always be null in child");
+
+    if (oaw.actorChild() != mKids[0])
+        fail("should have got back same child-side actor");
+}
+
+void
+TestDataStructuresChild::Test7()
+{
+    Actors i1(42);
+    InfallibleTArray<int> i2a;
+    i2a.AppendElement(1);  i2a.AppendElement(2);  i2a.AppendElement(3);
+
+    Actors o1, o2, o3;
+    if (!SendTest7(i1, Actors(i2a), Actors(mKids), &o1, &o2, &o3))
+        fail("can't send Test7");
+
+    test_assert(42 == o1.get_int(), "wrong value");
+    assert_arrays_equal(i2a, o2.get_ArrayOfint());
+    assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test8()
+{
+    Actors i1e(42);
+    InfallibleTArray<int> i2a;
+    i2a.AppendElement(1);  i2a.AppendElement(2);  i2a.AppendElement(3);
+
+    InfallibleTArray<Actors> i1;
+    i1.AppendElement(i1e);
+    i1.AppendElement(i2a);
+    i1.AppendElement(mKids);
+
+    InfallibleTArray<Actors> o1;
+    if (!SendTest8(i1, &o1))
+        fail("can't send Test8");
+
+    test_assert(3 == o1.Length(), "wrong length");
+    test_assert(42 == o1[0].get_int(), "wrong value");
+    assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
+    assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test9()
+{
+    Unions i1(int(42));
+
+    InfallibleTArray<int> i2a;
+    i2a.AppendElement(1);
+    i2a.AppendElement(2);
+    i2a.AppendElement(3);
+
+    InfallibleTArray<Actors> i4a;
+    i4a.AppendElement(mKids);
+
+    Unions o1, o2, o3, o4;
+    if (!SendTest9(i1, Unions(i2a), Unions(mKids), Unions(i4a),
+                   &o1, &o2, &o3, &o4))
+        fail("can't send Test9");
+
+    test_assert(42 == o1.get_int(), "wrong value");
+    assert_arrays_equal(i2a, o2.get_ArrayOfint());
+    assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
+    assert_arrays_equal(
+        mKids,
+        o4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test10()
+{
+    Unions i1a(int(42));
+
+    InfallibleTArray<int> i2a;
+    i2a.AppendElement(1);
+    i2a.AppendElement(2);
+    i2a.AppendElement(3);
+
+    InfallibleTArray<Actors> i4a;
+    i4a.AppendElement(mKids);
+
+    InfallibleTArray<Unions> i1;
+    i1.AppendElement(i1a);
+    i1.AppendElement(Unions(i2a));
+    i1.AppendElement(Unions(mKids));
+    i1.AppendElement(Unions(i4a));
+
+    InfallibleTArray<Unions> o1;
+    if (!SendTest10(i1, &o1))
+        fail("can't send Test10");
+
+    test_assert(4 == o1.Length(), "wrong length");
+    test_assert(42 == o1[0].get_int(), "wrong value");
+    assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
+    assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
+    assert_arrays_equal(
+        mKids,
+        o1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test11()
+{
+    SIntDouble i(1, 2.0);
+    SIntDouble o;
+
+    if (!SendTest11(i, &o))
+        fail("sending Test11");
+
+    test_assert(1 == o.i() && 2.0 == o.d(), "wrong values");
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test12()
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    InfallibleTArray<double> ad;
+    ad.AppendElement(.5);  ad.AppendElement(1.0);  ad.AppendElement(2.0);
+
+    SIntDoubleArrays i(42, ai, ad);
+    SIntDoubleArrays o;
+
+    if (!SendTest12(i, &o))
+        fail("sending Test12");
+
+    test_assert(42 == o.i(), "wrong value");
+    assert_arrays_equal(ai, o.ai());
+    assert_arrays_equal(ad, o.ad());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test13()
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    SActors i;
+    i.i() = 42;
+    i.ai() = ai;
+    i.apChild() = mKids;
+
+    SActors o;
+    if (!SendTest13(i, &o))
+        fail("can't send Test13");
+
+    test_assert(42 == o.i(), "wrong value");
+    assert_arrays_equal(ai, o.ai());
+    assert_arrays_equal(mKids, o.apChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test14()
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    SActors ia;
+    ia.i() = 42;
+    ia.ai() = ai;
+    ia.apChild() = mKids;
+    InfallibleTArray<SActors> aa;  aa.AppendElement(ia);
+
+    Structs i;
+    i.i() = 42;
+    i.ai() = ai;
+    i.apChild() = mKids;
+    i.aa() = aa;
+
+    Structs o;
+    if (!SendTest14(i, &o))
+        fail("can't send Test14");
+
+    test_assert(42 == o.i(), "wrong value");
+    assert_arrays_equal(ai, o.ai());
+    assert_arrays_equal(mKids, o.apChild());
+
+    const SActors& os = o.aa()[0];
+    test_assert(42 == os.i(), "wrong value");
+    assert_arrays_equal(ai, os.ai());
+    assert_arrays_equal(mKids, os.apChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test15()
+{
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+
+    SActors ia;
+    ia.i() = 42;
+    ia.ai() = ai;
+    ia.apChild() = mKids;
+    InfallibleTArray<SActors> iaa;  iaa.AppendElement(ia);
+
+    Structs is;
+    is.i() = 42;
+    is.ai() = ai;
+    is.apChild() = mKids;
+    is.aa() = iaa;
+    InfallibleTArray<Structs> isa;  isa.AppendElement(is);
+
+    WithStructs o1, o2, o3, o4, o5;
+    if (!SendTest15(WithStructs(42),
+                    WithStructs(ai),
+                    WithStructs(mKids),
+                    WithStructs(iaa),
+                    WithStructs(isa),
+                    &o1, &o2, &o3, &o4, &o5))
+        fail("sending Test15");
+
+    test_assert(o1 == int(42), "wrong value");
+    assert_arrays_equal(o2.get_ArrayOfint(), ai);
+    assert_arrays_equal(o3.get_ArrayOfPTestDataStructuresSubChild(), mKids);
+
+    const SActors& oa = o4.get_ArrayOfSActors()[0];
+    test_assert(42 == oa.i(), "wrong value");
+    assert_arrays_equal(ai, oa.ai());
+    assert_arrays_equal(mKids, oa.apChild());
+
+    const Structs& os = o5.get_ArrayOfStructs()[0];
+    test_assert(42 == os.i(), "wrong value");
+    assert_arrays_equal(ai, os.ai());
+    assert_arrays_equal(mKids, os.apChild());   
+
+    const SActors& osa = os.aa()[0];
+    test_assert(42 == osa.i(), "wrong value");
+    assert_arrays_equal(ai, osa.ai());
+    assert_arrays_equal(mKids, osa.apChild());
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test16()
+{
+    WithUnions i;
+
+    i.i() = 42;
+
+    InfallibleTArray<int> ai;
+    ai.AppendElement(1);  ai.AppendElement(2);  ai.AppendElement(3);
+    i.ai() = ai;
+
+    i.apChild() = mKids;
+
+    InfallibleTArray<Actors> iaa;
+    iaa.AppendElement(mKids);
+    i.aa() = iaa;
+
+    InfallibleTArray<Unions> iau;
+    iau.AppendElement(int(42));
+    iau.AppendElement(ai);
+    iau.AppendElement(mKids);
+    iau.AppendElement(iaa);
+    i.au() = iau;
+
+    WithUnions o;
+    if (!SendTest16(i, &o))
+        fail("sending Test16");
+
+    test_assert(42 == o.i(), "wrong value");
+    assert_arrays_equal(o.ai(), ai);
+    assert_arrays_equal(o.apChild(), mKids);
+
+    const Actors& oaa = o.aa()[0];
+    assert_arrays_equal(oaa.get_ArrayOfPTestDataStructuresSubChild(), mKids);
+
+    const InfallibleTArray<Unions>& oau = o.au();
+    test_assert(oau[0] == 42, "wrong value");
+    assert_arrays_equal(oau[1].get_ArrayOfint(), ai);
+    assert_arrays_equal(oau[2].get_ArrayOfPTestDataStructuresSubChild(),
+                        mKids);
+    assert_arrays_equal(oau[3].get_ArrayOfActors()[0]
+                        .get_ArrayOfPTestDataStructuresSubChild(),
+                        mKids);
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test17()
+{
+    Attrs attrs;
+    attrs.common() = CommonAttrs(true);
+    attrs.specific() = BarAttrs(1.0f);
+
+    InfallibleTArray<Op> ops;
+    ops.AppendElement(SetAttrs(nullptr, mKids[0], attrs));
+
+    if (!SendTest17(ops))
+        fail("sending Test17");
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+void
+TestDataStructuresChild::Test18()
+{
+    const int nelements = 1000;
+    RegionArray ra;
+    // big enough to hopefully force a realloc to a different chunk of
+    // memory on the receiving side, if the workaround isn't working
+    // correctly.  But SetCapacity() here because we don't want to
+    // crash on the sending side.
+    ra.SetCapacity(nelements);
+    for (int i = 0; i < nelements; ++i) {
+        nsIntRegion r;
+        r.Or(nsIntRect(0, 0, 10, 10), nsIntRect(10, 10, 10, 10));
+        ra.AppendElement(r);
+    }
+
+    if (!SendTest18(ra))
+        fail("sending Test18");
+
+    printf("  passed %s\n", __FUNCTION__);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestDataStructures.h b/ipc/ipdl/test/cxx/TestDataStructures.h
new file mode 100644
index 000000000..f77cfa100
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestDataStructures.h
@@ -0,0 +1,234 @@
+#ifndef mozilla__ipdltest_TestDataStructures_h
+#define mozilla__ipdltest_TestDataStructures_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestDataStructuresParent.h"
+#include "mozilla/_ipdltest/PTestDataStructuresChild.h"
+
+#include "mozilla/_ipdltest/PTestDataStructuresSubParent.h"
+#include "mozilla/_ipdltest/PTestDataStructuresSubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Subprotocol actors
+
+class TestDataStructuresSub :
+        public PTestDataStructuresSubParent,
+        public PTestDataStructuresSubChild
+{
+public:
+    explicit TestDataStructuresSub(uint32_t i) : mI(i)
+    { }
+    virtual ~TestDataStructuresSub()
+    { }
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+      if (Deletion != why)
+        fail("unexpected destruction!");
+    }
+  uint32_t mI;
+};
+
+//-----------------------------------------------------------------------------
+// Main actors
+
+class TestDataStructuresParent :
+    public PTestDataStructuresParent
+{
+public:
+    TestDataStructuresParent();
+    virtual ~TestDataStructuresParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual PTestDataStructuresSubParent* AllocPTestDataStructuresSubParent(const int& i) override
+    {
+        PTestDataStructuresSubParent* actor = new TestDataStructuresSub(i);
+        mKids.AppendElement(actor);
+        return actor;
+    }
+
+    virtual bool DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor) override;
+
+    virtual bool RecvTest1(
+	    InfallibleTArray<int>&& i1,
+            InfallibleTArray<int>* o1) override;
+
+    virtual bool RecvTest2(
+            InfallibleTArray<PTestDataStructuresSubParent*>&& i1,
+            InfallibleTArray<PTestDataStructuresSubParent*>* o1) override;
+
+    virtual bool RecvTest3(
+            const IntDouble& i1,
+            const IntDouble& i2,
+            IntDouble* o1,
+            IntDouble* o2) override;
+
+    virtual bool RecvTest4(
+            InfallibleTArray<IntDouble>&& i1,
+            InfallibleTArray<IntDouble>* o1) override;
+
+    virtual bool RecvTest5(
+            const IntDoubleArrays& i1,
+            const IntDoubleArrays& i2,
+            const IntDoubleArrays& i3,
+            IntDoubleArrays* o1,
+            IntDoubleArrays* o2,
+            IntDoubleArrays* o3) override;
+
+    virtual bool RecvTest6(
+            InfallibleTArray<IntDoubleArrays>&& i1,
+            InfallibleTArray<IntDoubleArrays>* o1) override;
+
+
+    virtual bool RecvTest7_0(const ActorWrapper& i1,
+                             ActorWrapper* o1) override;
+
+    virtual bool RecvTest7(
+            const Actors& i1,
+            const Actors& i2,
+            const Actors& i3,
+            Actors* o1,
+            Actors* o2,
+            Actors* o3) override;
+
+    virtual bool RecvTest8(
+            InfallibleTArray<Actors>&& i1,
+            InfallibleTArray<Actors>* o1) override;
+
+    virtual bool RecvTest9(
+            const Unions& i1,
+            const Unions& i2,
+            const Unions& i3,
+            const Unions& i4,
+            Unions* o1,
+            Unions* o2,
+            Unions* o3,
+            Unions* o4) override;
+
+    virtual bool RecvTest10(
+            InfallibleTArray<Unions>&& i1,
+            InfallibleTArray<Unions>* o1) override;
+
+    virtual bool RecvTest11(
+            const SIntDouble& i,
+            SIntDouble* o) override;
+
+    virtual bool RecvTest12(
+            const SIntDoubleArrays& i,
+            SIntDoubleArrays* o) override;
+
+    virtual bool RecvTest13(
+            const SActors& i,
+            SActors* o) override;
+
+    virtual bool RecvTest14(
+            const Structs& i,
+            Structs* o) override;
+
+    virtual bool RecvTest15(
+            const WithStructs& i1,
+            const WithStructs& i2,
+            const WithStructs& i3,
+            const WithStructs& i4,
+            const WithStructs& i5,
+            WithStructs* o1,
+            WithStructs* o2,
+            WithStructs* o3,
+            WithStructs* o4,
+            WithStructs* o5) override;
+
+    virtual bool RecvTest16(
+            const WithUnions& i,
+            WithUnions* o) override;
+
+    virtual bool RecvTest17(InfallibleTArray<Op>&& sa) override;
+
+    virtual bool RecvTest18(InfallibleTArray<nsIntRegion>&& ra) override;
+
+    virtual bool RecvDummy(const ShmemUnion& su, ShmemUnion* rsu) override
+    {
+        *rsu = su;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    InfallibleTArray<PTestDataStructuresSubParent*> mKids;
+};
+
+
+class TestDataStructuresChild :
+    public PTestDataStructuresChild
+{
+public:
+    TestDataStructuresChild();
+    virtual ~TestDataStructuresChild();
+
+protected:
+    virtual PTestDataStructuresSubChild* AllocPTestDataStructuresSubChild(const int& i) override
+    {
+        PTestDataStructuresSubChild* actor = new TestDataStructuresSub(i);
+        mKids.AppendElement(actor);
+        return actor;
+    }
+
+    virtual bool DeallocPTestDataStructuresSubChild(PTestDataStructuresSubChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual bool RecvStart() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+
+private:
+    void Test1();
+    void Test2();
+    void Test3();
+    void Test4();
+    void Test5();
+    void Test6();
+    void Test7_0();
+    void Test7();
+    void Test8();
+    void Test9();
+    void Test10();
+    void Test11();
+    void Test12();
+    void Test13();
+    void Test14();
+    void Test15();
+    void Test16();
+    void Test17();
+    void Test18();
+
+    InfallibleTArray<PTestDataStructuresSubChild*> mKids;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestDataStructures_h
diff --git a/ipc/ipdl/test/cxx/TestDemon.cpp b/ipc/ipdl/test/cxx/TestDemon.cpp
new file mode 100644
index 000000000..c349aafbe
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestDemon.cpp
@@ -0,0 +1,417 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=4 ts=4 et :
+ */
+#include "TestDemon.h"
+
+#include <stdlib.h>
+
+#include "IPDLUnitTests.h"      // fail etc.
+#if defined(OS_POSIX)
+#include <sys/time.h>
+#include <unistd.h>
+#else
+#include <time.h>
+#include <windows.h>
+#endif
+
+namespace mozilla {
+namespace _ipdltest {
+
+const int kMaxStackHeight = 4;
+
+static LazyLogModule sLogModule("demon");
+
+#define DEMON_LOG(...) MOZ_LOG(sLogModule, LogLevel::Debug, (__VA_ARGS__))
+
+static int gStackHeight = 0;
+static bool gFlushStack = false;
+
+static int
+Choose(int count)
+{
+#if defined(OS_POSIX)
+  return random() % count;
+#else
+  return rand() % count;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestDemonParent::TestDemonParent()
+ : mDone(false),
+   mIncoming(),
+   mOutgoing()
+{
+  MOZ_COUNT_CTOR(TestDemonParent);
+}
+
+TestDemonParent::~TestDemonParent()
+{
+  MOZ_COUNT_DTOR(TestDemonParent);
+}
+
+void
+TestDemonParent::Main()
+{
+  if (!getenv("MOZ_TEST_IPC_DEMON")) {
+    QuitParent();
+    return;
+  }
+#if defined(OS_POSIX)
+  srandom(time(nullptr));
+#else
+  srand(time(nullptr));
+#endif
+
+  DEMON_LOG("Start demon");
+
+  if (!SendStart())
+	fail("sending Start");
+
+  RunUnlimitedSequence();
+}
+
+#ifdef DEBUG
+bool
+TestDemonParent::ShouldContinueFromReplyTimeout()
+{
+  return Choose(2) == 0;
+}
+
+bool
+TestDemonParent::ArtificialTimeout()
+{
+  return Choose(5) == 0;
+}
+
+void
+TestDemonParent::ArtificialSleep()
+{
+  if (Choose(2) == 0) {
+    // Sleep for anywhere from 0 to 100 milliseconds.
+    unsigned micros = Choose(100) * 1000;
+#ifdef OS_POSIX
+    usleep(micros);
+#else
+    Sleep(micros / 1000);
+#endif
+  }
+}
+#endif
+
+bool
+TestDemonParent::RecvAsyncMessage(const int& n)
+{
+  DEMON_LOG("Start RecvAsync [%d]", n);
+
+  MOZ_ASSERT(n == mIncoming[0]);
+  mIncoming[0]++;
+
+  RunLimitedSequence();
+
+  DEMON_LOG("End RecvAsync [%d]", n);
+  return true;
+}
+
+bool
+TestDemonParent::RecvHiPrioSyncMessage()
+{
+  DEMON_LOG("Start RecvHiPrioSyncMessage");
+  RunLimitedSequence();
+  DEMON_LOG("End RecvHiPrioSyncMessage");
+  return true;
+}
+
+bool
+TestDemonParent::RecvSyncMessage(const int& n)
+{
+  DEMON_LOG("Start RecvSync [%d]", n);
+
+  MOZ_ASSERT(n == mIncoming[0]);
+  mIncoming[0]++;
+
+  RunLimitedSequence(ASYNC_ONLY);
+
+  DEMON_LOG("End RecvSync [%d]", n);
+  return true;
+}
+
+bool
+TestDemonParent::RecvUrgentAsyncMessage(const int& n)
+{
+  DEMON_LOG("Start RecvUrgentAsyncMessage [%d]", n);
+
+  MOZ_ASSERT(n == mIncoming[2]);
+  mIncoming[2]++;
+
+  RunLimitedSequence(ASYNC_ONLY);
+
+  DEMON_LOG("End RecvUrgentAsyncMessage [%d]", n);
+  return true;
+}
+
+bool
+TestDemonParent::RecvUrgentSyncMessage(const int& n)
+{
+  DEMON_LOG("Start RecvUrgentSyncMessage [%d]", n);
+
+  MOZ_ASSERT(n == mIncoming[2]);
+  mIncoming[2]++;
+
+  RunLimitedSequence(ASYNC_ONLY);
+
+  DEMON_LOG("End RecvUrgentSyncMessage [%d]", n);
+  return true;
+}
+
+void
+TestDemonParent::RunUnlimitedSequence()
+{
+  if (mDone) {
+    return;
+  }
+
+  gFlushStack = false;
+  DoAction();
+
+  MessageLoop::current()->PostTask(NewNonOwningRunnableMethod(this, &TestDemonParent::RunUnlimitedSequence));
+}
+
+void
+TestDemonParent::RunLimitedSequence(int flags)
+{
+  if (gStackHeight >= kMaxStackHeight) {
+    return;
+  }
+  gStackHeight++;
+
+  int count = Choose(20);
+  for (int i = 0; i < count; i++) {
+	if (!DoAction(flags)) {
+      gFlushStack = true;
+    }
+    if (gFlushStack) {
+      gStackHeight--;
+      return;
+    }
+  }
+
+  gStackHeight--;
+}
+
+static bool
+AllowAsync(int outgoing, int incoming)
+{
+  return incoming >= outgoing - 5;
+}
+
+bool
+TestDemonParent::DoAction(int flags)
+{
+  if (flags & ASYNC_ONLY) {
+    if (AllowAsync(mOutgoing[0], mIncoming[0])) {
+      DEMON_LOG("SendAsyncMessage [%d]", mOutgoing[0]);
+      return SendAsyncMessage(mOutgoing[0]++);
+    } else {
+      return true;
+    }
+  } else {
+	switch (Choose(3)) {
+     case 0:
+      if (AllowAsync(mOutgoing[0], mIncoming[0])) {
+        DEMON_LOG("SendAsyncMessage [%d]", mOutgoing[0]);
+        return SendAsyncMessage(mOutgoing[0]++);
+      } else {
+        return true;
+      }
+
+     case 1: {
+       DEMON_LOG("Start SendHiPrioSyncMessage");
+       bool r = SendHiPrioSyncMessage();
+       DEMON_LOG("End SendHiPrioSyncMessage result=%d", r);
+       return r;
+     }
+
+     case 2:
+      DEMON_LOG("Cancel");
+      GetIPCChannel()->CancelCurrentTransaction();
+      return true;
+	}
+  }
+  MOZ_CRASH();
+  return false;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+
+TestDemonChild::TestDemonChild()
+ : mIncoming(),
+   mOutgoing()
+{
+  MOZ_COUNT_CTOR(TestDemonChild);
+}
+
+TestDemonChild::~TestDemonChild()
+{
+  MOZ_COUNT_DTOR(TestDemonChild);
+}
+
+bool
+TestDemonChild::RecvStart()
+{
+#ifdef OS_POSIX
+  srandom(time(nullptr));
+#else
+  srand(time(nullptr));
+#endif
+
+  DEMON_LOG("RecvStart");
+
+  RunUnlimitedSequence();
+  return true;
+}
+
+#ifdef DEBUG
+void
+TestDemonChild::ArtificialSleep()
+{
+  if (Choose(2) == 0) {
+    // Sleep for anywhere from 0 to 100 milliseconds.
+    unsigned micros = Choose(100) * 1000;
+#ifdef OS_POSIX
+    usleep(micros);
+#else
+    Sleep(micros / 1000);
+#endif
+  }
+}
+#endif
+
+bool
+TestDemonChild::RecvAsyncMessage(const int& n)
+{
+  DEMON_LOG("Start RecvAsyncMessage [%d]", n);
+
+  MOZ_ASSERT(n == mIncoming[0]);
+  mIncoming[0]++;
+
+  RunLimitedSequence();
+
+  DEMON_LOG("End RecvAsyncMessage [%d]", n);
+  return true;
+}
+
+bool
+TestDemonChild::RecvHiPrioSyncMessage()
+{
+  DEMON_LOG("Start RecvHiPrioSyncMessage");
+  RunLimitedSequence();
+  DEMON_LOG("End RecvHiPrioSyncMessage");
+  return true;
+}
+
+void
+TestDemonChild::RunUnlimitedSequence()
+{
+  gFlushStack = false;
+  DoAction();
+
+  MessageLoop::current()->PostTask(NewNonOwningRunnableMethod(this, &TestDemonChild::RunUnlimitedSequence));
+}
+
+void
+TestDemonChild::RunLimitedSequence()
+{
+  if (gStackHeight >= kMaxStackHeight) {
+    return;
+  }
+  gStackHeight++;
+
+  int count = Choose(20);
+  for (int i = 0; i < count; i++) {
+    if (!DoAction()) {
+      gFlushStack = true;
+    }
+    if (gFlushStack) {
+      gStackHeight--;
+      return;
+    }
+  }
+
+  gStackHeight--;
+}
+
+bool
+TestDemonChild::DoAction()
+{
+  switch (Choose(6)) {
+   case 0:
+    if (AllowAsync(mOutgoing[0], mIncoming[0])) {
+      DEMON_LOG("SendAsyncMessage [%d]", mOutgoing[0]);
+      return SendAsyncMessage(mOutgoing[0]++);
+    } else {
+      return true;
+    }
+
+   case 1: {
+     DEMON_LOG("Start SendHiPrioSyncMessage");
+     bool r = SendHiPrioSyncMessage();
+     DEMON_LOG("End SendHiPrioSyncMessage result=%d", r);
+     return r;
+   }
+
+   case 2: {
+     DEMON_LOG("Start SendSyncMessage [%d]", mOutgoing[0]);
+     bool r = SendSyncMessage(mOutgoing[0]++);
+     switch (GetIPCChannel()->LastSendError()) {
+       case SyncSendError::PreviousTimeout:
+       case SyncSendError::SendingCPOWWhileDispatchingSync:
+       case SyncSendError::SendingCPOWWhileDispatchingUrgent:
+       case SyncSendError::NotConnectedBeforeSend:
+       case SyncSendError::CancelledBeforeSend:
+         mOutgoing[0]--;
+         break;
+       default:
+         break;
+     }
+     DEMON_LOG("End SendSyncMessage result=%d", r);
+     return r;
+   }
+
+   case 3:
+	DEMON_LOG("SendUrgentAsyncMessage [%d]", mOutgoing[2]);
+	return SendUrgentAsyncMessage(mOutgoing[2]++);
+
+   case 4: {
+     DEMON_LOG("Start SendUrgentSyncMessage [%d]", mOutgoing[2]);
+     bool r = SendUrgentSyncMessage(mOutgoing[2]++);
+     switch (GetIPCChannel()->LastSendError()) {
+       case SyncSendError::PreviousTimeout:
+       case SyncSendError::SendingCPOWWhileDispatchingSync:
+       case SyncSendError::SendingCPOWWhileDispatchingUrgent:
+       case SyncSendError::NotConnectedBeforeSend:
+       case SyncSendError::CancelledBeforeSend:
+         mOutgoing[2]--;
+         break;
+       default:
+         break;
+     }
+     DEMON_LOG("End SendUrgentSyncMessage result=%d", r);
+     return r;
+   }
+
+   case 5:
+	DEMON_LOG("Cancel");
+	GetIPCChannel()->CancelCurrentTransaction();
+	return true;
+  }
+  MOZ_CRASH();
+  return false;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestDemon.h b/ipc/ipdl/test/cxx/TestDemon.h
new file mode 100644
index 000000000..d481039a6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestDemon.h
@@ -0,0 +1,106 @@
+#ifndef mozilla__ipdltest_TestDemon_h
+#define mozilla__ipdltest_TestDemon_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestDemonParent.h"
+#include "mozilla/_ipdltest/PTestDemonChild.h"
+
+using namespace mozilla::ipc;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestDemonParent :
+    public PTestDemonParent
+{
+public:
+    TestDemonParent();
+    virtual ~TestDemonParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+#ifdef DEBUG
+    bool ShouldContinueFromReplyTimeout() override;
+    bool ArtificialTimeout() override;
+
+    bool NeedArtificialSleep() override { return true; }
+    void ArtificialSleep() override;
+#endif
+
+    bool RecvAsyncMessage(const int& n) override;
+    bool RecvHiPrioSyncMessage() override;
+
+    bool RecvSyncMessage(const int& n) override;
+    bool RecvUrgentAsyncMessage(const int& n) override;
+    bool RecvUrgentSyncMessage(const int& n) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+	mDone = true;
+	printf("Parent ActorDestroy\n");
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    bool mDone;
+    int mIncoming[3];
+    int mOutgoing[3];
+
+    enum {
+	ASYNC_ONLY = 1,
+    };
+
+    void RunUnlimitedSequence();
+    void RunLimitedSequence(int flags = 0);
+    bool DoAction(int flags = 0);
+};
+
+
+class TestDemonChild :
+    public PTestDemonChild
+{
+public:
+    TestDemonChild();
+    virtual ~TestDemonChild();
+
+    bool RecvStart() override;
+
+#ifdef DEBUG
+    bool NeedArtificialSleep() override { return true; }
+    void ArtificialSleep() override;
+#endif
+
+    bool RecvAsyncMessage(const int& n) override;
+    bool RecvHiPrioSyncMessage() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+	_exit(0);
+    }
+
+    virtual void IntentionalCrash() override
+    {
+	_exit(0);
+    }
+
+private:
+    int mIncoming[3];
+    int mOutgoing[3];
+
+    void RunUnlimitedSequence();
+    void RunLimitedSequence();
+    bool DoAction();
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestDemon_h
diff --git a/ipc/ipdl/test/cxx/TestDesc.cpp b/ipc/ipdl/test/cxx/TestDesc.cpp
new file mode 100644
index 000000000..696e5a4c5
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestDesc.cpp
@@ -0,0 +1,105 @@
+#include "TestDesc.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+void
+TestDescParent::Main()
+{
+    PTestDescSubParent* p = CallPTestDescSubConstructor(0);
+    if (!p)
+        fail("can't allocate Sub");
+
+    PTestDescSubsubParent* pp = p->CallPTestDescSubsubConstructor();
+    if (!pp)
+        fail("can't allocate Subsub");
+
+    if (!SendTest(pp))
+        fail("can't send Subsub");
+}
+
+bool
+TestDescParent::RecvOk(PTestDescSubsubParent* a)
+{
+    if (!a)
+        fail("didn't receive Subsub");
+
+    if (!PTestDescSubsubParent::Call__delete__(a))
+        fail("deleting Subsub");
+
+    Close();
+
+    return true;
+}
+
+
+PTestDescSubParent*
+TestDescParent::AllocPTestDescSubParent(PTestDescSubsubParent* dummy) {
+    if (dummy)
+        fail("actor supposed to be null");
+    return new TestDescSubParent();
+}
+bool
+TestDescParent::DeallocPTestDescSubParent(PTestDescSubParent* actor)
+{
+    delete actor;
+    return true;
+}
+
+PTestDescSubsubParent*
+TestDescSubParent::AllocPTestDescSubsubParent()
+{
+    return new TestDescSubsubParent();
+}
+bool
+TestDescSubParent::DeallocPTestDescSubsubParent(PTestDescSubsubParent* actor)
+{
+    delete actor;
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+bool
+TestDescChild::RecvTest(PTestDescSubsubChild* a)
+{
+    if (!a)
+        fail("didn't receive Subsub");
+    if (!SendOk(a))
+        fail("couldn't send Ok()");
+    return true;
+}
+
+PTestDescSubChild*
+TestDescChild::AllocPTestDescSubChild(PTestDescSubsubChild* dummy) {
+    if (dummy)
+        fail("actor supposed to be null");
+    return new TestDescSubChild();
+}
+bool
+TestDescChild::DeallocPTestDescSubChild(PTestDescSubChild* actor)
+{
+    delete actor;
+    return true;
+}
+
+PTestDescSubsubChild*
+TestDescSubChild::AllocPTestDescSubsubChild()
+{
+    return new TestDescSubsubChild();
+}
+bool
+TestDescSubChild::DeallocPTestDescSubsubChild(PTestDescSubsubChild* actor)
+{
+    delete actor;
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestDesc.h b/ipc/ipdl/test/cxx/TestDesc.h
new file mode 100644
index 000000000..876de7201
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestDesc.h
@@ -0,0 +1,128 @@
+#ifndef mozilla_ipdltest_TestDesc_h
+#define mozilla_ipdltest_TestDesc_h
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestDescParent.h"
+#include "mozilla/_ipdltest/PTestDescChild.h"
+
+#include "mozilla/_ipdltest/PTestDescSubParent.h"
+#include "mozilla/_ipdltest/PTestDescSubChild.h"
+
+#include "mozilla/_ipdltest/PTestDescSubsubParent.h"
+#include "mozilla/_ipdltest/PTestDescSubsubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Top-level
+//
+class TestDescParent :
+    public PTestDescParent
+{
+public:
+    TestDescParent() { }
+    virtual ~TestDescParent() { }
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+    virtual bool RecvOk(PTestDescSubsubParent* a) override;
+
+protected:
+    virtual PTestDescSubParent* AllocPTestDescSubParent(PTestDescSubsubParent*) override;
+    virtual bool DeallocPTestDescSubParent(PTestDescSubParent* actor) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestDescChild :
+    public PTestDescChild
+{
+public:
+    TestDescChild() { }
+    virtual ~TestDescChild() { }
+
+protected:
+    virtual PTestDescSubChild* AllocPTestDescSubChild(PTestDescSubsubChild*) override;
+
+    virtual bool DeallocPTestDescSubChild(PTestDescSubChild* actor) override;
+
+    virtual bool RecvTest(PTestDescSubsubChild* a) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+// First descendent
+//
+class TestDescSubParent :
+    public PTestDescSubParent
+{
+public:
+    TestDescSubParent() { }
+    virtual ~TestDescSubParent() { }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+    virtual PTestDescSubsubParent* AllocPTestDescSubsubParent() override;
+    virtual bool DeallocPTestDescSubsubParent(PTestDescSubsubParent* actor) override;
+};
+
+
+class TestDescSubChild :
+    public PTestDescSubChild
+{
+public:
+    TestDescSubChild() { }
+    virtual ~TestDescSubChild() { }
+
+protected:
+    virtual PTestDescSubsubChild* AllocPTestDescSubsubChild() override;
+    virtual bool DeallocPTestDescSubsubChild(PTestDescSubsubChild* actor) override;
+};
+
+
+//-----------------------------------------------------------------------------
+// Grand-descendent
+//
+class TestDescSubsubParent :
+    public PTestDescSubsubParent
+{
+public:
+    TestDescSubsubParent() { }
+    virtual ~TestDescSubsubParent() { }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+};
+
+class TestDescSubsubChild :
+    public PTestDescSubsubChild
+{
+public:
+    TestDescSubsubChild() { }
+    virtual ~TestDescSubsubChild() { }
+};
+
+
+}
+}
+
+#endif // ifndef mozilla_ipdltest_TestDesc_h
diff --git a/ipc/ipdl/test/cxx/TestEndpointBridgeMain.cpp b/ipc/ipdl/test/cxx/TestEndpointBridgeMain.cpp
new file mode 100644
index 000000000..1b646f425
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestEndpointBridgeMain.cpp
@@ -0,0 +1,257 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+#include "TestEndpointBridgeMain.h"
+
+#include "base/task.h"
+#include "IPDLUnitTests.h"      // fail etc.
+#include "IPDLUnitTestSubprocess.h"
+
+using namespace std;
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+//-----------------------------------------------------------------------------
+// main process
+void
+TestEndpointBridgeMainParent::Main()
+{
+  if (!SendStart()) {
+    fail("sending Start");
+  }
+}
+
+bool
+TestEndpointBridgeMainParent::RecvBridged(Endpoint<PTestEndpointBridgeMainSubParent>&& endpoint)
+{
+  TestEndpointBridgeMainSubParent* a = new TestEndpointBridgeMainSubParent();
+  if (!endpoint.Bind(a)) {
+    fail("Bind failed");
+  }
+  return true;
+}
+
+void
+TestEndpointBridgeMainParent::ActorDestroy(ActorDestroyReason why)
+{
+  if (NormalShutdown != why) {
+    fail("unexpected destruction!");
+  }
+  passed("ok");
+  QuitParent();
+}
+
+bool
+TestEndpointBridgeMainSubParent::RecvHello()
+{
+  return SendHi();
+}
+
+bool
+TestEndpointBridgeMainSubParent::RecvHelloSync()
+{
+  return true;
+}
+
+bool
+TestEndpointBridgeMainSubParent::AnswerHelloRpc()
+{
+  return CallHiRpc();
+}
+
+void
+TestEndpointBridgeMainSubParent::ActorDestroy(ActorDestroyReason why)
+{
+  if (NormalShutdown != why) {
+    fail("unexpected destruction!");
+  }
+
+  // ActorDestroy() is just a callback from IPDL-generated code,
+  // which needs the top-level actor (this) to stay alive a little
+  // longer so other things can be cleaned up.
+  MessageLoop::current()->PostTask(
+    do_AddRef(new DeleteTask<TestEndpointBridgeMainSubParent>(this)));
+}
+
+//-----------------------------------------------------------------------------
+// sub process --- child of main
+TestEndpointBridgeMainChild* gEndpointBridgeMainChild;
+
+TestEndpointBridgeMainChild::TestEndpointBridgeMainChild()
+ : mSubprocess(nullptr)
+{
+  gEndpointBridgeMainChild = this;
+}
+
+bool
+TestEndpointBridgeMainChild::RecvStart()
+{
+  vector<string> subsubArgs;
+  subsubArgs.push_back("TestEndpointBridgeSub");
+
+  mSubprocess = new IPDLUnitTestSubprocess();
+  if (!mSubprocess->SyncLaunch(subsubArgs)) {
+    fail("problem launching subprocess");
+  }
+
+  IPC::Channel* transport = mSubprocess->GetChannel();
+  if (!transport) {
+    fail("no transport");
+  }
+
+  TestEndpointBridgeSubParent* bsp = new TestEndpointBridgeSubParent();
+  bsp->Open(transport, base::GetProcId(mSubprocess->GetChildProcessHandle()));
+
+  bsp->Main();
+  return true;
+}
+
+void
+TestEndpointBridgeMainChild::ActorDestroy(ActorDestroyReason why)
+{
+  if (NormalShutdown != why) {
+    fail("unexpected destruction!");
+  }
+  // NB: this is kosher because QuitChild() joins with the IO thread
+  XRE_GetIOMessageLoop()->PostTask(
+    do_AddRef(new DeleteTask<IPDLUnitTestSubprocess>(mSubprocess)));
+  QuitChild();
+}
+
+void
+TestEndpointBridgeSubParent::Main()
+{
+  if (!SendPing()) {
+    fail("sending Ping");
+  }
+}
+
+bool
+TestEndpointBridgeSubParent::RecvBridgeEm()
+{
+  Endpoint<PTestEndpointBridgeMainSubParent> parent;
+  Endpoint<PTestEndpointBridgeMainSubChild> child;
+  nsresult rv;
+  rv = PTestEndpointBridgeMainSub::CreateEndpoints(
+    gEndpointBridgeMainChild->OtherPid(), OtherPid(),
+    &parent, &child);
+  if (NS_FAILED(rv)) {
+    fail("opening PTestEndpointOpensOpened");
+  }
+
+  if (!gEndpointBridgeMainChild->SendBridged(mozilla::Move(parent))) {
+    fail("SendBridge failed for parent");
+  }
+  if (!SendBridged(mozilla::Move(child))) {
+    fail("SendBridge failed for child");
+  }
+
+  return true;
+}
+
+void
+TestEndpointBridgeSubParent::ActorDestroy(ActorDestroyReason why)
+{
+  if (NormalShutdown != why) {
+    fail("unexpected destruction!");
+  }
+  gEndpointBridgeMainChild->Close();
+
+  // ActorDestroy() is just a callback from IPDL-generated code,
+  // which needs the top-level actor (this) to stay alive a little
+  // longer so other things can be cleaned up.
+  MessageLoop::current()->PostTask(
+    do_AddRef(new DeleteTask<TestEndpointBridgeSubParent>(this)));
+}
+
+//-----------------------------------------------------------------------------
+// subsub process --- child of sub
+
+static TestEndpointBridgeSubChild* gBridgeSubChild;
+
+TestEndpointBridgeSubChild::TestEndpointBridgeSubChild()
+{
+    gBridgeSubChild = this;
+}
+
+bool
+TestEndpointBridgeSubChild::RecvPing()
+{
+  if (!SendBridgeEm()) {
+    fail("sending BridgeEm");
+  }
+  return true;
+}
+
+bool
+TestEndpointBridgeSubChild::RecvBridged(Endpoint<PTestEndpointBridgeMainSubChild>&& endpoint)
+{
+  TestEndpointBridgeMainSubChild* a = new TestEndpointBridgeMainSubChild();
+
+  if (!endpoint.Bind(a)) {
+    fail("failed to Bind");
+  }
+
+  if (!a->SendHello()) {
+    fail("sending Hello");
+  }
+
+  return true;
+}
+
+void
+TestEndpointBridgeSubChild::ActorDestroy(ActorDestroyReason why)
+{
+  if (NormalShutdown != why) {
+    fail("unexpected destruction!");
+  }
+  QuitChild();
+}
+
+bool
+TestEndpointBridgeMainSubChild::RecvHi()
+{
+  if (!SendHelloSync()) {
+    fail("sending HelloSync");
+  }
+  if (!CallHelloRpc()) {
+    fail("calling HelloRpc");
+  }
+  if (!mGotHi) {
+    fail("didn't answer HiRpc");
+  }
+
+  // Need to close the channel without message-processing frames on
+  // the C++ stack
+  MessageLoop::current()->PostTask(
+    NewNonOwningRunnableMethod(this, &TestEndpointBridgeMainSubChild::Close));
+  return true;
+}
+
+bool
+TestEndpointBridgeMainSubChild::AnswerHiRpc()
+{
+  mGotHi = true;              // d00d
+  return true;
+}
+
+void
+TestEndpointBridgeMainSubChild::ActorDestroy(ActorDestroyReason why)
+{
+  if (NormalShutdown != why) {
+    fail("unexpected destruction!");
+  }
+
+  gBridgeSubChild->Close();
+
+  // ActorDestroy() is just a callback from IPDL-generated code,
+  // which needs the top-level actor (this) to stay alive a little
+  // longer so other things can be cleaned up.
+  MessageLoop::current()->PostTask(
+    do_AddRef(new DeleteTask<TestEndpointBridgeMainSubChild>(this)));
+}
+
+} // namespace mozilla
+} // namespace _ipdltest
diff --git a/ipc/ipdl/test/cxx/TestEndpointBridgeMain.h b/ipc/ipdl/test/cxx/TestEndpointBridgeMain.h
new file mode 100644
index 000000000..a180ba8eb
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestEndpointBridgeMain.h
@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+#ifndef mozilla__ipdltest_TestEndpointBridgeMain_h
+#define mozilla__ipdltest_TestEndpointBridgeMain_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestEndpointBridgeMainParent.h"
+#include "mozilla/_ipdltest/PTestEndpointBridgeMainChild.h"
+
+#include "mozilla/_ipdltest/PTestEndpointBridgeSubParent.h"
+#include "mozilla/_ipdltest/PTestEndpointBridgeSubChild.h"
+
+#include "mozilla/_ipdltest/PTestEndpointBridgeMainSubParent.h"
+#include "mozilla/_ipdltest/PTestEndpointBridgeMainSubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// "Main" process
+//
+class TestEndpointBridgeMainParent :
+    public PTestEndpointBridgeMainParent
+{
+public:
+  TestEndpointBridgeMainParent() {}
+  virtual ~TestEndpointBridgeMainParent() {}
+
+  static bool RunTestInProcesses() { return true; }
+  static bool RunTestInThreads() { return false; }
+
+  void Main();
+
+protected:
+  bool RecvBridged(mozilla::ipc::Endpoint<PTestEndpointBridgeMainSubParent>&& endpoint) override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+class TestEndpointBridgeMainSubParent :
+    public PTestEndpointBridgeMainSubParent
+{
+public:
+  explicit TestEndpointBridgeMainSubParent()
+  {}
+  virtual ~TestEndpointBridgeMainSubParent() {}
+
+protected:
+  virtual bool RecvHello() override;
+  virtual bool RecvHelloSync() override;
+  virtual bool AnswerHelloRpc() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+//-----------------------------------------------------------------------------
+// "Sub" process --- child of "main"
+//
+class TestEndpointBridgeSubParent;
+
+class TestEndpointBridgeMainChild :
+    public PTestEndpointBridgeMainChild
+{
+public:
+  TestEndpointBridgeMainChild();
+  virtual ~TestEndpointBridgeMainChild() {}
+
+protected:
+  virtual bool RecvStart() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+
+  IPDLUnitTestSubprocess* mSubprocess;
+};
+
+class TestEndpointBridgeSubParent :
+    public PTestEndpointBridgeSubParent
+{
+public:
+  TestEndpointBridgeSubParent() {}
+  virtual ~TestEndpointBridgeSubParent() {}
+
+  void Main();
+
+protected:
+  virtual bool RecvBridgeEm() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+//-----------------------------------------------------------------------------
+// "Subsub" process --- child of "sub"
+//
+class TestEndpointBridgeSubChild :
+    public PTestEndpointBridgeSubChild
+{
+public:
+  TestEndpointBridgeSubChild();
+  virtual ~TestEndpointBridgeSubChild() {}
+
+protected:
+  virtual bool RecvPing() override;
+
+  bool RecvBridged(Endpoint<PTestEndpointBridgeMainSubChild>&& endpoint) override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+class TestEndpointBridgeMainSubChild :
+    public PTestEndpointBridgeMainSubChild
+{
+public:
+  explicit TestEndpointBridgeMainSubChild()
+   : mGotHi(false)
+  {}
+  virtual ~TestEndpointBridgeMainSubChild() {}
+
+protected:
+  virtual bool RecvHi() override;
+  virtual bool AnswerHiRpc() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+
+  bool mGotHi;
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestEndpointBridgeMain_h
diff --git a/ipc/ipdl/test/cxx/TestEndpointOpens.cpp b/ipc/ipdl/test/cxx/TestEndpointOpens.cpp
new file mode 100644
index 000000000..820273ad7
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestEndpointOpens.cpp
@@ -0,0 +1,271 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+#include "base/task.h"
+#include "base/thread.h"
+
+#include "TestEndpointOpens.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+using namespace mozilla::ipc;
+
+using base::ProcessHandle;
+using base::Thread;
+
+namespace mozilla {
+// NB: this is generally bad style, but I am lazy.
+using namespace _ipdltest;
+using namespace _ipdltest2;
+
+static MessageLoop* gMainThread;
+
+static void
+AssertNotMainThread()
+{
+  if (!gMainThread) {
+    fail("gMainThread is not initialized");
+  }
+  if (MessageLoop::current() == gMainThread) {
+    fail("unexpectedly called on the main thread");
+  }
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+// Thread on which TestEndpointOpensOpenedParent runs
+static Thread* gParentThread;
+
+void
+TestEndpointOpensParent::Main()
+{
+  if (!SendStart()) {
+    fail("sending Start");
+  }
+}
+
+static void
+OpenParent(TestEndpointOpensOpenedParent* aParent,
+           Endpoint<PTestEndpointOpensOpenedParent>&& aEndpoint)
+{
+  AssertNotMainThread();
+
+  // Open the actor on the off-main thread to park it there.
+  // Messages will be delivered to this thread's message loop
+  // instead of the main thread's.
+  if (!aEndpoint.Bind(aParent)) {
+    fail("binding Parent");
+  }
+}
+
+bool
+TestEndpointOpensParent::RecvStartSubprotocol(
+  mozilla::ipc::Endpoint<PTestEndpointOpensOpenedParent>&& endpoint)
+{
+  gMainThread = MessageLoop::current();
+
+  gParentThread = new Thread("ParentThread");
+  if (!gParentThread->Start()) {
+    fail("starting parent thread");
+  }
+
+  TestEndpointOpensOpenedParent* a = new TestEndpointOpensOpenedParent();
+  gParentThread->message_loop()->PostTask(
+    NewRunnableFunction(OpenParent, a, mozilla::Move(endpoint)));
+
+  return true;
+}
+
+void
+TestEndpointOpensParent::ActorDestroy(ActorDestroyReason why)
+{
+  // Stops the thread and joins it
+  delete gParentThread;
+
+  if (NormalShutdown != why) {
+    fail("unexpected destruction A!");
+  }
+  passed("ok");
+  QuitParent();
+}
+
+bool
+TestEndpointOpensOpenedParent::RecvHello()
+{
+  AssertNotMainThread();
+  return SendHi();
+}
+
+bool
+TestEndpointOpensOpenedParent::RecvHelloSync()
+{
+  AssertNotMainThread();
+  return true;
+}
+
+bool
+TestEndpointOpensOpenedParent::AnswerHelloRpc()
+{
+  AssertNotMainThread();
+  return CallHiRpc();
+}
+
+static void
+ShutdownTestEndpointOpensOpenedParent(TestEndpointOpensOpenedParent* parent,
+                                      Transport* transport)
+{
+  delete parent;
+}
+
+void
+TestEndpointOpensOpenedParent::ActorDestroy(ActorDestroyReason why)
+{
+  AssertNotMainThread();
+
+  if (NormalShutdown != why) {
+    fail("unexpected destruction B!");
+  }
+
+  // ActorDestroy() is just a callback from IPDL-generated code,
+  // which needs the top-level actor (this) to stay alive a little
+  // longer so other things can be cleaned up.
+  gParentThread->message_loop()->PostTask(
+    NewRunnableFunction(ShutdownTestEndpointOpensOpenedParent,
+                        this, GetTransport()));
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+static TestEndpointOpensChild* gOpensChild;
+// Thread on which TestEndpointOpensOpenedChild runs
+static Thread* gChildThread;
+
+TestEndpointOpensChild::TestEndpointOpensChild()
+{
+  gOpensChild = this;
+}
+
+static void
+OpenChild(TestEndpointOpensOpenedChild* aChild,
+          Endpoint<PTestEndpointOpensOpenedChild>&& endpoint)
+{
+  AssertNotMainThread();
+
+  // Open the actor on the off-main thread to park it there.
+  // Messages will be delivered to this thread's message loop
+  // instead of the main thread's.
+  if (!endpoint.Bind(aChild)) {
+    fail("binding child endpoint");
+  }
+
+  // Kick off the unit tests
+  if (!aChild->SendHello()) {
+    fail("sending Hello");
+  }
+}
+
+bool
+TestEndpointOpensChild::RecvStart()
+{
+  Endpoint<PTestEndpointOpensOpenedParent> parent;
+  Endpoint<PTestEndpointOpensOpenedChild> child;
+  nsresult rv;
+  rv = PTestEndpointOpensOpened::CreateEndpoints(OtherPid(), base::GetCurrentProcId(),
+                                                 &parent, &child);
+  if (NS_FAILED(rv)) {
+    fail("opening PTestEndpointOpensOpened");
+  }
+
+  gMainThread = MessageLoop::current();
+
+  gChildThread = new Thread("ChildThread");
+  if (!gChildThread->Start()) {
+    fail("starting child thread");
+  }
+
+  TestEndpointOpensOpenedChild* a = new TestEndpointOpensOpenedChild();
+  gChildThread->message_loop()->PostTask(
+    NewRunnableFunction(OpenChild, a, mozilla::Move(child)));
+
+  if (!SendStartSubprotocol(parent)) {
+    fail("send StartSubprotocol");
+  }
+
+  return true;
+}
+
+void
+TestEndpointOpensChild::ActorDestroy(ActorDestroyReason why)
+{
+  // Stops the thread and joins it
+  delete gChildThread;
+
+  if (NormalShutdown != why) {
+    fail("unexpected destruction C!");
+  }
+  QuitChild();
+}
+
+bool
+TestEndpointOpensOpenedChild::RecvHi()
+{
+  AssertNotMainThread();
+
+  if (!SendHelloSync()) {
+    fail("sending HelloSync");
+  }
+  if (!CallHelloRpc()) {
+    fail("calling HelloRpc");
+  }
+  if (!mGotHi) {
+    fail("didn't answer HiRpc");
+  }
+
+  // Need to close the channel without message-processing frames on
+  // the C++ stack
+  MessageLoop::current()->PostTask(
+    NewNonOwningRunnableMethod(this, &TestEndpointOpensOpenedChild::Close));
+  return true;
+}
+
+bool
+TestEndpointOpensOpenedChild::AnswerHiRpc()
+{
+  AssertNotMainThread();
+
+  mGotHi = true;              // d00d
+  return true;
+}
+
+static void
+ShutdownTestEndpointOpensOpenedChild(TestEndpointOpensOpenedChild* child,
+                                     Transport* transport)
+{
+  delete child;
+
+  // Kick off main-thread shutdown.
+  gMainThread->PostTask(
+    NewNonOwningRunnableMethod(gOpensChild, &TestEndpointOpensChild::Close));
+}
+
+void
+TestEndpointOpensOpenedChild::ActorDestroy(ActorDestroyReason why)
+{
+  AssertNotMainThread();
+
+  if (NormalShutdown != why) {
+    fail("unexpected destruction D!");
+  }
+
+  // ActorDestroy() is just a callback from IPDL-generated code,
+  // which needs the top-level actor (this) to stay alive a little
+  // longer so other things can be cleaned up.  Defer shutdown to
+  // let cleanup finish.
+  gChildThread->message_loop()->PostTask(
+    NewRunnableFunction(ShutdownTestEndpointOpensOpenedChild,
+                        this, GetTransport()));
+}
+
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestEndpointOpens.h b/ipc/ipdl/test/cxx/TestEndpointOpens.h
new file mode 100644
index 000000000..6bfaace2a
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestEndpointOpens.h
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+
+#ifndef mozilla__ipdltest_TestEndpointOpens_h
+#define mozilla__ipdltest_TestEndpointOpens_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestEndpointOpensParent.h"
+#include "mozilla/_ipdltest/PTestEndpointOpensChild.h"
+
+#include "mozilla/_ipdltest2/PTestEndpointOpensOpenedParent.h"
+#include "mozilla/_ipdltest2/PTestEndpointOpensOpenedChild.h"
+
+namespace mozilla {
+
+// parent process
+
+namespace _ipdltest {
+
+class TestEndpointOpensParent : public PTestEndpointOpensParent
+{
+public:
+  TestEndpointOpensParent() {}
+  virtual ~TestEndpointOpensParent() {}
+
+  static bool RunTestInProcesses() { return true; }
+  static bool RunTestInThreads() { return false; }
+
+  void Main();
+
+protected:
+  virtual bool RecvStartSubprotocol(mozilla::ipc::Endpoint<PTestEndpointOpensOpenedParent>&& endpoint);
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+} // namespace _ipdltest
+
+namespace _ipdltest2 {
+
+class TestEndpointOpensOpenedParent : public PTestEndpointOpensOpenedParent
+{
+public:
+  explicit TestEndpointOpensOpenedParent()
+  {}
+  virtual ~TestEndpointOpensOpenedParent() {}
+
+protected:
+  virtual bool RecvHello() override;
+  virtual bool RecvHelloSync() override;
+  virtual bool AnswerHelloRpc() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+} // namespace _ipdltest2
+
+// child process
+
+namespace _ipdltest {
+
+class TestEndpointOpensChild : public PTestEndpointOpensChild
+{
+public:
+  TestEndpointOpensChild();
+  virtual ~TestEndpointOpensChild() {}
+
+protected:
+  virtual bool RecvStart() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+} // namespace _ipdltest
+
+namespace _ipdltest2 {
+
+class TestEndpointOpensOpenedChild : public PTestEndpointOpensOpenedChild
+{
+public:
+  explicit TestEndpointOpensOpenedChild()
+   : mGotHi(false)
+  {}
+  virtual ~TestEndpointOpensOpenedChild() {}
+
+protected:
+  virtual bool RecvHi() override;
+  virtual bool AnswerHiRpc() override;
+
+  virtual void ActorDestroy(ActorDestroyReason why) override;
+
+  bool mGotHi;
+};
+
+} // namespace _ipdltest2
+
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestEndpointOpens_h
diff --git a/ipc/ipdl/test/cxx/TestFailedCtor.cpp b/ipc/ipdl/test/cxx/TestFailedCtor.cpp
new file mode 100644
index 000000000..12ea8fdc1
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestFailedCtor.cpp
@@ -0,0 +1,137 @@
+#include "TestFailedCtor.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+void
+TestFailedCtorParent::Main()
+{
+    PTestFailedCtorSubParent* p = CallPTestFailedCtorSubConstructor();
+    if (p)
+        fail("expected ctor to fail");
+
+    Close();
+}
+
+PTestFailedCtorSubParent*
+TestFailedCtorParent::AllocPTestFailedCtorSubParent()
+{
+    return new TestFailedCtorSubParent();
+}
+bool
+TestFailedCtorParent::DeallocPTestFailedCtorSubParent(PTestFailedCtorSubParent* actor)
+{
+    delete actor;
+    return true;
+}
+
+PTestFailedCtorSubsubParent*
+TestFailedCtorSubParent::AllocPTestFailedCtorSubsubParent()
+{
+    TestFailedCtorSubsub* a = new TestFailedCtorSubsub();
+    if (!mOne) {
+        return mOne = a;
+    } else if (!mTwo) {
+        return mTwo = a;
+    } else if (!mThree) {
+        return mThree = a;
+    } else {
+        fail("unexpected Alloc()");
+        return nullptr;
+    }
+}
+bool
+TestFailedCtorSubParent::DeallocPTestFailedCtorSubsubParent(PTestFailedCtorSubsubParent* actor)
+{
+    static_cast<TestFailedCtorSubsub*>(actor)->mDealloced = true;
+    return true;
+}
+
+void
+TestFailedCtorSubParent::ActorDestroy(ActorDestroyReason why)
+{
+
+    if (mOne->mWhy != Deletion)
+        fail("Subsub one got wrong ActorDestroyReason");
+    if (mTwo->mWhy != AncestorDeletion)
+        fail("Subsub two got wrong ActorDestroyReason");
+    if (mThree->mWhy != AncestorDeletion)
+        fail("Subsub three got wrong ActorDestroyReason");
+
+    if (FailedConstructor != why)
+        fail("unexpected destruction!");
+}
+
+TestFailedCtorSubParent::~TestFailedCtorSubParent()
+{
+    if (!(mOne->mDealloced && mTwo->mDealloced && mThree->mDealloced))
+        fail("Not all subsubs were Dealloc'd");
+    delete mOne;
+    delete mTwo;
+    delete mThree;
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+PTestFailedCtorSubChild*
+TestFailedCtorChild::AllocPTestFailedCtorSubChild()
+{
+    return new TestFailedCtorSubChild();
+}
+
+bool
+TestFailedCtorChild::AnswerPTestFailedCtorSubConstructor(PTestFailedCtorSubChild* actor)
+{
+    PTestFailedCtorSubsubChild* c1 = actor->SendPTestFailedCtorSubsubConstructor();
+    PTestFailedCtorSubsubChild::Send__delete__(c1);
+
+    if (!actor->SendPTestFailedCtorSubsubConstructor() ||
+        !actor->SendPTestFailedCtorSubsubConstructor() ||
+        !actor->SendSync())
+        fail("setting up test");
+
+    // This causes our process to die
+    return false;
+}
+
+bool
+TestFailedCtorChild::DeallocPTestFailedCtorSubChild(PTestFailedCtorSubChild* actor)
+{
+    delete actor;
+    return true;
+}
+
+void
+TestFailedCtorChild::ProcessingError(Result aCode, const char* aReason)
+{
+    if (OtherPid() != base::GetCurrentProcId()) // thread-mode
+        _exit(0);
+}
+
+PTestFailedCtorSubsubChild*
+TestFailedCtorSubChild::AllocPTestFailedCtorSubsubChild()
+{
+    return new TestFailedCtorSubsub();
+}
+
+bool
+TestFailedCtorSubChild::DeallocPTestFailedCtorSubsubChild(PTestFailedCtorSubsubChild* actor)
+{
+    delete actor;
+    return true;
+}
+
+void
+TestFailedCtorSubChild::ActorDestroy(ActorDestroyReason why)
+{
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestFailedCtor.h b/ipc/ipdl/test/cxx/TestFailedCtor.h
new file mode 100644
index 000000000..97f9013cc
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestFailedCtor.h
@@ -0,0 +1,136 @@
+#ifndef mozilla_ipdltest_TestFailedCtor_h
+#define mozilla_ipdltest_TestFailedCtor_h
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestFailedCtorParent.h"
+#include "mozilla/_ipdltest/PTestFailedCtorChild.h"
+
+#include "mozilla/_ipdltest/PTestFailedCtorSubParent.h"
+#include "mozilla/_ipdltest/PTestFailedCtorSubChild.h"
+
+#include "mozilla/_ipdltest/PTestFailedCtorSubsubParent.h"
+#include "mozilla/_ipdltest/PTestFailedCtorSubsubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Top-level
+//
+class TestFailedCtorParent :
+    public PTestFailedCtorParent
+{
+public:
+    TestFailedCtorParent() { }
+    virtual ~TestFailedCtorParent() { }
+
+    static bool RunTestInProcesses() { return true; }
+
+    // FIXME/bug 703322 Disabled because child calls exit() to end
+    //                  test, not clear how to handle failed ctor in
+    //                  threaded mode.
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:
+    virtual PTestFailedCtorSubParent* AllocPTestFailedCtorSubParent() override;
+    virtual bool DeallocPTestFailedCtorSubParent(PTestFailedCtorSubParent* actor) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (AbnormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestFailedCtorChild :
+    public PTestFailedCtorChild
+{
+public:
+    TestFailedCtorChild() { }
+    virtual ~TestFailedCtorChild() { }
+
+protected:
+    virtual PTestFailedCtorSubChild* AllocPTestFailedCtorSubChild() override;
+
+    virtual bool AnswerPTestFailedCtorSubConstructor(PTestFailedCtorSubChild* actor) override;
+
+    virtual bool DeallocPTestFailedCtorSubChild(PTestFailedCtorSubChild* actor) override;
+
+    virtual void ProcessingError(Result aCode, const char* aReason) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        fail("should have _exit()ed");
+    }
+};
+
+
+//-----------------------------------------------------------------------------
+// First descendent
+//
+class TestFailedCtorSubsub;
+
+class TestFailedCtorSubParent :
+    public PTestFailedCtorSubParent
+{
+public:
+    TestFailedCtorSubParent() : mOne(nullptr), mTwo(nullptr), mThree(nullptr) { }
+    virtual ~TestFailedCtorSubParent();
+
+protected:
+    virtual PTestFailedCtorSubsubParent* AllocPTestFailedCtorSubsubParent() override;
+
+    virtual bool DeallocPTestFailedCtorSubsubParent(PTestFailedCtorSubsubParent* actor) override;
+    virtual bool RecvSync() override { return true; }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+
+    TestFailedCtorSubsub* mOne;
+    TestFailedCtorSubsub* mTwo;
+    TestFailedCtorSubsub* mThree;
+};
+
+
+class TestFailedCtorSubChild :
+    public PTestFailedCtorSubChild
+{
+public:
+    TestFailedCtorSubChild() { }
+    virtual ~TestFailedCtorSubChild() { }
+
+protected:
+    virtual PTestFailedCtorSubsubChild* AllocPTestFailedCtorSubsubChild() override;
+    virtual bool DeallocPTestFailedCtorSubsubChild(PTestFailedCtorSubsubChild* actor) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+
+//-----------------------------------------------------------------------------
+// Grand-descendent
+//
+class TestFailedCtorSubsub :
+        public PTestFailedCtorSubsubParent,
+        public PTestFailedCtorSubsubChild
+{
+public:
+    TestFailedCtorSubsub() : mWhy(ActorDestroyReason(-1)), mDealloced(false) {}
+    virtual ~TestFailedCtorSubsub() {}
+
+    virtual void ActorDestroy(ActorDestroyReason why) override { mWhy = why; }
+
+    ActorDestroyReason mWhy;
+    bool mDealloced;
+};
+
+
+}
+}
+
+#endif // ifndef mozilla_ipdltest_TestFailedCtor_h
diff --git a/ipc/ipdl/test/cxx/TestHangs.cpp b/ipc/ipdl/test/cxx/TestHangs.cpp
new file mode 100644
index 000000000..b96823aee
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestHangs.cpp
@@ -0,0 +1,146 @@
+#include "base/process_util.h"
+
+#include "TestHangs.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+using base::KillProcess;
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestHangsParent::TestHangsParent() : mDetectedHang(false)
+{
+    MOZ_COUNT_CTOR(TestHangsParent);
+}
+
+TestHangsParent::~TestHangsParent()
+{
+    MOZ_COUNT_DTOR(TestHangsParent);
+}
+
+void
+TestHangsParent::Main()
+{
+    // Here we try to set things up to test the following sequence of events:
+    //
+    // - subprocess causes an OnMaybeDequeueOne() task to be posted to
+    //   this thread
+    //
+    // - subprocess hangs just long enough for the hang timer to expire
+    //
+    // - hang-kill code in the parent starts running
+    //
+    // - subprocess replies to message while hang code runs
+    //
+    // - reply is processed in OnMaybeDequeueOne() before Close() has
+    //   been called or the channel error notification has been posted
+
+    // this tells the subprocess to send us Nonce()
+    if (!SendStart())
+        fail("sending Start");
+
+    // now we sleep here for a while awaiting the Nonce() message from
+    // the child.  since we're not blocked on anything, the IO thread
+    // will enqueue an OnMaybeDequeueOne() task to process that
+    // message
+    // 
+    // NB: PR_Sleep is exactly what we want, only the current thread
+    // sleeping
+    PR_Sleep(5000);
+
+    // when we call into this, we'll pull the Nonce() message out of
+    // the mPending queue, but that doesn't matter ... the
+    // OnMaybeDequeueOne() event will remain
+    if (CallStackFrame() && mDetectedHang)
+        fail("should have timed out!");
+
+    // the Close() task in the queue will shut us down
+}
+
+bool
+TestHangsParent::ShouldContinueFromReplyTimeout()
+{
+    mDetectedHang = true;
+
+    // so we've detected a timeout after 2 ms ... now we cheat and
+    // sleep for a long time, to allow the subprocess's reply to come
+    // in
+
+    PR_Sleep(5000);
+
+    // reply should be here; we'll post a task to shut things down.
+    // This must be after OnMaybeDequeueOne() in the event queue.
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestHangsParent::CleanUp));
+
+    GetIPCChannel()->CloseWithTimeout();
+
+    return false;
+}
+
+bool
+TestHangsParent::AnswerStackFrame()
+{
+    if (PTestHangs::HANG != state()) {
+        if (CallStackFrame())
+            fail("should have timed out!");
+    }
+    else {
+        // minimum possible, 2 ms.  We want to detecting a hang to race
+        // with the reply coming in, as reliably as possible
+        SetReplyTimeoutMs(2);
+
+        if (CallHang())
+            fail("should have timed out!");
+    }
+
+    return true;
+}
+
+void
+TestHangsParent::CleanUp()
+{
+    ipc::ScopedProcessHandle otherProcessHandle;
+    if (!base::OpenProcessHandle(OtherPid(), &otherProcessHandle.rwget())) {
+        fail("couldn't open child process");
+    } else {
+        if (!KillProcess(otherProcessHandle, 0, false)) {
+            fail("terminating child process");
+        }
+    }
+    Close();
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+TestHangsChild::TestHangsChild()
+{
+    MOZ_COUNT_CTOR(TestHangsChild);
+}
+
+TestHangsChild::~TestHangsChild()
+{
+    MOZ_COUNT_DTOR(TestHangsChild);
+}
+
+bool
+TestHangsChild::AnswerHang()
+{
+    puts(" (child process is 'hanging' now)");
+
+    // just sleep until we're reasonably confident the 1ms hang
+    // detector fired in the parent process and it's sleeping in
+    // ShouldContinueFromReplyTimeout()
+    PR_Sleep(1000);
+
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestHangs.h b/ipc/ipdl/test/cxx/TestHangs.h
new file mode 100644
index 000000000..676215172
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestHangs.h
@@ -0,0 +1,87 @@
+#ifndef mozilla__ipdltest_TestHangs_h
+#define mozilla__ipdltest_TestHangs_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestHangsParent.h"
+#include "mozilla/_ipdltest/PTestHangsChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestHangsParent :
+    public PTestHangsParent
+{
+public:
+    TestHangsParent();
+    virtual ~TestHangsParent();
+
+    static bool RunTestInProcesses() { return true; }
+
+    // FIXME/bug 703320 Disabled because parent kills child proc, not
+    //                  clear how that should work in threads.
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:
+    virtual bool ShouldContinueFromReplyTimeout() override;
+
+    virtual bool RecvNonce() {
+        return true;
+    }
+
+    virtual bool AnswerStackFrame() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (AbnormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+    void CleanUp();
+
+    bool mDetectedHang;
+};
+
+
+class TestHangsChild :
+    public PTestHangsChild
+{
+public:
+    TestHangsChild();
+    virtual ~TestHangsChild();
+
+protected:
+    virtual bool RecvStart() override {
+        if (!SendNonce())
+            fail("sending Nonce");
+        return true;
+    }
+
+    virtual bool AnswerStackFrame() override
+    {
+        if (CallStackFrame())
+            fail("should have failed");
+        return true;
+    }
+
+    virtual bool AnswerHang() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (AbnormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestHangs_h
diff --git a/ipc/ipdl/test/cxx/TestHighestPrio.cpp b/ipc/ipdl/test/cxx/TestHighestPrio.cpp
new file mode 100644
index 000000000..524943de4
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestHighestPrio.cpp
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: sw=4 ts=4 et :
+ */
+/* 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 "TestHighestPrio.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#if defined(OS_POSIX)
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestHighestPrioParent::TestHighestPrioParent()
+  : msg_num_(0)
+{
+    MOZ_COUNT_CTOR(TestHighestPrioParent);
+}
+
+TestHighestPrioParent::~TestHighestPrioParent()
+{
+    MOZ_COUNT_DTOR(TestHighestPrioParent);
+}
+
+void
+TestHighestPrioParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+bool
+TestHighestPrioParent::RecvMsg1()
+{
+    MOZ_ASSERT(msg_num_ == 0);
+    msg_num_ = 1;
+    return true;
+}
+
+bool
+TestHighestPrioParent::RecvMsg2()
+{
+
+    MOZ_ASSERT(msg_num_ == 1);
+    msg_num_ = 2;
+
+    if (!SendStartInner())
+        fail("sending StartInner");
+
+    return true;
+}
+
+bool
+TestHighestPrioParent::RecvMsg3()
+{
+    MOZ_ASSERT(msg_num_ == 2);
+    msg_num_ = 3;
+    return true;
+}
+
+bool
+TestHighestPrioParent::RecvMsg4()
+{
+    MOZ_ASSERT(msg_num_ == 3);
+    msg_num_ = 4;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+
+TestHighestPrioChild::TestHighestPrioChild()
+{
+    MOZ_COUNT_CTOR(TestHighestPrioChild);
+}
+
+TestHighestPrioChild::~TestHighestPrioChild()
+{
+    MOZ_COUNT_DTOR(TestHighestPrioChild);
+}
+
+bool
+TestHighestPrioChild::RecvStart()
+{
+    if (!SendMsg1())
+        fail("sending Msg1");
+
+    if (!SendMsg2())
+        fail("sending Msg2");
+
+    Close();
+    return true;
+}
+
+bool
+TestHighestPrioChild::RecvStartInner()
+{
+    if (!SendMsg3())
+        fail("sending Msg3");
+
+    if (!SendMsg4())
+        fail("sending Msg4");
+
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestHighestPrio.h b/ipc/ipdl/test/cxx/TestHighestPrio.h
new file mode 100644
index 000000000..e6dc8c427
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestHighestPrio.h
@@ -0,0 +1,68 @@
+#ifndef mozilla__ipdltest_TestHighestPrio_h
+#define mozilla__ipdltest_TestHighestPrio_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestHighestPrioParent.h"
+#include "mozilla/_ipdltest/PTestHighestPrioChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestHighestPrioParent :
+    public PTestHighestPrioParent
+{
+public:
+    TestHighestPrioParent();
+    virtual ~TestHighestPrioParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+    bool RecvMsg1() override;
+    bool RecvMsg2() override;
+    bool RecvMsg3() override;
+    bool RecvMsg4() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        if (msg_num_ != 4)
+            fail("missed IPC call");
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    int msg_num_;
+};
+
+
+class TestHighestPrioChild :
+    public PTestHighestPrioChild
+{
+public:
+    TestHighestPrioChild();
+    virtual ~TestHighestPrioChild();
+
+    bool RecvStart() override;
+    bool RecvStartInner() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestHighestPrio_h
diff --git a/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.cpp b/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.cpp
new file mode 100644
index 000000000..21a5bc592
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.cpp
@@ -0,0 +1,155 @@
+#include "TestInterruptErrorCleanup.h"
+
+#include "base/task.h"
+#include "mozilla/CondVar.h"
+#include "mozilla/Mutex.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#include "IPDLUnitTestSubprocess.h"
+
+using mozilla::CondVar;
+using mozilla::Mutex;
+using mozilla::MutexAutoLock;
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+namespace {
+
+// NB: this test does its own shutdown, rather than going through
+// QuitParent(), because it's testing degenerate edge cases
+
+void DeleteSubprocess(Mutex* mutex, CondVar* cvar)
+{
+    MutexAutoLock lock(*mutex);
+
+    delete gSubprocess;
+    gSubprocess = nullptr;
+
+    cvar->Notify();
+}
+
+void DeleteTheWorld()
+{
+    delete static_cast<TestInterruptErrorCleanupParent*>(gParentActor);
+    gParentActor = nullptr;
+
+    // needs to be synchronous to avoid affecting event ordering on
+    // the main thread
+    Mutex mutex("TestInterruptErrorCleanup.DeleteTheWorld.mutex");
+    CondVar cvar(mutex, "TestInterruptErrorCleanup.DeleteTheWorld.cvar");
+
+    MutexAutoLock lock(mutex);
+
+    XRE_GetIOMessageLoop()->PostTask(
+      NewRunnableFunction(DeleteSubprocess, &mutex, &cvar));
+
+    cvar.Wait();
+}
+
+void Done()
+{
+  static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
+  nsCOMPtr<nsIAppShell> appShell (do_GetService(kAppShellCID));
+  appShell->Exit();
+
+  passed(__FILE__);
+}
+
+} // namespace <anon>
+
+TestInterruptErrorCleanupParent::TestInterruptErrorCleanupParent()
+    : mGotProcessingError(false)
+{
+    MOZ_COUNT_CTOR(TestInterruptErrorCleanupParent);
+}
+
+TestInterruptErrorCleanupParent::~TestInterruptErrorCleanupParent()
+{
+    MOZ_COUNT_DTOR(TestInterruptErrorCleanupParent);
+}
+
+void
+TestInterruptErrorCleanupParent::Main()
+{
+    // This test models the following sequence of events
+    //
+    // (1) Parent: Interrupt out-call
+    // (2) Child: crash
+    // --[Parent-only hereafter]--
+    // (3) Interrupt out-call return false
+    // (4) Close()
+    // --[event loop]--
+    // (5) delete parentActor
+    // (6) delete childProcess
+    // --[event loop]--
+    // (7) Channel::OnError notification
+    // --[event loop]--
+    // (8) Done, quit
+    //
+    // See bug 535298 and friends; this seqeunce of events captures
+    // three differnent potential errors
+    //  - Close()-after-error (semantic error previously)
+    //  - use-after-free of parentActor
+    //  - use-after-free of channel
+    //
+    // Because of legacy constraints related to nsNPAPI* code, we need
+    // to ensure that this sequence of events can occur without
+    // errors/crashes.
+
+    MessageLoop::current()->PostTask(
+        NewRunnableFunction(DeleteTheWorld));
+
+    // it's a failure if this *succeeds*
+    if (CallError())
+        fail("expected an error!");
+
+    if (!mGotProcessingError)
+        fail("expected a ProcessingError() notification");
+
+    // it's OK to Close() a channel after an error, because nsNPAPI*
+    // wants to do this
+    Close();
+
+    // we know that this event *must* be after the MaybeError
+    // notification enqueued by AsyncChannel, because that event is
+    // enqueued within the same mutex that ends up signaling the
+    // wakeup-on-error of |CallError()| above
+    MessageLoop::current()->PostTask(NewRunnableFunction(Done));
+}
+
+void
+TestInterruptErrorCleanupParent::ProcessingError(Result aCode, const char* aReason)
+{
+    if (aCode != MsgDropped)
+        fail("unexpected processing error");
+    mGotProcessingError = true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestInterruptErrorCleanupChild::TestInterruptErrorCleanupChild()
+{
+    MOZ_COUNT_CTOR(TestInterruptErrorCleanupChild);
+}
+
+TestInterruptErrorCleanupChild::~TestInterruptErrorCleanupChild()
+{
+    MOZ_COUNT_DTOR(TestInterruptErrorCleanupChild);
+}
+
+bool
+TestInterruptErrorCleanupChild::AnswerError()
+{
+    _exit(0);
+    NS_RUNTIMEABORT("unreached");
+    return false;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.h b/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.h
new file mode 100644
index 000000000..bd45b2c98
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestInterruptErrorCleanup.h
@@ -0,0 +1,60 @@
+#ifndef mozilla__ipdltest_TestInterruptErrorCleanup_h
+#define mozilla__ipdltest_TestInterruptErrorCleanup_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestInterruptErrorCleanupParent.h"
+#include "mozilla/_ipdltest/PTestInterruptErrorCleanupChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestInterruptErrorCleanupParent :
+    public PTestInterruptErrorCleanupParent
+{
+public:
+    TestInterruptErrorCleanupParent();
+    virtual ~TestInterruptErrorCleanupParent();
+
+    static bool RunTestInProcesses() { return true; }
+    // FIXME/bug 703323 Could work if modified
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:    
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (AbnormalShutdown != why)
+            fail("unexpected destruction!");  
+    }
+
+    virtual void ProcessingError(Result aCode, const char* aReason) override;
+
+    bool mGotProcessingError;
+};
+
+
+class TestInterruptErrorCleanupChild :
+    public PTestInterruptErrorCleanupChild
+{
+public:
+    TestInterruptErrorCleanupChild();
+    virtual ~TestInterruptErrorCleanupChild();
+
+protected:
+    virtual bool AnswerError() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        fail("should have 'crashed'!");
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestInterruptErrorCleanup_h
diff --git a/ipc/ipdl/test/cxx/TestInterruptRaces.cpp b/ipc/ipdl/test/cxx/TestInterruptRaces.cpp
new file mode 100644
index 000000000..6986506bb
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestInterruptRaces.cpp
@@ -0,0 +1,220 @@
+#include "TestInterruptRaces.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+using mozilla::ipc::MessageChannel;
+
+namespace mozilla {
+namespace _ipdltest {
+
+ipc::RacyInterruptPolicy
+MediateRace(const MessageChannel::MessageInfo& parent,
+            const MessageChannel::MessageInfo& child)
+{
+    return (PTestInterruptRaces::Msg_Child__ID == parent.type()) ?
+                ipc::RIPParentWins : ipc::RIPChildWins;
+}
+
+//-----------------------------------------------------------------------------
+// parent
+void
+TestInterruptRacesParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start()");
+}
+
+bool
+TestInterruptRacesParent::RecvStartRace()
+{
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestInterruptRacesParent::OnRaceTime));
+    return true;
+}
+
+void
+TestInterruptRacesParent::OnRaceTime()
+{
+    if (!CallRace(&mChildHasReply))
+        fail("problem calling Race()");
+
+    if (!mChildHasReply)
+        fail("child should have got a reply already");
+
+    mHasReply = true;
+
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestInterruptRacesParent::Test2));
+}
+
+bool
+TestInterruptRacesParent::AnswerRace(bool* hasReply)
+{
+    if (mHasReply)
+        fail("apparently the parent won the Interrupt race!");
+    *hasReply = hasReply;
+    return true;
+}
+
+void
+TestInterruptRacesParent::Test2()
+{
+    puts("  passed");
+    puts("Test 2");
+
+    mHasReply = false;
+    mChildHasReply = false;
+
+    if (!CallStackFrame())
+        fail("can't set up a stack frame");
+
+    puts("  passed");
+
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestInterruptRacesParent::Test3));
+}
+
+bool
+TestInterruptRacesParent::AnswerStackFrame()
+{
+    if (!SendWakeup())
+        fail("can't wake up the child");
+
+    if (!CallRace(&mChildHasReply))
+        fail("can't set up race condition");
+    mHasReply = true;
+
+    if (!mChildHasReply)
+        fail("child should have got a reply already");
+
+    return true;
+}
+
+void
+TestInterruptRacesParent::Test3()
+{
+    puts("Test 3");
+
+    if (!CallStackFrame3())
+        fail("can't set up a stack frame");
+
+    puts("  passed");
+
+    Close();
+}
+
+bool
+TestInterruptRacesParent::AnswerStackFrame3()
+{
+    if (!SendWakeup3())
+        fail("can't wake up the child");
+
+    if (!CallChild())
+        fail("can't set up race condition");
+
+    return true;
+}
+
+bool
+TestInterruptRacesParent::AnswerParent()
+{
+    mAnsweredParent = true;
+    return true;
+}
+
+bool
+TestInterruptRacesParent::RecvGetAnsweredParent(bool* answeredParent)
+{
+    *answeredParent = mAnsweredParent;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+bool
+TestInterruptRacesChild::RecvStart()
+{
+    puts("Test 1");
+
+    if (!SendStartRace())
+        fail("problem sending StartRace()");
+
+    bool dontcare;
+    if (!CallRace(&dontcare))
+        fail("problem calling Race()");
+
+    mHasReply = true;
+    return true;
+}
+
+bool
+TestInterruptRacesChild::AnswerRace(bool* hasReply)
+{
+    if (!mHasReply)
+        fail("apparently the child lost the Interrupt race!");
+
+    *hasReply = mHasReply;
+
+    return true;
+}
+
+bool
+TestInterruptRacesChild::AnswerStackFrame()
+{
+    // reset for the second test
+    mHasReply = false;
+
+    if (!CallStackFrame())
+        fail("can't set up stack frame");
+
+    if (!mHasReply)
+        fail("should have had reply by now");
+
+    return true;
+}
+
+bool
+TestInterruptRacesChild::RecvWakeup()
+{
+    bool dontcare;
+    if (!CallRace(&dontcare))
+        fail("can't set up race condition");
+
+    mHasReply = true;
+    return true;
+}
+
+bool
+TestInterruptRacesChild::AnswerStackFrame3()
+{
+    if (!CallStackFrame3())
+        fail("can't set up stack frame");
+    return true;
+}
+
+bool
+TestInterruptRacesChild::RecvWakeup3()
+{
+    if (!CallParent())
+        fail("can't set up race condition");
+    return true;
+}
+
+bool
+TestInterruptRacesChild::AnswerChild()
+{
+    bool parentAnsweredParent;
+    // the parent is supposed to win the race, which means its
+    // message, Child(), is supposed to be processed before the
+    // child's message, Parent()
+    if (!SendGetAnsweredParent(&parentAnsweredParent))
+        fail("sending GetAnsweredParent");
+
+    if (parentAnsweredParent)
+        fail("parent was supposed to win the race!");
+
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestInterruptRaces.h b/ipc/ipdl/test/cxx/TestInterruptRaces.h
new file mode 100644
index 000000000..f83c49fd1
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestInterruptRaces.h
@@ -0,0 +1,131 @@
+#ifndef mozilla__ipdltest_TestInterruptRaces_h
+#define mozilla__ipdltest_TestInterruptRaces_h
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestInterruptRacesParent.h"
+#include "mozilla/_ipdltest/PTestInterruptRacesChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+mozilla::ipc::RacyInterruptPolicy
+MediateRace(const mozilla::ipc::MessageChannel::MessageInfo& parent,
+            const mozilla::ipc::MessageChannel::MessageInfo& child);
+
+class TestInterruptRacesParent :
+    public PTestInterruptRacesParent
+{
+public:
+    TestInterruptRacesParent() : mHasReply(false),
+                           mChildHasReply(false),
+                           mAnsweredParent(false)
+    { }
+    virtual ~TestInterruptRacesParent() { }
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool
+    RecvStartRace() override;
+
+    virtual bool
+    AnswerRace(bool* hasRace) override;
+
+    virtual bool
+    AnswerStackFrame() override;
+
+    virtual bool
+    AnswerStackFrame3() override;
+
+    virtual bool
+    AnswerParent() override;
+
+    virtual bool
+    RecvGetAnsweredParent(bool* answeredParent) override;
+
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const MessageInfo& parent,
+                         const MessageInfo& child) override
+    {
+        return MediateRace(parent, child);
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        if (!(mHasReply && mChildHasReply))
+            fail("both sides should have replies!");
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    void OnRaceTime();
+
+    void Test2();
+    void Test3();
+
+    bool mHasReply;
+    bool mChildHasReply;
+    bool mAnsweredParent;
+};
+
+
+class TestInterruptRacesChild :
+    public PTestInterruptRacesChild
+{
+public:
+    TestInterruptRacesChild() : mHasReply(false) { }
+    virtual ~TestInterruptRacesChild() { }
+
+protected:
+    virtual bool
+    RecvStart() override;
+
+    virtual bool
+    AnswerRace(bool* hasRace) override;
+
+    virtual bool
+    AnswerStackFrame() override;
+
+    virtual bool
+    AnswerStackFrame3() override;
+
+    virtual bool
+    RecvWakeup() override;
+
+    virtual bool
+    RecvWakeup3() override;
+
+    virtual bool
+    AnswerChild() override;
+
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const MessageInfo& parent,
+                         const MessageInfo& child) override
+    {
+        return MediateRace(parent, child);
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+
+private:
+    bool mHasReply;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestInterruptRaces_h
diff --git a/ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp b/ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp
new file mode 100644
index 000000000..38f7993da
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestInterruptShutdownRace.cpp
@@ -0,0 +1,134 @@
+#include "TestInterruptShutdownRace.h"
+
+#include "base/task.h"
+#include "IPDLUnitTests.h"      // fail etc.
+#include "IPDLUnitTestSubprocess.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+namespace {
+
+// NB: this test does its own shutdown, rather than going through
+// QuitParent(), because it's testing degenerate edge cases
+
+void DeleteSubprocess()
+{
+    delete gSubprocess;
+    gSubprocess = nullptr;
+}
+
+void Done()
+{
+    passed(__FILE__);
+    QuitParent();
+}
+
+} // namespace <anon>
+
+TestInterruptShutdownRaceParent::TestInterruptShutdownRaceParent()
+{
+    MOZ_COUNT_CTOR(TestInterruptShutdownRaceParent);
+}
+
+TestInterruptShutdownRaceParent::~TestInterruptShutdownRaceParent()
+{
+    MOZ_COUNT_DTOR(TestInterruptShutdownRaceParent);
+}
+
+void
+TestInterruptShutdownRaceParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+bool
+TestInterruptShutdownRaceParent::RecvStartDeath()
+{
+    // this will be ordered before the OnMaybeDequeueOne event of
+    // Orphan in the queue
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this,
+				   &TestInterruptShutdownRaceParent::StartShuttingDown));
+    return true;
+}
+
+void
+TestInterruptShutdownRaceParent::StartShuttingDown()
+{
+    // NB: we sleep here to try and avoid receiving the Orphan message
+    // while waiting for the CallExit() reply.  if we fail at that, it
+    // will cause the test to pass spuriously, because there won't be
+    // an OnMaybeDequeueOne task for Orphan
+    PR_Sleep(2000);
+
+    if (CallExit())
+        fail("connection was supposed to be interrupted");
+
+    Close();
+
+    delete static_cast<TestInterruptShutdownRaceParent*>(gParentActor);
+    gParentActor = nullptr;
+
+    XRE_GetIOMessageLoop()->PostTask(NewRunnableFunction(DeleteSubprocess));
+
+    // this is ordered after the OnMaybeDequeueOne event in the queue
+    MessageLoop::current()->PostTask(NewRunnableFunction(Done));
+
+    // |this| has been deleted, be mindful
+}
+
+bool
+TestInterruptShutdownRaceParent::RecvOrphan()
+{
+    // it would be nice to fail() here, but we'll process this message
+    // while waiting for the reply CallExit().  The OnMaybeDequeueOne
+    // task will still be in the queue, it just wouldn't have had any
+    // work to do, if we hadn't deleted ourself
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestInterruptShutdownRaceChild::TestInterruptShutdownRaceChild()
+{
+    MOZ_COUNT_CTOR(TestInterruptShutdownRaceChild);
+}
+
+TestInterruptShutdownRaceChild::~TestInterruptShutdownRaceChild()
+{
+    MOZ_COUNT_DTOR(TestInterruptShutdownRaceChild);
+}
+
+bool
+TestInterruptShutdownRaceChild::RecvStart()
+{
+    if (!SendStartDeath())
+        fail("sending StartDeath");
+
+    // See comment in StartShuttingDown(): we want to send Orphan()
+    // while the parent is in its PR_Sleep()
+    PR_Sleep(1000);
+
+    if (!SendOrphan())
+        fail("sending Orphan");
+
+    return true;
+}
+
+bool
+TestInterruptShutdownRaceChild::AnswerExit()
+{
+    _exit(0);
+    NS_RUNTIMEABORT("unreached");
+    return false;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestInterruptShutdownRace.h b/ipc/ipdl/test/cxx/TestInterruptShutdownRace.h
new file mode 100644
index 000000000..c291b14a6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestInterruptShutdownRace.h
@@ -0,0 +1,64 @@
+#ifndef mozilla__ipdltest_TestInterruptShutdownRace_h
+#define mozilla__ipdltest_TestInterruptShutdownRace_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestInterruptShutdownRaceParent.h"
+#include "mozilla/_ipdltest/PTestInterruptShutdownRaceChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestInterruptShutdownRaceParent :
+    public PTestInterruptShutdownRaceParent
+{
+public:
+    TestInterruptShutdownRaceParent();
+    virtual ~TestInterruptShutdownRaceParent();
+
+    static bool RunTestInProcesses() { return true; }
+    // FIXME/bug 703323 Could work if modified
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+    virtual bool RecvStartDeath() override;
+
+    virtual bool RecvOrphan() override;
+
+protected:
+    void StartShuttingDown();
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (AbnormalShutdown != why)
+            fail("unexpected destruction!");  
+    }
+};
+
+
+class TestInterruptShutdownRaceChild :
+    public PTestInterruptShutdownRaceChild
+{
+public:
+    TestInterruptShutdownRaceChild();
+    virtual ~TestInterruptShutdownRaceChild();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual bool AnswerExit() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        fail("should have 'crashed'!");
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestInterruptShutdownRace_h
diff --git a/ipc/ipdl/test/cxx/TestJSON.cpp b/ipc/ipdl/test/cxx/TestJSON.cpp
new file mode 100644
index 000000000..ea742b705
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestJSON.cpp
@@ -0,0 +1,129 @@
+#include "TestJSON.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+#define test_assert(_cond, _msg) \
+    if (!(_cond)) fail(_msg)
+
+namespace mozilla {
+namespace _ipdltest {
+
+static nsString
+String(const char* const str)
+{
+    return NS_ConvertUTF8toUTF16(str);
+}
+
+static void
+Array123(InfallibleTArray<JSONVariant>& a123)
+{
+    a123.AppendElement(1);  a123.AppendElement(2);  a123.AppendElement(3);
+
+    test_assert(a123 == a123, "operator== is broken");
+}
+
+template<class HandleT>
+JSONVariant
+MakeTestVariant(HandleT* handle)
+{
+    // In JS syntax:
+    //
+    //   return [
+    //     undefined, null, true, 1.25, "test string",
+    //     handle,
+    //     [ 1, 2, 3 ],
+    //     { "undefined" : undefined,
+    //       "null"      : null,
+    //       "true"      : true,
+    //       "1.25"      : 1.25,
+    //       "string"    : "string"
+    //       "handle"    : handle,
+    //       "array"     : [ 1, 2, 3 ]
+    //     }
+    //   ]
+    //
+    InfallibleTArray<JSONVariant> outer;
+
+    outer.AppendElement(void_t());
+    outer.AppendElement(null_t());
+    outer.AppendElement(true);
+    outer.AppendElement(1.25);
+    outer.AppendElement(String("test string"));
+
+    outer.AppendElement(handle);
+
+    InfallibleTArray<JSONVariant> tmp;
+    Array123(tmp);
+    outer.AppendElement(tmp);
+
+    InfallibleTArray<KeyValue> obj;
+    obj.AppendElement(KeyValue(String("undefined"), void_t()));
+    obj.AppendElement(KeyValue(String("null"), null_t()));
+    obj.AppendElement(KeyValue(String("true"), true));
+    obj.AppendElement(KeyValue(String("1.25"), 1.25));
+    obj.AppendElement(KeyValue(String("string"), String("value")));
+    obj.AppendElement(KeyValue(String("handle"), handle));
+    InfallibleTArray<JSONVariant> tmp2;
+    Array123(tmp2);
+    obj.AppendElement(KeyValue(String("array"), tmp2));
+
+    outer.AppendElement(obj);
+
+    test_assert(outer == outer, "operator== is broken");
+
+    return JSONVariant(outer);
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+void
+TestJSONParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+
+bool
+TestJSONParent::RecvTest(const JSONVariant& i,
+                         JSONVariant* o)
+{
+    test_assert(i == i, "operator== is broken");
+    test_assert(i == MakeTestVariant(mKid), "inparam mangled en route");
+
+    *o = i;
+
+    test_assert(i == *o, "operator= is broken");
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+bool
+TestJSONChild::RecvStart()
+{
+    if (!SendPTestHandleConstructor())
+        fail("sending Handle ctor");
+
+    JSONVariant i(MakeTestVariant(mKid));
+    test_assert(i == i, "operator== is broken");
+    test_assert(i == MakeTestVariant(mKid), "copy ctor is broken");
+
+    JSONVariant o;
+    if (!SendTest(i, &o))
+        fail("sending Test");
+
+    test_assert(i == o, "round-trip mangled input data");
+    test_assert(o == MakeTestVariant(mKid), "outparam mangled en route");
+
+    Close();
+    return true;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestJSON.h b/ipc/ipdl/test/cxx/TestJSON.h
new file mode 100644
index 000000000..55d6e041b
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestJSON.h
@@ -0,0 +1,111 @@
+#ifndef mozilla__ipdltest_TestJSON_h
+#define mozilla__ipdltest_TestJSON_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestJSONParent.h"
+#include "mozilla/_ipdltest/PTestJSONChild.h"
+
+#include "mozilla/_ipdltest/PTestHandleParent.h"
+#include "mozilla/_ipdltest/PTestHandleChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+class TestHandleParent :
+    public PTestHandleParent
+{
+public:
+    TestHandleParent() { }
+    virtual ~TestHandleParent() { }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+};
+
+class TestJSONParent :
+    public PTestJSONParent
+{
+public:
+    TestJSONParent() { }
+    virtual ~TestJSONParent() { }
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool
+    RecvTest(const JSONVariant& i,
+             JSONVariant* o) override;
+
+    virtual PTestHandleParent* AllocPTestHandleParent() override
+    {
+        return mKid = new TestHandleParent();
+    }
+
+    virtual bool DeallocPTestHandleParent(PTestHandleParent* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+    PTestHandleParent* mKid;
+};
+
+
+class TestHandleChild :
+    public PTestHandleChild
+{
+public:
+    TestHandleChild() { }
+    virtual ~TestHandleChild() { }
+};
+
+class TestJSONChild :
+    public PTestJSONChild
+{
+public:
+    TestJSONChild() { }
+    virtual ~TestJSONChild() { }
+
+protected:
+    virtual bool
+    RecvStart() override;
+
+    virtual PTestHandleChild* AllocPTestHandleChild() override
+    {
+        return mKid = new TestHandleChild();
+    }
+
+    virtual bool DeallocPTestHandleChild(PTestHandleChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+
+    PTestHandleChild* mKid;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestJSON_h
diff --git a/ipc/ipdl/test/cxx/TestLatency.cpp b/ipc/ipdl/test/cxx/TestLatency.cpp
new file mode 100644
index 000000000..094622b82
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestLatency.cpp
@@ -0,0 +1,258 @@
+#include "TestLatency.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+// A ping/pong trial takes O(100us) or more, so if we don't have 10us
+// resolution or better, the results will not be terribly useful
+static const double kTimingResolutionCutoff = 0.00001; // 10us
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestLatencyParent::TestLatencyParent() :
+    mStart(),
+    mPPTimeTotal(),
+    mPP5TimeTotal(),
+    mRpcTimeTotal(),
+    mPPTrialsToGo(NR_TRIALS),
+    mPP5TrialsToGo(NR_TRIALS),
+    mNumChildProcessedCompressedSpams(0)
+{
+    MOZ_COUNT_CTOR(TestLatencyParent);
+}
+
+TestLatencyParent::~TestLatencyParent()
+{
+    MOZ_COUNT_DTOR(TestLatencyParent);
+}
+
+void
+TestLatencyParent::Main()
+{
+    TimeDuration resolution = TimeDuration::Resolution();
+    if (resolution.ToSeconds() > kTimingResolutionCutoff) {
+        puts("  (skipping TestLatency, timing resolution is too poor)");
+        Close();
+        return;
+    }
+
+    printf("  timing resolution: %g seconds\n",
+           resolution.ToSecondsSigDigits());
+
+    if (mozilla::ipc::LoggingEnabled())
+        NS_RUNTIMEABORT("you really don't want to log all IPC messages during this test, trust me");
+
+    PingPongTrial();
+}
+
+void
+TestLatencyParent::PingPongTrial()
+{
+    mStart = TimeStamp::Now();
+    if (!SendPing())
+        fail("sending Ping()");
+}
+
+void
+TestLatencyParent::Ping5Pong5Trial()
+{
+    mStart = TimeStamp::Now();
+
+    if (!SendPing5() ||
+        !SendPing5() ||
+        !SendPing5() ||
+        !SendPing5() ||
+        !SendPing5())
+        fail("sending Ping5()");
+}
+
+bool
+TestLatencyParent::RecvPong()
+{
+    TimeDuration thisTrial = (TimeStamp::Now() - mStart);
+    mPPTimeTotal += thisTrial;
+
+    if (0 == (mPPTrialsToGo % 1000))
+        printf("  PP trial %d: %g\n",
+               mPPTrialsToGo, thisTrial.ToSecondsSigDigits());
+
+    if (--mPPTrialsToGo > 0)
+        PingPongTrial();
+    else
+        Ping5Pong5Trial();
+    return true;
+}
+
+bool
+TestLatencyParent::RecvPong5()
+{
+    if (PTestLatency::PING5 != state())
+        return true;
+
+    TimeDuration thisTrial = (TimeStamp::Now() - mStart);
+    mPP5TimeTotal += thisTrial;
+
+    if (0 == (mPP5TrialsToGo % 1000))
+        printf("  PP5 trial %d: %g\n",
+               mPP5TrialsToGo, thisTrial.ToSecondsSigDigits());
+
+    if (0 < --mPP5TrialsToGo)
+        Ping5Pong5Trial();
+    else
+        RpcTrials();
+
+    return true;
+}
+
+void
+TestLatencyParent::RpcTrials()
+{
+    TimeStamp start = TimeStamp::Now();
+    for (int i = 0; i < NR_TRIALS; ++i) {
+        if (!CallRpc())
+            fail("can't call Rpc()");
+        if (0 == (i % 1000))
+            printf("  Rpc trial %d\n", i);
+    }
+    mRpcTimeTotal = (TimeStamp::Now() - start);
+
+    SpamTrial();
+}
+
+void
+TestLatencyParent::SpamTrial()
+{
+    TimeStamp start = TimeStamp::Now();
+    for (int i = 0; i < NR_SPAMS - 1; ++i) {
+        if (!SendSpam())
+            fail("sending Spam()");
+        if (0 == (i % 10000))
+            printf("  Spam trial %d\n", i);
+    }
+
+    // Synchronize with the child process to ensure all messages have
+    // been processed.  This adds the overhead of a reply message from
+    // child-->here, but should be insignificant compared to >>
+    // NR_SPAMS.
+    if (!CallSynchro())
+        fail("calling Synchro()");
+
+    mSpamTimeTotal = (TimeStamp::Now() - start);
+
+    CompressedSpamTrial();
+}
+
+void
+TestLatencyParent::CompressedSpamTrial()
+{
+    for (int i = 0; i < NR_SPAMS; ++i) {
+        if (!SendCompressedSpam(i + 1))
+            fail("sending CompressedSpam()");
+        if (0 == (i % 10000))
+            printf("  CompressedSpam trial %d\n", i);
+    }
+
+    uint32_t lastSeqno;
+    if (!CallSynchro2(&lastSeqno, &mNumChildProcessedCompressedSpams))
+        fail("calling Synchro2()");
+
+    if (lastSeqno != NR_SPAMS)
+        fail("last seqno was %u, expected %u", lastSeqno, NR_SPAMS);
+
+    // NB: since this is testing an optimization, it's somewhat bogus.
+    // Need to make a warning if it actually intermittently fails in
+    // practice, which is doubtful.
+    if (!(mNumChildProcessedCompressedSpams < NR_SPAMS))
+        fail("Didn't compress any messages?");
+
+    Exit();
+}
+
+void
+TestLatencyParent::Exit()
+{
+    Close();
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestLatencyChild::TestLatencyChild()
+    : mLastSeqno(0)
+    , mNumProcessedCompressedSpams(0)
+{
+    MOZ_COUNT_CTOR(TestLatencyChild);
+}
+
+TestLatencyChild::~TestLatencyChild()
+{
+    MOZ_COUNT_DTOR(TestLatencyChild);
+}
+
+bool
+TestLatencyChild::RecvPing()
+{
+    SendPong();
+    return true;
+}
+
+bool
+TestLatencyChild::RecvPing5()
+{
+    if (PTestLatency::PONG1 != state())
+        return true;
+
+    if (!SendPong5() ||
+        !SendPong5() ||
+        !SendPong5() ||
+        !SendPong5() ||
+        !SendPong5())
+        fail("sending Pong5()");
+
+    return true;
+}
+
+bool
+TestLatencyChild::AnswerRpc()
+{
+    return true;
+}
+
+bool
+TestLatencyChild::RecvSpam()
+{
+    // no-op
+    return true;
+}
+
+bool
+TestLatencyChild::AnswerSynchro()
+{
+    return true;
+}
+
+bool
+TestLatencyChild::RecvCompressedSpam(const uint32_t& seqno)
+{
+    if (seqno <= mLastSeqno)
+        fail("compressed seqnos must monotonically increase");
+
+    mLastSeqno = seqno;
+    ++mNumProcessedCompressedSpams;
+    return true;
+}
+
+bool
+TestLatencyChild::AnswerSynchro2(uint32_t* lastSeqno,
+                                 uint32_t* numMessagesDispatched)
+{
+    *lastSeqno = mLastSeqno;
+    *numMessagesDispatched = mNumProcessedCompressedSpams;
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestLatency.h b/ipc/ipdl/test/cxx/TestLatency.h
new file mode 100644
index 000000000..d179213db
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestLatency.h
@@ -0,0 +1,111 @@
+#ifndef mozilla__ipdltest_TestLatency_h
+#define mozilla__ipdltest_TestLatency_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestLatencyParent.h"
+#include "mozilla/_ipdltest/PTestLatencyChild.h"
+
+#include "mozilla/TimeStamp.h"
+
+#define NR_TRIALS 10000
+#define NR_SPAMS  25000
+
+namespace mozilla {
+namespace _ipdltest {
+
+class TestLatencyParent :
+    public PTestLatencyParent
+{
+private:
+    typedef mozilla::TimeStamp TimeStamp;
+    typedef mozilla::TimeDuration TimeDuration;
+
+public:
+    TestLatencyParent();
+    virtual ~TestLatencyParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool RecvPong() override;
+    virtual bool RecvPong5() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+
+        passed("\n"
+               "  average #ping-pong/sec:        %g\n"
+               "  average #ping5-pong5/sec:      %g\n"
+               "  average #RPC call-answer/sec:  %g\n"
+               "  average #spams/sec:            %g\n"
+               "  pct. spams compressed away:    %g\n",
+               double(NR_TRIALS) / mPPTimeTotal.ToSecondsSigDigits(),
+               double(NR_TRIALS) / mPP5TimeTotal.ToSecondsSigDigits(),
+               double(NR_TRIALS) / mRpcTimeTotal.ToSecondsSigDigits(),
+               double(NR_SPAMS) / mSpamTimeTotal.ToSecondsSigDigits(),
+               100.0 * (double(NR_SPAMS - mNumChildProcessedCompressedSpams) /
+                        double(NR_SPAMS)));
+
+        QuitParent();
+    }
+
+private:
+    void PingPongTrial();
+    void Ping5Pong5Trial();
+    void RpcTrials();
+    void SpamTrial();
+    void CompressedSpamTrial();
+    void Exit();
+
+    TimeStamp mStart;
+    TimeDuration mPPTimeTotal;
+    TimeDuration mPP5TimeTotal;
+    TimeDuration mRpcTimeTotal;
+    TimeDuration mSpamTimeTotal;
+
+    int mPPTrialsToGo;
+    int mPP5TrialsToGo;
+    uint32_t mNumChildProcessedCompressedSpams;
+};
+
+
+class TestLatencyChild :
+    public PTestLatencyChild
+{
+public:
+    TestLatencyChild();
+    virtual ~TestLatencyChild();
+
+protected:
+    virtual bool RecvPing() override;
+    virtual bool RecvPing5() override;
+    virtual bool AnswerRpc() override;
+    virtual bool RecvSpam() override;
+    virtual bool AnswerSynchro() override;
+    virtual bool RecvCompressedSpam(const uint32_t& seqno) override;
+    virtual bool AnswerSynchro2(uint32_t* lastSeqno,
+                                uint32_t* numMessagesDispatched) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+
+    uint32_t mLastSeqno;
+    uint32_t mNumProcessedCompressedSpams;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestLatency_h
diff --git a/ipc/ipdl/test/cxx/TestManyChildAllocs.cpp b/ipc/ipdl/test/cxx/TestManyChildAllocs.cpp
new file mode 100644
index 000000000..7dee30e63
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestManyChildAllocs.cpp
@@ -0,0 +1,104 @@
+#include "TestManyChildAllocs.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+
+#define NALLOCS 10
+
+namespace mozilla {
+namespace _ipdltest {
+
+// parent code
+
+TestManyChildAllocsParent::TestManyChildAllocsParent()
+{
+    MOZ_COUNT_CTOR(TestManyChildAllocsParent);
+}
+
+TestManyChildAllocsParent::~TestManyChildAllocsParent()
+{
+    MOZ_COUNT_DTOR(TestManyChildAllocsParent);
+}
+
+void
+TestManyChildAllocsParent::Main()
+{
+    if (!SendGo())
+        fail("can't send Go()");
+}
+
+bool
+TestManyChildAllocsParent::RecvDone()
+{
+    // explicitly *not* cleaning up, so we can sanity-check IPDL's
+    // auto-shutdown/cleanup handling
+    Close();
+
+    return true;
+}
+
+bool
+TestManyChildAllocsParent::DeallocPTestManyChildAllocsSubParent(
+    PTestManyChildAllocsSubParent* __a)
+{
+    delete __a; return true;
+}
+
+PTestManyChildAllocsSubParent*
+TestManyChildAllocsParent::AllocPTestManyChildAllocsSubParent()
+{
+    return new TestManyChildAllocsSubParent();
+}
+
+
+// child code
+
+TestManyChildAllocsChild::TestManyChildAllocsChild()
+{
+    MOZ_COUNT_CTOR(TestManyChildAllocsChild);
+}
+
+TestManyChildAllocsChild::~TestManyChildAllocsChild()
+{
+    MOZ_COUNT_DTOR(TestManyChildAllocsChild);
+}
+
+bool TestManyChildAllocsChild::RecvGo()
+{
+    for (int i = 0; i < NALLOCS; ++i) {
+        PTestManyChildAllocsSubChild* child =
+            SendPTestManyChildAllocsSubConstructor();
+
+        if (!child)
+            fail("can't send ctor()");
+
+        if (!child->SendHello())
+            fail("can't send Hello()");
+    }
+
+    size_t len = ManagedPTestManyChildAllocsSubChild().Count();
+    if (NALLOCS != len)
+        fail("expected %lu kids, got %lu", NALLOCS, len);
+
+    if (!SendDone())
+        fail("can't send Done()");
+
+    return true;
+}
+
+bool
+TestManyChildAllocsChild::DeallocPTestManyChildAllocsSubChild(
+    PTestManyChildAllocsSubChild* __a)
+{
+    delete __a; return true;
+}
+
+PTestManyChildAllocsSubChild*
+TestManyChildAllocsChild::AllocPTestManyChildAllocsSubChild()
+{
+    return new TestManyChildAllocsSubChild();
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestManyChildAllocs.h b/ipc/ipdl/test/cxx/TestManyChildAllocs.h
new file mode 100644
index 000000000..d29a35cb8
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestManyChildAllocs.h
@@ -0,0 +1,94 @@
+#ifndef mozilla__ipdltest_TestManyChildAllocs_h
+#define mozilla__ipdltest_TestManyChildAllocs_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestManyChildAllocsParent.h"
+#include "mozilla/_ipdltest/PTestManyChildAllocsChild.h"
+
+#include "mozilla/_ipdltest/PTestManyChildAllocsSubParent.h"
+#include "mozilla/_ipdltest/PTestManyChildAllocsSubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+// top-level protocol
+
+class TestManyChildAllocsParent :
+    public PTestManyChildAllocsParent
+{
+public:
+    TestManyChildAllocsParent();
+    virtual ~TestManyChildAllocsParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool RecvDone() override;
+    virtual bool DeallocPTestManyChildAllocsSubParent(PTestManyChildAllocsSubParent* __a) override;
+    virtual PTestManyChildAllocsSubParent* AllocPTestManyChildAllocsSubParent() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestManyChildAllocsChild :
+    public PTestManyChildAllocsChild
+{
+public:
+    TestManyChildAllocsChild();
+    virtual ~TestManyChildAllocsChild();
+
+protected:
+    virtual bool RecvGo() override;
+    virtual bool DeallocPTestManyChildAllocsSubChild(PTestManyChildAllocsSubChild* __a) override;
+    virtual PTestManyChildAllocsSubChild* AllocPTestManyChildAllocsSubChild() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+// do-nothing sub-protocol actors
+
+class TestManyChildAllocsSubParent :
+    public PTestManyChildAllocsSubParent
+{
+public:
+    TestManyChildAllocsSubParent() { }
+    virtual ~TestManyChildAllocsSubParent() { }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+    virtual bool RecvHello() override { return true; }
+};
+
+
+class TestManyChildAllocsSubChild :
+    public PTestManyChildAllocsSubChild
+{
+public:
+    TestManyChildAllocsSubChild() { }
+    virtual ~TestManyChildAllocsSubChild() { }
+};
+
+
+
+} // namepsace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestManyChildAllocs_h
diff --git a/ipc/ipdl/test/cxx/TestMultiMgrs.cpp b/ipc/ipdl/test/cxx/TestMultiMgrs.cpp
new file mode 100644
index 000000000..422b3fea3
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestMultiMgrs.cpp
@@ -0,0 +1,104 @@
+#include "TestMultiMgrs.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#include "mozilla/ipc/ProtocolUtils.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+void
+TestMultiMgrsParent::Main()
+{
+    TestMultiMgrsLeftParent* leftie = new TestMultiMgrsLeftParent();
+    if (!SendPTestMultiMgrsLeftConstructor(leftie))
+        fail("error sending ctor");
+
+    TestMultiMgrsRightParent* rightie = new TestMultiMgrsRightParent();
+    if (!SendPTestMultiMgrsRightConstructor(rightie))
+        fail("error sending ctor");
+
+    TestMultiMgrsBottomParent* bottomL = new TestMultiMgrsBottomParent();
+    if (!leftie->SendPTestMultiMgrsBottomConstructor(bottomL))
+        fail("error sending ctor");
+
+    TestMultiMgrsBottomParent* bottomR = new TestMultiMgrsBottomParent();
+    if (!rightie->SendPTestMultiMgrsBottomConstructor(bottomR))
+        fail("error sending ctor");
+
+    if (!leftie->HasChild(bottomL))
+        fail("leftie didn't have a child it was supposed to!");
+    if (leftie->HasChild(bottomR))
+        fail("leftie had rightie's child!");
+
+    if (!rightie->HasChild(bottomR))
+        fail("rightie didn't have a child it was supposed to!");
+    if (rightie->HasChild(bottomL))
+        fail("rightie had rightie's child!");
+
+    if (!SendCheck())
+        fail("couldn't kick off the child-side check");
+}
+
+bool
+TestMultiMgrsParent::RecvOK()
+{
+    Close();
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+bool
+TestMultiMgrsLeftChild::RecvPTestMultiMgrsBottomConstructor(
+    PTestMultiMgrsBottomChild* actor)
+{
+    static_cast<TestMultiMgrsChild*>(Manager())->mBottomL = actor;
+    return true;
+}
+
+bool
+TestMultiMgrsRightChild::RecvPTestMultiMgrsBottomConstructor(
+    PTestMultiMgrsBottomChild* actor)
+{
+    static_cast<TestMultiMgrsChild*>(Manager())->mBottomR = actor;
+    return true;
+}
+
+bool
+TestMultiMgrsChild::RecvCheck()
+{
+    if (1 != ManagedPTestMultiMgrsLeftChild().Count())
+        fail("where's leftie?");
+    if (1 != ManagedPTestMultiMgrsRightChild().Count())
+        fail("where's rightie?");
+
+    TestMultiMgrsLeftChild* leftie =
+        static_cast<TestMultiMgrsLeftChild*>(
+            LoneManagedOrNullAsserts(ManagedPTestMultiMgrsLeftChild()));
+    TestMultiMgrsRightChild* rightie =
+        static_cast<TestMultiMgrsRightChild*>(
+            LoneManagedOrNullAsserts(ManagedPTestMultiMgrsRightChild()));
+
+    if (!leftie->HasChild(mBottomL))
+        fail("leftie didn't have a child it was supposed to!");
+    if (leftie->HasChild(mBottomR))
+        fail("leftie had rightie's child!");
+
+    if (!rightie->HasChild(mBottomR))
+        fail("rightie didn't have a child it was supposed to!");
+    if (rightie->HasChild(mBottomL))
+        fail("rightie had leftie's child!");
+
+    if (!SendOK())
+        fail("couldn't send OK()");
+
+    return true;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestMultiMgrs.h b/ipc/ipdl/test/cxx/TestMultiMgrs.h
new file mode 100644
index 000000000..3dfab7430
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestMultiMgrs.h
@@ -0,0 +1,250 @@
+#ifndef mozilla__ipdltest_TestMultiMgrs_h
+#define mozilla__ipdltest_TestMultiMgrs_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestMultiMgrsParent.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsChild.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsBottomParent.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsBottomChild.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsLeftParent.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsLeftChild.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsRightParent.h"
+#include "mozilla/_ipdltest/PTestMultiMgrsRightChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Parent side
+//
+
+class TestMultiMgrsBottomParent :
+    public PTestMultiMgrsBottomParent
+{
+public:
+    TestMultiMgrsBottomParent() { }
+    virtual ~TestMultiMgrsBottomParent() { }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+};
+
+class TestMultiMgrsLeftParent :
+    public PTestMultiMgrsLeftParent
+{
+public:
+    TestMultiMgrsLeftParent() { }
+    virtual ~TestMultiMgrsLeftParent() { }
+
+    bool HasChild(TestMultiMgrsBottomParent* c)
+    {
+        return ManagedPTestMultiMgrsBottomParent().Contains(c);
+    }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+
+    virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottomParent() override
+    {
+        return new TestMultiMgrsBottomParent();
+    }
+
+    virtual bool DeallocPTestMultiMgrsBottomParent(PTestMultiMgrsBottomParent* actor) override
+    {
+        delete actor;
+        return true;
+    }
+};
+
+class TestMultiMgrsRightParent :
+    public PTestMultiMgrsRightParent
+{
+public:
+    TestMultiMgrsRightParent() { }
+    virtual ~TestMultiMgrsRightParent() { }
+
+    bool HasChild(TestMultiMgrsBottomParent* c)
+    {
+        return ManagedPTestMultiMgrsBottomParent().Contains(c);
+    }
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override {}
+
+    virtual PTestMultiMgrsBottomParent* AllocPTestMultiMgrsBottomParent() override
+    {
+        return new TestMultiMgrsBottomParent();
+    }
+
+    virtual bool DeallocPTestMultiMgrsBottomParent(PTestMultiMgrsBottomParent* actor) override
+    {
+        delete actor;
+        return true;
+    }
+};
+
+class TestMultiMgrsParent :
+    public PTestMultiMgrsParent
+{
+public:
+    TestMultiMgrsParent() { }
+    virtual ~TestMultiMgrsParent() { }
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool RecvOK() override;
+
+    virtual PTestMultiMgrsLeftParent* AllocPTestMultiMgrsLeftParent() override
+    {
+        return new TestMultiMgrsLeftParent();
+    }
+
+    virtual bool DeallocPTestMultiMgrsLeftParent(PTestMultiMgrsLeftParent* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual PTestMultiMgrsRightParent* AllocPTestMultiMgrsRightParent() override
+    {
+        return new TestMultiMgrsRightParent();
+    }
+
+    virtual bool DeallocPTestMultiMgrsRightParent(PTestMultiMgrsRightParent* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+//-----------------------------------------------------------------------------
+// Child side
+//
+
+class TestMultiMgrsBottomChild :
+    public PTestMultiMgrsBottomChild
+{
+public:
+    TestMultiMgrsBottomChild() { }
+    virtual ~TestMultiMgrsBottomChild() { }
+};
+
+class TestMultiMgrsLeftChild :
+    public PTestMultiMgrsLeftChild
+{
+public:
+    TestMultiMgrsLeftChild() { }
+    virtual ~TestMultiMgrsLeftChild() { }
+
+    bool HasChild(PTestMultiMgrsBottomChild* c)
+    {
+        return ManagedPTestMultiMgrsBottomChild().Contains(c);
+    }
+
+protected:
+    virtual bool RecvPTestMultiMgrsBottomConstructor(PTestMultiMgrsBottomChild* actor) override;
+
+    virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottomChild() override
+    {
+        return new TestMultiMgrsBottomChild();
+    }
+
+    virtual bool DeallocPTestMultiMgrsBottomChild(PTestMultiMgrsBottomChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+};
+
+class TestMultiMgrsRightChild :
+    public PTestMultiMgrsRightChild
+{
+public:
+    TestMultiMgrsRightChild() { }
+    virtual ~TestMultiMgrsRightChild() { }
+
+    bool HasChild(PTestMultiMgrsBottomChild* c)
+    {
+        return ManagedPTestMultiMgrsBottomChild().Contains(c);
+    }
+
+protected:
+    virtual bool RecvPTestMultiMgrsBottomConstructor(PTestMultiMgrsBottomChild* actor) override;
+
+    virtual PTestMultiMgrsBottomChild* AllocPTestMultiMgrsBottomChild() override
+    {
+        return new TestMultiMgrsBottomChild();
+    }
+
+    virtual bool DeallocPTestMultiMgrsBottomChild(PTestMultiMgrsBottomChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+};
+
+class TestMultiMgrsChild :
+    public PTestMultiMgrsChild
+{
+public:
+    TestMultiMgrsChild() { }
+    virtual ~TestMultiMgrsChild() { }
+
+    void Main();
+
+    PTestMultiMgrsBottomChild* mBottomL;
+    PTestMultiMgrsBottomChild* mBottomR;
+
+protected:
+    virtual bool RecvCheck() override;
+
+    virtual PTestMultiMgrsLeftChild* AllocPTestMultiMgrsLeftChild() override
+    {
+        return new TestMultiMgrsLeftChild();
+    }
+
+    virtual bool DeallocPTestMultiMgrsLeftChild(PTestMultiMgrsLeftChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual PTestMultiMgrsRightChild* AllocPTestMultiMgrsRightChild() override
+    {
+        return new TestMultiMgrsRightChild();
+    }
+
+    virtual bool DeallocPTestMultiMgrsRightChild(PTestMultiMgrsRightChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestMultiMgrs_h
diff --git a/ipc/ipdl/test/cxx/TestNestedLoops.cpp b/ipc/ipdl/test/cxx/TestNestedLoops.cpp
new file mode 100644
index 000000000..0e0ba496d
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestNestedLoops.cpp
@@ -0,0 +1,98 @@
+#include "base/basictypes.h"
+
+#include "nsThreadUtils.h"
+
+#include "TestNestedLoops.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestNestedLoopsParent::TestNestedLoopsParent() : mBreakNestedLoop(false)
+{
+    MOZ_COUNT_CTOR(TestNestedLoopsParent);
+}
+
+TestNestedLoopsParent::~TestNestedLoopsParent()
+{
+    MOZ_COUNT_DTOR(TestNestedLoopsParent);
+}
+
+void
+TestNestedLoopsParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+
+    // sigh ... spin for a while to let Nonce arrive
+    puts(" (sleeping to wait for nonce ... sorry)");
+    PR_Sleep(5000);
+
+    // while waiting for the reply to R, we'll receive Nonce
+    if (!CallR())
+        fail("calling R");
+
+    Close();
+}
+
+bool
+TestNestedLoopsParent::RecvNonce()
+{
+    // if we have an OnMaybeDequeueOne waiting for us (we may not, due
+    // to the inherent race condition in this test, then this event
+    // must be ordered after it in the queue
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestNestedLoopsParent::BreakNestedLoop));
+
+    // sigh ... spin for a while to let the reply to R arrive
+    puts(" (sleeping to wait for reply to R ... sorry)");
+    PR_Sleep(5000);
+
+    // sigh ... we have no idea when code might do this
+    do {
+        if (!NS_ProcessNextEvent(nullptr, false))
+            fail("expected at least one pending event");
+    } while (!mBreakNestedLoop);
+
+    return true;
+}
+
+void
+TestNestedLoopsParent::BreakNestedLoop()
+{
+    mBreakNestedLoop = true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestNestedLoopsChild::TestNestedLoopsChild()
+{
+    MOZ_COUNT_CTOR(TestNestedLoopsChild);
+}
+
+TestNestedLoopsChild::~TestNestedLoopsChild()
+{
+    MOZ_COUNT_DTOR(TestNestedLoopsChild);
+}
+
+bool
+TestNestedLoopsChild::RecvStart()
+{
+    if (!SendNonce())
+        fail("sending Nonce");
+    return true;
+}
+
+bool
+TestNestedLoopsChild::AnswerR()
+{
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestNestedLoops.h b/ipc/ipdl/test/cxx/TestNestedLoops.h
new file mode 100644
index 000000000..a91258a43
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestNestedLoops.h
@@ -0,0 +1,67 @@
+#ifndef mozilla__ipdltest_TestNestedLoops_h
+#define mozilla__ipdltest_TestNestedLoops_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestNestedLoopsParent.h"
+#include "mozilla/_ipdltest/PTestNestedLoopsChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestNestedLoopsParent :
+    public PTestNestedLoopsParent
+{
+public:
+    TestNestedLoopsParent();
+    virtual ~TestNestedLoopsParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual bool RecvNonce() override;
+
+    void BreakNestedLoop();
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+    bool mBreakNestedLoop;
+};
+
+
+class TestNestedLoopsChild :
+    public PTestNestedLoopsChild
+{
+public:
+    TestNestedLoopsChild();
+    virtual ~TestNestedLoopsChild();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual bool AnswerR() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestNestedLoops_h
diff --git a/ipc/ipdl/test/cxx/TestOpens.cpp b/ipc/ipdl/test/cxx/TestOpens.cpp
new file mode 100644
index 000000000..cb1ed00b5
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestOpens.cpp
@@ -0,0 +1,251 @@
+#include "base/task.h"
+#include "base/thread.h"
+
+#include "TestOpens.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+using namespace mozilla::ipc;
+
+using base::ProcessHandle;
+using base::Thread;
+
+namespace mozilla {
+// NB: this is generally bad style, but I am lazy.
+using namespace _ipdltest;
+using namespace _ipdltest2;
+
+static MessageLoop* gMainThread;
+
+static void
+AssertNotMainThread()
+{
+    if (!gMainThread)
+        fail("gMainThread is not initialized");
+    if (MessageLoop::current() == gMainThread)
+        fail("unexpectedly called on the main thread");
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+// Thread on which TestOpensOpenedParent runs
+static Thread* gParentThread;
+
+void
+TestOpensParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+static void
+OpenParent(TestOpensOpenedParent* aParent,
+           Transport* aTransport, base::ProcessId aOtherPid)
+{
+    AssertNotMainThread();
+
+    // Open the actor on the off-main thread to park it there.
+    // Messages will be delivered to this thread's message loop
+    // instead of the main thread's.
+    if (!aParent->Open(aTransport, aOtherPid,
+                       XRE_GetIOMessageLoop(), ipc::ParentSide))
+        fail("opening Parent");
+}
+
+PTestOpensOpenedParent*
+TestOpensParent::AllocPTestOpensOpenedParent(Transport* transport,
+                                             ProcessId otherPid)
+{
+    gMainThread = MessageLoop::current();
+
+    gParentThread = new Thread("ParentThread");
+    if (!gParentThread->Start())
+        fail("starting parent thread");
+
+    TestOpensOpenedParent* a = new TestOpensOpenedParent(transport);
+    gParentThread->message_loop()->PostTask(
+        NewRunnableFunction(OpenParent, a, transport, otherPid));
+
+    return a;
+}
+
+void
+TestOpensParent::ActorDestroy(ActorDestroyReason why)
+{
+    // Stops the thread and joins it
+    delete gParentThread;
+
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");  
+    passed("ok");
+    QuitParent();
+}
+
+bool
+TestOpensOpenedParent::RecvHello()
+{
+    AssertNotMainThread();
+    return SendHi();
+}
+
+bool
+TestOpensOpenedParent::RecvHelloSync()
+{
+    AssertNotMainThread();
+    return true;
+}
+
+bool
+TestOpensOpenedParent::AnswerHelloRpc()
+{
+    AssertNotMainThread();
+    return CallHiRpc();
+}
+
+static void
+ShutdownTestOpensOpenedParent(TestOpensOpenedParent* parent,
+                              Transport* transport)
+{
+    delete parent;
+}
+
+void
+TestOpensOpenedParent::ActorDestroy(ActorDestroyReason why)
+{
+    AssertNotMainThread();
+
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");
+
+    // ActorDestroy() is just a callback from IPDL-generated code,
+    // which needs the top-level actor (this) to stay alive a little
+    // longer so other things can be cleaned up.
+    gParentThread->message_loop()->PostTask(
+        NewRunnableFunction(ShutdownTestOpensOpenedParent,
+                            this, mTransport));
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+static TestOpensChild* gOpensChild;
+// Thread on which TestOpensOpenedChild runs
+static Thread* gChildThread;
+
+TestOpensChild::TestOpensChild()
+{
+    gOpensChild = this;
+}
+
+bool
+TestOpensChild::RecvStart()
+{
+    if (!PTestOpensOpened::Open(this))
+        fail("opening PTestOpensOpened");
+    return true;
+}
+
+static void
+OpenChild(TestOpensOpenedChild* aChild,
+           Transport* aTransport, base::ProcessId aOtherPid)
+{
+    AssertNotMainThread();
+
+    // Open the actor on the off-main thread to park it there.
+    // Messages will be delivered to this thread's message loop
+    // instead of the main thread's.
+    if (!aChild->Open(aTransport, aOtherPid,
+                      XRE_GetIOMessageLoop(), ipc::ChildSide))
+        fail("opening Child");
+
+    // Kick off the unit tests
+    if (!aChild->SendHello())
+        fail("sending Hello");
+}
+
+PTestOpensOpenedChild*
+TestOpensChild::AllocPTestOpensOpenedChild(Transport* transport,
+                                           ProcessId otherPid)
+{
+    gMainThread = MessageLoop::current();
+
+    gChildThread = new Thread("ChildThread");
+    if (!gChildThread->Start())
+        fail("starting child thread");
+
+    TestOpensOpenedChild* a = new TestOpensOpenedChild(transport);
+    gChildThread->message_loop()->PostTask(
+        NewRunnableFunction(OpenChild, a, transport, otherPid));
+
+    return a;
+}
+
+void
+TestOpensChild::ActorDestroy(ActorDestroyReason why)
+{
+    // Stops the thread and joins it
+    delete gChildThread;
+
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");
+    QuitChild();
+}
+
+bool
+TestOpensOpenedChild::RecvHi()
+{
+    AssertNotMainThread();
+
+    if (!SendHelloSync())
+        fail("sending HelloSync");
+    if (!CallHelloRpc())
+        fail("calling HelloRpc");
+    if (!mGotHi)
+        fail("didn't answer HiRpc");
+
+    // Need to close the channel without message-processing frames on
+    // the C++ stack
+    MessageLoop::current()->PostTask(
+        NewNonOwningRunnableMethod(this, &TestOpensOpenedChild::Close));
+    return true;
+}
+
+bool
+TestOpensOpenedChild::AnswerHiRpc()
+{
+    AssertNotMainThread();
+
+    mGotHi = true;              // d00d
+    return true;
+}
+
+static void
+ShutdownTestOpensOpenedChild(TestOpensOpenedChild* child,
+                             Transport* transport)
+{
+    delete child;
+
+    // Kick off main-thread shutdown.
+    gMainThread->PostTask(
+        NewNonOwningRunnableMethod(gOpensChild, &TestOpensChild::Close));
+}
+
+void
+TestOpensOpenedChild::ActorDestroy(ActorDestroyReason why)
+{
+    AssertNotMainThread();
+
+    if (NormalShutdown != why)
+        fail("unexpected destruction!");  
+
+    // ActorDestroy() is just a callback from IPDL-generated code,
+    // which needs the top-level actor (this) to stay alive a little
+    // longer so other things can be cleaned up.  Defer shutdown to
+    // let cleanup finish.
+    gChildThread->message_loop()->PostTask(
+        NewRunnableFunction(ShutdownTestOpensOpenedChild,
+                            this, mTransport));
+}
+
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestOpens.h b/ipc/ipdl/test/cxx/TestOpens.h
new file mode 100644
index 000000000..b83645a82
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestOpens.h
@@ -0,0 +1,107 @@
+#ifndef mozilla__ipdltest_TestOpens_h
+#define mozilla__ipdltest_TestOpens_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestOpensParent.h"
+#include "mozilla/_ipdltest/PTestOpensChild.h"
+
+#include "mozilla/_ipdltest2/PTestOpensOpenedParent.h"
+#include "mozilla/_ipdltest2/PTestOpensOpenedChild.h"
+
+namespace mozilla {
+
+// parent process
+
+namespace _ipdltest {
+
+class TestOpensParent : public PTestOpensParent
+{
+public:
+    TestOpensParent() {}
+    virtual ~TestOpensParent() {}
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:
+    virtual PTestOpensOpenedParent*
+    AllocPTestOpensOpenedParent(Transport* transport, ProcessId otherProcess) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+} // namespace _ipdltest
+
+namespace _ipdltest2 {
+
+class TestOpensOpenedParent : public PTestOpensOpenedParent
+{
+public:
+    explicit TestOpensOpenedParent(Transport* aTransport)
+        : mTransport(aTransport)
+    {}
+    virtual ~TestOpensOpenedParent() {}
+
+protected:
+    virtual bool RecvHello() override;
+    virtual bool RecvHelloSync() override;
+    virtual bool AnswerHelloRpc() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+
+    Transport* mTransport;
+};
+
+} // namespace _ipdltest2
+
+// child process
+
+namespace _ipdltest {
+
+class TestOpensChild : public PTestOpensChild
+{
+public:
+    TestOpensChild();
+    virtual ~TestOpensChild() {}
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual PTestOpensOpenedChild*
+    AllocPTestOpensOpenedChild(Transport* transport, ProcessId otherProcess) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+};
+
+} // namespace _ipdltest
+
+namespace _ipdltest2 {
+
+class TestOpensOpenedChild : public PTestOpensOpenedChild
+{
+public:
+    explicit TestOpensOpenedChild(Transport* aTransport)
+        : mGotHi(false)
+        , mTransport(aTransport)
+    {}
+    virtual ~TestOpensOpenedChild() {}
+
+protected:
+    virtual bool RecvHi() override;
+    virtual bool AnswerHiRpc() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override;
+
+    bool mGotHi;
+    Transport* mTransport;
+};
+
+} // namespace _ipdltest2
+
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestOpens_h
diff --git a/ipc/ipdl/test/cxx/TestRPC.cpp b/ipc/ipdl/test/cxx/TestRPC.cpp
new file mode 100644
index 000000000..2dfc51d33
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRPC.cpp
@@ -0,0 +1,152 @@
+#include "TestRPC.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#if defined(OS_POSIX)
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestRPCParent::TestRPCParent()
+ : reentered_(false),
+   resolved_first_cpow_(false)
+{
+  MOZ_COUNT_CTOR(TestRPCParent);
+}
+
+TestRPCParent::~TestRPCParent()
+{
+  MOZ_COUNT_DTOR(TestRPCParent);
+}
+
+void
+TestRPCParent::Main()
+{
+  if (!SendStart())
+    fail("sending Start");
+}
+
+bool
+TestRPCParent::RecvTest1_Start(uint32_t* aResult)
+{
+  uint32_t result;
+  if (!SendTest1_InnerQuery(&result))
+    fail("SendTest1_InnerQuery");
+  if (result != 300)
+    fail("Wrong result (expected 300)");
+
+  *aResult = 100;
+  return true;
+}
+
+bool
+TestRPCParent::RecvTest1_InnerEvent(uint32_t* aResult)
+{
+  uint32_t result;
+  if (!SendTest1_NoReenter(&result))
+    fail("SendTest1_NoReenter");
+  if (result != 400)
+    fail("Wrong result (expected 400)");
+
+  *aResult = 200;
+  return true;
+}
+
+bool
+TestRPCParent::RecvTest2_Start()
+{
+  // Send a CPOW. During this time, we must NOT process the RPC message, as
+  // we could start receiving CPOW replies out-of-order.
+  if (!SendTest2_FirstUrgent())
+    fail("SendTest2_FirstUrgent");
+
+  MOZ_ASSERT(!reentered_);
+  resolved_first_cpow_ = true;
+  return true;
+}
+
+bool
+TestRPCParent::RecvTest2_OutOfOrder()
+{
+  // Send a CPOW. If this RPC call was initiated while waiting for the first
+  // CPOW to resolve, replies will be processed out of order, and we'll crash.
+  if (!SendTest2_SecondUrgent())
+    fail("SendTest2_SecondUrgent");
+
+  reentered_ = true;
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+
+TestRPCChild::TestRPCChild()
+{
+    MOZ_COUNT_CTOR(TestRPCChild);
+}
+
+TestRPCChild::~TestRPCChild()
+{
+    MOZ_COUNT_DTOR(TestRPCChild);
+}
+
+bool
+TestRPCChild::RecvStart()
+{
+  uint32_t result;
+  if (!SendTest1_Start(&result))
+    fail("SendTest1_Start");
+  if (result != 100)
+    fail("Wrong result (expected 100)");
+
+  if (!SendTest2_Start())
+    fail("SendTest2_Start");
+
+  if (!SendTest2_OutOfOrder())
+    fail("SendTest2_OutOfOrder");
+
+  Close();
+  return true;
+}
+
+bool
+TestRPCChild::RecvTest1_InnerQuery(uint32_t* aResult)
+{
+  uint32_t result;
+  if (!SendTest1_InnerEvent(&result))
+    fail("SendTest1_InnerEvent");
+  if (result != 200)
+    fail("Wrong result (expected 200)");
+
+  *aResult = 300;
+  return true;
+}
+
+bool
+TestRPCChild::RecvTest1_NoReenter(uint32_t* aResult)
+{
+  *aResult = 400;
+  return true;
+}
+
+bool
+TestRPCChild::RecvTest2_FirstUrgent()
+{
+  return true;
+}
+
+bool
+TestRPCChild::RecvTest2_SecondUrgent()
+{
+  return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestRPC.h b/ipc/ipdl/test/cxx/TestRPC.h
new file mode 100644
index 000000000..0a11b3e76
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRPC.h
@@ -0,0 +1,74 @@
+#ifndef mozilla__ipdltest_TestRPC_h
+#define mozilla__ipdltest_TestRPC_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestRPCParent.h"
+#include "mozilla/_ipdltest/PTestRPCChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestRPCParent :
+    public PTestRPCParent
+{
+public:
+    TestRPCParent();
+    virtual ~TestRPCParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+    bool RecvTest1_Start(uint32_t* aResult) override;
+    bool RecvTest1_InnerEvent(uint32_t* aResult) override;
+    bool RecvTest2_Start() override;
+    bool RecvTest2_OutOfOrder() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        if (!reentered_)
+            fail("never processed raced RPC call!");
+        if (!resolved_first_cpow_)
+            fail("never resolved first CPOW!");
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    bool reentered_;
+    bool resolved_first_cpow_;
+};
+
+
+class TestRPCChild :
+    public PTestRPCChild
+{
+public:
+    TestRPCChild();
+    virtual ~TestRPCChild();
+
+    bool RecvStart() override;
+    bool RecvTest1_InnerQuery(uint32_t* aResult) override;
+    bool RecvTest1_NoReenter(uint32_t* aResult) override;
+    bool RecvTest2_FirstUrgent() override;
+    bool RecvTest2_SecondUrgent() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestRPC_h
diff --git a/ipc/ipdl/test/cxx/TestRaceDeadlock.cpp b/ipc/ipdl/test/cxx/TestRaceDeadlock.cpp
new file mode 100644
index 000000000..7402f30d3
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRaceDeadlock.cpp
@@ -0,0 +1,131 @@
+#include "TestRaceDeadlock.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+// #define TEST_TIMEOUT 5000
+
+using namespace mozilla::ipc;
+typedef mozilla::ipc::MessageChannel::Message Message;
+typedef mozilla::ipc::MessageChannel::MessageInfo MessageInfo;
+
+namespace mozilla {
+namespace _ipdltest {
+
+static RacyInterruptPolicy
+MediateRace(const MessageInfo& parent, const MessageInfo& child)
+{
+    return (PTestRaceDeadlock::Msg_Win__ID == parent.type()) ?
+        RIPParentWins : RIPChildWins;
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestRaceDeadlockParent::TestRaceDeadlockParent()
+{
+    MOZ_COUNT_CTOR(TestRaceDeadlockParent);
+}
+
+TestRaceDeadlockParent::~TestRaceDeadlockParent()
+{
+    MOZ_COUNT_DTOR(TestRaceDeadlockParent);
+}
+
+void
+TestRaceDeadlockParent::Main()
+{
+    Test1();
+
+    Close();
+}
+
+bool
+TestRaceDeadlockParent::ShouldContinueFromReplyTimeout()
+{
+    fail("This test should not hang");
+    GetIPCChannel()->CloseWithTimeout();
+    return false;
+}
+
+void
+TestRaceDeadlockParent::Test1()
+{
+#if defined(TEST_TIMEOUT)
+    SetReplyTimeoutMs(TEST_TIMEOUT);
+#endif
+    if (!SendStartRace()) {
+        fail("sending StartRace");
+    }
+    if (!CallRpc()) {
+        fail("calling Rpc");
+    }
+}
+
+bool
+TestRaceDeadlockParent::AnswerLose()
+{
+    return true;
+}
+
+RacyInterruptPolicy
+TestRaceDeadlockParent::MediateInterruptRace(const MessageInfo& parent,
+                                             const MessageInfo& child)
+{
+    return MediateRace(parent, child);
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestRaceDeadlockChild::TestRaceDeadlockChild()
+{
+    MOZ_COUNT_CTOR(TestRaceDeadlockChild);
+}
+
+TestRaceDeadlockChild::~TestRaceDeadlockChild()
+{
+    MOZ_COUNT_DTOR(TestRaceDeadlockChild);
+}
+
+bool
+TestRaceDeadlockParent::RecvStartRace()
+{
+    if (!CallWin()) {
+        fail("calling Win");
+    }
+    return true;
+}
+
+bool
+TestRaceDeadlockChild::RecvStartRace()
+{
+    if (!SendStartRace()) {
+        fail("calling SendStartRace");
+    }
+    if (!CallLose()) {
+        fail("calling Lose");
+    }
+    return true;
+}
+
+bool
+TestRaceDeadlockChild::AnswerWin()
+{
+    return true;
+}
+
+bool
+TestRaceDeadlockChild::AnswerRpc()
+{
+    return true;
+}
+
+RacyInterruptPolicy
+TestRaceDeadlockChild::MediateInterruptRace(const MessageInfo& parent,
+                                            const MessageInfo& child)
+{
+    return MediateRace(parent, child);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestRaceDeadlock.h b/ipc/ipdl/test/cxx/TestRaceDeadlock.h
new file mode 100644
index 000000000..7723c7629
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRaceDeadlock.h
@@ -0,0 +1,77 @@
+#ifndef mozilla__ipdltest_TestRaceDeadlock_h
+#define mozilla__ipdltest_TestRaceDeadlock_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestRaceDeadlockParent.h"
+#include "mozilla/_ipdltest/PTestRaceDeadlockChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+class TestRaceDeadlockParent :
+    public PTestRaceDeadlockParent
+{
+public:
+    TestRaceDeadlockParent();
+    virtual ~TestRaceDeadlockParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool ShouldContinueFromReplyTimeout() override;
+
+    void Test1();
+
+    virtual bool RecvStartRace() override;
+    virtual bool AnswerLose() override;
+
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const MessageInfo& parent,
+                         const MessageInfo& child) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestRaceDeadlockChild :
+    public PTestRaceDeadlockChild
+{
+public:
+    TestRaceDeadlockChild();
+    virtual ~TestRaceDeadlockChild();
+
+protected:
+    virtual bool RecvStartRace() override;
+
+    virtual bool AnswerWin() override;
+
+    virtual bool AnswerRpc() override;
+
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const MessageInfo& parent,
+                         const MessageInfo& child) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestRaceDeadlock_h
diff --git a/ipc/ipdl/test/cxx/TestRaceDeferral.cpp b/ipc/ipdl/test/cxx/TestRaceDeferral.cpp
new file mode 100644
index 000000000..b62d0e2f3
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRaceDeferral.cpp
@@ -0,0 +1,118 @@
+#include "TestRaceDeferral.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+using namespace mozilla::ipc;
+typedef mozilla::ipc::MessageChannel::Message Message;
+typedef mozilla::ipc::MessageChannel::MessageInfo MessageInfo;
+
+namespace mozilla {
+namespace _ipdltest {
+
+static RacyInterruptPolicy
+MediateRace(const MessageInfo& parent, const MessageInfo& child)
+{
+    return (PTestRaceDeferral::Msg_Win__ID == parent.type()) ?
+        RIPParentWins : RIPChildWins;
+}
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestRaceDeferralParent::TestRaceDeferralParent()
+    : mProcessedLose(false)
+{
+    MOZ_COUNT_CTOR(TestRaceDeferralParent);
+}
+
+TestRaceDeferralParent::~TestRaceDeferralParent()
+{
+    MOZ_COUNT_DTOR(TestRaceDeferralParent);
+
+    if (!mProcessedLose)
+        fail("never processed Lose");
+}
+
+void
+TestRaceDeferralParent::Main()
+{
+    Test1();
+
+    Close();
+}
+
+void
+TestRaceDeferralParent::Test1()
+{
+    if (!SendStartRace())
+        fail("sending StartRace");
+
+    if (!CallWin())
+        fail("calling Win");
+    if (mProcessedLose)
+        fail("Lose didn't lose");
+
+    if (!CallRpc())
+        fail("calling Rpc");
+    if (!mProcessedLose)
+        fail("didn't resolve Rpc vs. Lose 'race' correctly");
+}
+
+bool
+TestRaceDeferralParent::AnswerLose()
+{
+    if (mProcessedLose)
+        fail("processed Lose twice");
+    mProcessedLose = true;
+    return true;
+}
+
+RacyInterruptPolicy
+TestRaceDeferralParent::MediateInterruptRace(const MessageInfo& parent,
+                                             const MessageInfo& child)
+{
+    return MediateRace(parent, child);
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestRaceDeferralChild::TestRaceDeferralChild()
+{
+    MOZ_COUNT_CTOR(TestRaceDeferralChild);
+}
+
+TestRaceDeferralChild::~TestRaceDeferralChild()
+{
+    MOZ_COUNT_DTOR(TestRaceDeferralChild);
+}
+
+bool
+TestRaceDeferralChild::RecvStartRace()
+{
+    if (!CallLose())
+        fail("calling Lose");
+    return true;
+}
+
+bool
+TestRaceDeferralChild::AnswerWin()
+{
+    return true;
+}
+
+bool
+TestRaceDeferralChild::AnswerRpc()
+{
+    return true;
+}
+
+RacyInterruptPolicy
+TestRaceDeferralChild::MediateInterruptRace(const MessageInfo& parent,
+                                            const MessageInfo& child)
+{
+    return MediateRace(parent, child);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestRaceDeferral.h b/ipc/ipdl/test/cxx/TestRaceDeferral.h
new file mode 100644
index 000000000..e465cf77c
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRaceDeferral.h
@@ -0,0 +1,76 @@
+#ifndef mozilla__ipdltest_TestRaceDeferral_h
+#define mozilla__ipdltest_TestRaceDeferral_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestRaceDeferralParent.h"
+#include "mozilla/_ipdltest/PTestRaceDeferralChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+class TestRaceDeferralParent :
+    public PTestRaceDeferralParent
+{
+public:
+    TestRaceDeferralParent();
+    virtual ~TestRaceDeferralParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    void Test1();
+
+    virtual bool AnswerLose() override;
+
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const MessageInfo& parent,
+                         const MessageInfo& child) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+    bool mProcessedLose;
+};
+
+
+class TestRaceDeferralChild :
+    public PTestRaceDeferralChild
+{
+public:
+    TestRaceDeferralChild();
+    virtual ~TestRaceDeferralChild();
+
+protected:
+    virtual bool RecvStartRace() override;
+
+    virtual bool AnswerWin() override;
+
+    virtual bool AnswerRpc() override;
+
+    virtual mozilla::ipc::RacyInterruptPolicy
+    MediateInterruptRace(const MessageInfo& parent,
+                         const MessageInfo& child) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestRaceDeferral_h
diff --git a/ipc/ipdl/test/cxx/TestRacyInterruptReplies.cpp b/ipc/ipdl/test/cxx/TestRacyInterruptReplies.cpp
new file mode 100644
index 000000000..513b84f73
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRacyInterruptReplies.cpp
@@ -0,0 +1,119 @@
+#include "TestRacyInterruptReplies.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestRacyInterruptRepliesParent::TestRacyInterruptRepliesParent() : mReplyNum(0)
+{
+    MOZ_COUNT_CTOR(TestRacyInterruptRepliesParent);
+}
+
+TestRacyInterruptRepliesParent::~TestRacyInterruptRepliesParent()
+{
+    MOZ_COUNT_DTOR(TestRacyInterruptRepliesParent);
+}
+
+void
+TestRacyInterruptRepliesParent::Main()
+{
+    int replyNum = -1;
+    if (!CallR_(&replyNum))
+        fail("calling R()");
+
+    if (1 != replyNum)
+        fail("this should have been the first reply to R()");
+
+    if (!SendChildTest())
+        fail("sending ChildStart");
+}
+
+bool
+TestRacyInterruptRepliesParent::RecvA_()
+{
+    int replyNum = -1;
+    // this R() call races with the reply being generated by the other
+    // side to the R() call from Main().  This is a pretty nasty edge
+    // case for which one could argue we're breaking in-order message
+    // delivery, since this side will process the second reply to R()
+    // before the first.
+    if (!CallR_(&replyNum))
+        fail("calling R()");
+
+    if (2 != replyNum)
+        fail("this should have been the second reply to R()");
+
+    return true;
+}
+
+bool
+TestRacyInterruptRepliesParent::Answer_R(int* replyNum)
+{
+    *replyNum = ++mReplyNum;
+
+    if (1 == *replyNum)
+        if (!Send_A())
+            fail("sending _A()");
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestRacyInterruptRepliesChild::TestRacyInterruptRepliesChild() : mReplyNum(0)
+{
+    MOZ_COUNT_CTOR(TestRacyInterruptRepliesChild);
+}
+
+TestRacyInterruptRepliesChild::~TestRacyInterruptRepliesChild()
+{
+    MOZ_COUNT_DTOR(TestRacyInterruptRepliesChild);
+}
+
+bool
+TestRacyInterruptRepliesChild::AnswerR_(int* replyNum)
+{
+    *replyNum = ++mReplyNum;
+
+    if (1 == *replyNum)
+        SendA_();
+
+    return true;
+}
+
+bool
+TestRacyInterruptRepliesChild::RecvChildTest()
+{
+    int replyNum = -1;
+    if (!Call_R(&replyNum))
+        fail("calling R()");
+
+    if (1 != replyNum)
+        fail("this should have been the first reply to R()");
+
+    Close();
+
+    return true;
+}
+
+bool
+TestRacyInterruptRepliesChild::Recv_A()
+{
+    int replyNum = -1;
+
+    if (!Call_R(&replyNum))
+        fail("calling _R()");
+
+    if (2 != replyNum)
+        fail("this should have been the second reply to R()");
+
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestRacyInterruptReplies.h b/ipc/ipdl/test/cxx/TestRacyInterruptReplies.h
new file mode 100644
index 000000000..94f514188
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRacyInterruptReplies.h
@@ -0,0 +1,73 @@
+#ifndef mozilla__ipdltest_TestRacyInterruptReplies_h
+#define mozilla__ipdltest_TestRacyInterruptReplies_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestRacyInterruptRepliesParent.h"
+#include "mozilla/_ipdltest/PTestRacyInterruptRepliesChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestRacyInterruptRepliesParent :
+    public PTestRacyInterruptRepliesParent
+{
+public:
+    TestRacyInterruptRepliesParent();
+    virtual ~TestRacyInterruptRepliesParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual bool RecvA_() override;
+
+    virtual bool Answer_R(int* replyNum) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    int mReplyNum;
+};
+
+
+class TestRacyInterruptRepliesChild :
+    public PTestRacyInterruptRepliesChild
+{
+public:
+    TestRacyInterruptRepliesChild();
+    virtual ~TestRacyInterruptRepliesChild();
+
+protected:
+    virtual bool AnswerR_(int* replyNum) override;
+
+    virtual bool RecvChildTest() override;
+
+    virtual bool Recv_A() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+
+private:
+    int mReplyNum;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestRacyInterruptReplies_h
diff --git a/ipc/ipdl/test/cxx/TestRacyReentry.cpp b/ipc/ipdl/test/cxx/TestRacyReentry.cpp
new file mode 100644
index 000000000..00996cc39
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRacyReentry.cpp
@@ -0,0 +1,84 @@
+#include "TestRacyReentry.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestRacyReentryParent::TestRacyReentryParent() : mRecvdE(false)
+{
+    MOZ_COUNT_CTOR(TestRacyReentryParent);
+}
+
+TestRacyReentryParent::~TestRacyReentryParent()
+{
+    MOZ_COUNT_DTOR(TestRacyReentryParent);
+}
+
+void
+TestRacyReentryParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+
+    if (!SendN())
+        fail("sending N");
+}
+
+bool
+TestRacyReentryParent::AnswerE()
+{
+    if (!mRecvdE) {
+        mRecvdE = true;
+        return true;
+    }
+
+    if (!CallH())
+        fail("calling H");
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestRacyReentryChild::TestRacyReentryChild()
+{
+    MOZ_COUNT_CTOR(TestRacyReentryChild);
+}
+
+TestRacyReentryChild::~TestRacyReentryChild()
+{
+    MOZ_COUNT_DTOR(TestRacyReentryChild);
+}
+
+bool
+TestRacyReentryChild::RecvStart()
+{
+    if (!CallE())
+        fail("calling E");
+
+    Close();
+
+    return true;
+}
+
+bool
+TestRacyReentryChild::RecvN()
+{
+    if (!CallE())
+        fail("calling E");
+    return true;
+}
+
+bool
+TestRacyReentryChild::AnswerH()
+{
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestRacyReentry.h b/ipc/ipdl/test/cxx/TestRacyReentry.h
new file mode 100644
index 000000000..f496ef7bf
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRacyReentry.h
@@ -0,0 +1,67 @@
+#ifndef mozilla__ipdltest_TestRacyReentry_h
+#define mozilla__ipdltest_TestRacyReentry_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestRacyReentryParent.h"
+#include "mozilla/_ipdltest/PTestRacyReentryChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestRacyReentryParent :
+    public PTestRacyReentryParent
+{
+public:
+    TestRacyReentryParent();
+    virtual ~TestRacyReentryParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool AnswerE() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+    bool mRecvdE;
+};
+
+
+class TestRacyReentryChild :
+    public PTestRacyReentryChild
+{
+public:
+    TestRacyReentryChild();
+    virtual ~TestRacyReentryChild();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual bool RecvN() override;
+
+    virtual bool AnswerH() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestRacyReentry_h
diff --git a/ipc/ipdl/test/cxx/TestRacyUndefer.cpp b/ipc/ipdl/test/cxx/TestRacyUndefer.cpp
new file mode 100644
index 000000000..8bdd804cc
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRacyUndefer.cpp
@@ -0,0 +1,115 @@
+#include "base/basictypes.h"
+
+#include "TestRacyUndefer.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestRacyUndeferParent::TestRacyUndeferParent()
+{
+    MOZ_COUNT_CTOR(TestRacyUndeferParent);
+}
+
+TestRacyUndeferParent::~TestRacyUndeferParent()
+{
+    MOZ_COUNT_DTOR(TestRacyUndeferParent);
+}
+
+void
+TestRacyUndeferParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+bool
+TestRacyUndeferParent::AnswerSpam()
+{
+    static bool spammed = false;
+    static bool raced = false;
+    if (!spammed) {
+        spammed = true;
+
+        if (!SendAwakenSpam())
+            fail("sending AwakenSpam");
+    }
+    else if (!raced) {
+        raced = true;
+
+        if (!SendAwakenRaceWinTwice())
+            fail("sending WinRaceTwice");
+
+        if (!CallRace())
+            fail("calling Race1");
+    }
+    return true;
+}
+
+bool
+TestRacyUndeferParent::AnswerRaceWinTwice()
+{
+    return true;
+}
+
+bool
+TestRacyUndeferParent::RecvDone()
+{
+    Close();
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+TestRacyUndeferChild::TestRacyUndeferChild()
+{
+    MOZ_COUNT_CTOR(TestRacyUndeferChild);
+}
+
+TestRacyUndeferChild::~TestRacyUndeferChild()
+{
+    MOZ_COUNT_DTOR(TestRacyUndeferChild);
+}
+
+bool
+TestRacyUndeferChild::RecvStart()
+{
+    if (!CallSpam())
+        fail("calling Spam");
+
+    if (!SendDone())
+        fail("sending Done");
+
+    return true;
+}
+
+bool
+TestRacyUndeferChild::RecvAwakenSpam()
+{
+    if (!CallSpam())
+        fail("calling Spam");
+    return true;
+}
+
+bool
+TestRacyUndeferChild::RecvAwakenRaceWinTwice()
+{
+    if (!CallRaceWinTwice())
+        fail("calling RaceWinTwice");
+    return true;
+}
+
+bool
+TestRacyUndeferChild::AnswerRace()
+{
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestRacyUndefer.h b/ipc/ipdl/test/cxx/TestRacyUndefer.h
new file mode 100644
index 000000000..eee06a86c
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestRacyUndefer.h
@@ -0,0 +1,70 @@
+#ifndef mozilla__ipdltest_TestRacyUndefer_h
+#define mozilla__ipdltest_TestRacyUndefer_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestRacyUndeferParent.h"
+#include "mozilla/_ipdltest/PTestRacyUndeferChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestRacyUndeferParent :
+    public PTestRacyUndeferParent
+{
+public:
+    TestRacyUndeferParent();
+    virtual ~TestRacyUndeferParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual bool AnswerSpam() override;
+
+    virtual bool AnswerRaceWinTwice() override;
+
+    virtual bool RecvDone() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestRacyUndeferChild :
+    public PTestRacyUndeferChild
+{
+public:
+    TestRacyUndeferChild();
+    virtual ~TestRacyUndeferChild();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual bool RecvAwakenSpam() override;
+    virtual bool RecvAwakenRaceWinTwice() override;
+
+    virtual bool AnswerRace() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestRacyUndefer_h
diff --git a/ipc/ipdl/test/cxx/TestSanity.cpp b/ipc/ipdl/test/cxx/TestSanity.cpp
new file mode 100644
index 000000000..64ffceed6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSanity.cpp
@@ -0,0 +1,75 @@
+#include "TestSanity.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestSanityParent::TestSanityParent()
+{
+    MOZ_COUNT_CTOR(TestSanityParent);
+}
+
+TestSanityParent::~TestSanityParent()
+{
+    MOZ_COUNT_DTOR(TestSanityParent);
+}
+
+void
+TestSanityParent::Main()
+{
+    if (!SendPing(0, 0.5f, 0))
+        fail("sending Ping");
+}
+
+
+bool
+TestSanityParent::RecvPong(const int& one, const float& zeroPtTwoFive,
+                           const uint8_t&/*unused*/)
+{
+    if (1 != one)
+        fail("invalid argument `%d', should have been `1'", one);
+
+    if (0.25f != zeroPtTwoFive)
+        fail("invalid argument `%g', should have been `0.25'", zeroPtTwoFive);
+
+    Close();
+
+    return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+TestSanityChild::TestSanityChild()
+{
+    MOZ_COUNT_CTOR(TestSanityChild);
+}
+
+TestSanityChild::~TestSanityChild()
+{
+    MOZ_COUNT_DTOR(TestSanityChild);
+}
+
+bool
+TestSanityChild::RecvPing(const int& zero, const float& zeroPtFive,
+                          const int8_t&/*unused*/)
+{
+    if (0 != zero)
+        fail("invalid argument `%d', should have been `0'", zero);
+
+    if (0.5f != zeroPtFive)
+        fail("invalid argument `%g', should have been `0.5'", zeroPtFive);
+
+    if (!SendPong(1, 0.25f, 0))
+        fail("sending Pong");
+    return true;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestSanity.h b/ipc/ipdl/test/cxx/TestSanity.h
new file mode 100644
index 000000000..6e5b8cb59
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSanity.h
@@ -0,0 +1,63 @@
+#ifndef mozilla__ipdltest_TestSanity_h
+#define mozilla__ipdltest_TestSanity_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestSanityParent.h"
+#include "mozilla/_ipdltest/PTestSanityChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestSanityParent :
+    public PTestSanityParent
+{
+public:
+    TestSanityParent();
+    virtual ~TestSanityParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual bool RecvPong(const int& one, const float& zeroPtTwoFive,
+                          const uint8_t& dummy) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestSanityChild :
+    public PTestSanityChild
+{
+public:
+    TestSanityChild();
+    virtual ~TestSanityChild();
+
+protected:
+    virtual bool RecvPing(const int& zero, const float& zeroPtFive,
+                          const int8_t& dummy) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestSanity_h
diff --git a/ipc/ipdl/test/cxx/TestSelfManageRoot.cpp b/ipc/ipdl/test/cxx/TestSelfManageRoot.cpp
new file mode 100644
index 000000000..e8b2330ba
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSelfManageRoot.cpp
@@ -0,0 +1,63 @@
+#include "TestSelfManageRoot.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+#define ASSERT(c)                               \
+    do {                                        \
+        if (!(c))                               \
+            fail(#c);                           \
+    } while (0)
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+void
+TestSelfManageRootParent::Main()
+{
+    TestSelfManageParent* a =
+        static_cast<TestSelfManageParent*>(SendPTestSelfManageConstructor());
+    if (!a)
+        fail("constructing PTestSelfManage");
+
+    ASSERT(1 == ManagedPTestSelfManageParent().Count());
+
+    TestSelfManageParent* aa =
+        static_cast<TestSelfManageParent*>(a->SendPTestSelfManageConstructor());
+    if (!aa)
+        fail("constructing PTestSelfManage");
+
+    ASSERT(1 == ManagedPTestSelfManageParent().Count() &&
+           1 == a->ManagedPTestSelfManageParent().Count());
+
+    if (!PTestSelfManageParent::Send__delete__(aa))
+        fail("destroying PTestSelfManage");
+    ASSERT(Deletion == aa->mWhy &&
+           1 == ManagedPTestSelfManageParent().Count() &&
+           0 == a->ManagedPTestSelfManageParent().Count());
+    delete aa;
+
+    aa =
+        static_cast<TestSelfManageParent*>(a->SendPTestSelfManageConstructor());
+    if (!aa)
+        fail("constructing PTestSelfManage");
+
+    ASSERT(1 == ManagedPTestSelfManageParent().Count() &&
+           1 == a->ManagedPTestSelfManageParent().Count());
+
+    if (!PTestSelfManageParent::Send__delete__(a))
+        fail("destroying PTestSelfManage");
+    ASSERT(Deletion == a->mWhy &&
+           AncestorDeletion == aa->mWhy &&
+           0 == ManagedPTestSelfManageParent().Count() &&
+           0 == a->ManagedPTestSelfManageParent().Count());
+    delete a;
+    delete aa;
+
+    Close();
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestSelfManageRoot.h b/ipc/ipdl/test/cxx/TestSelfManageRoot.h
new file mode 100644
index 000000000..2a94fa392
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSelfManageRoot.h
@@ -0,0 +1,141 @@
+#ifndef mozilla__ipdltest_TestSelfManageRoot_h
+#define mozilla__ipdltest_TestSelfManageRoot_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestSelfManageRootParent.h"
+#include "mozilla/_ipdltest/PTestSelfManageRootChild.h"
+#include "mozilla/_ipdltest/PTestSelfManageParent.h"
+#include "mozilla/_ipdltest/PTestSelfManageChild.h"
+
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Parent side
+
+class TestSelfManageParent :
+    public PTestSelfManageParent
+{
+public:
+    TestSelfManageParent() {
+        MOZ_COUNT_CTOR(TestSelfManageParent);
+    }
+    virtual ~TestSelfManageParent() {
+        MOZ_COUNT_DTOR(TestSelfManageParent);
+    }
+
+    ActorDestroyReason mWhy;
+
+protected:    
+    virtual PTestSelfManageParent* AllocPTestSelfManageParent() override {
+        return new TestSelfManageParent();
+    }
+
+    virtual bool DeallocPTestSelfManageParent(PTestSelfManageParent* a) override {
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override {
+        mWhy = why;
+    }
+};
+
+class TestSelfManageRootParent :
+    public PTestSelfManageRootParent
+{
+public:
+    TestSelfManageRootParent() {
+        MOZ_COUNT_CTOR(TestSelfManageRootParent);
+    }
+    virtual ~TestSelfManageRootParent() {
+        MOZ_COUNT_DTOR(TestSelfManageRootParent);
+    }
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual PTestSelfManageParent* AllocPTestSelfManageParent() override {
+        return new TestSelfManageParent();
+    }
+
+    virtual bool DeallocPTestSelfManageParent(PTestSelfManageParent* a) override {
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+//-----------------------------------------------------------------------------
+// Child side
+
+class TestSelfManageChild :
+    public PTestSelfManageChild
+{
+public:
+    TestSelfManageChild() {
+        MOZ_COUNT_CTOR(TestSelfManageChild);
+    }
+    virtual ~TestSelfManageChild() {
+        MOZ_COUNT_DTOR(TestSelfManageChild);
+    }
+
+protected:    
+    virtual PTestSelfManageChild* AllocPTestSelfManageChild() override {
+        return new TestSelfManageChild();
+    }
+
+    virtual bool DeallocPTestSelfManageChild(PTestSelfManageChild* a) override {
+        delete a;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override { }
+};
+
+class TestSelfManageRootChild :
+    public PTestSelfManageRootChild
+{
+public:
+    TestSelfManageRootChild() {
+        MOZ_COUNT_CTOR(TestSelfManageRootChild);
+    }
+    virtual ~TestSelfManageRootChild() {
+        MOZ_COUNT_DTOR(TestSelfManageRootChild);
+    }
+
+    void Main();
+
+protected:    
+    virtual PTestSelfManageChild* AllocPTestSelfManageChild() override {
+        return new TestSelfManageChild();
+    }
+
+    virtual bool DeallocPTestSelfManageChild(PTestSelfManageChild* a) override {
+        delete a;
+        return true;
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        QuitChild();
+    }
+};
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestSelfManageRoot_h
diff --git a/ipc/ipdl/test/cxx/TestShmem.cpp b/ipc/ipdl/test/cxx/TestShmem.cpp
new file mode 100644
index 000000000..1ff62bc3a
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestShmem.cpp
@@ -0,0 +1,115 @@
+#include "TestShmem.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Parent
+
+void
+TestShmemParent::Main()
+{
+    Shmem mem;
+    Shmem unsafe;
+
+    size_t size = 12345;
+    if (!AllocShmem(size, SharedMemory::TYPE_BASIC, &mem))
+        fail("can't alloc shmem");
+    if (!AllocUnsafeShmem(size, SharedMemory::TYPE_BASIC, &unsafe))
+        fail("can't alloc shmem");
+
+    if (mem.Size<char>() != size)
+        fail("shmem is wrong size: expected %lu, got %lu",
+             size, mem.Size<char>());
+    if (unsafe.Size<char>() != size)
+        fail("shmem is wrong size: expected %lu, got %lu",
+             size, unsafe.Size<char>());
+
+    char* ptr = mem.get<char>();
+    memcpy(ptr, "Hello!", sizeof("Hello!"));
+
+    char* unsafeptr = unsafe.get<char>();
+    memcpy(unsafeptr, "Hello!", sizeof("Hello!"));
+
+    Shmem unsafecopy = unsafe;
+    if (!SendGive(mem, unsafe, size))
+        fail("can't send Give()");
+
+    // uncomment the following line for a (nondeterministic) surprise!
+    //char c1 = *ptr;  (void)c1;
+
+    // uncomment the following line for a deterministic surprise!
+    //char c2 = *mem.get<char>(); (void)c2;
+
+    // unsafe shmem gets rid of those checks
+    char uc1 = *unsafeptr;  (void)uc1;
+    char uc2 = *unsafecopy.get<char>(); (void)uc2;
+}
+
+
+bool
+TestShmemParent::RecvTake(Shmem&& mem, Shmem&& unsafe,
+                          const size_t& expectedSize)
+{
+    if (mem.Size<char>() != expectedSize)
+        fail("expected shmem size %lu, but it has size %lu",
+             expectedSize, mem.Size<char>());
+    if (unsafe.Size<char>() != expectedSize)
+        fail("expected shmem size %lu, but it has size %lu",
+             expectedSize, unsafe.Size<char>());
+
+    if (strcmp(mem.get<char>(), "And yourself!"))
+        fail("expected message was not written");
+    if (strcmp(unsafe.get<char>(), "And yourself!"))
+        fail("expected message was not written");
+
+    if (!DeallocShmem(mem))
+        fail("DeallocShmem");
+    if (!DeallocShmem(unsafe))
+        fail("DeallocShmem");
+
+    Close();
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// Child
+
+bool
+TestShmemChild::RecvGive(Shmem&& mem, Shmem&& unsafe, const size_t& expectedSize)
+{
+    if (mem.Size<char>() != expectedSize)
+        fail("expected shmem size %lu, but it has size %lu",
+             expectedSize, mem.Size<char>());
+    if (unsafe.Size<char>() != expectedSize)
+        fail("expected shmem size %lu, but it has size %lu",
+             expectedSize, unsafe.Size<char>());
+
+    if (strcmp(mem.get<char>(), "Hello!"))
+        fail("expected message was not written");
+    if (strcmp(unsafe.get<char>(), "Hello!"))
+        fail("expected message was not written");
+
+    char* unsafeptr = unsafe.get<char>();
+
+    memcpy(mem.get<char>(), "And yourself!", sizeof("And yourself!"));
+    memcpy(unsafeptr, "And yourself!", sizeof("And yourself!"));
+
+    Shmem unsafecopy = unsafe;
+    if (!SendTake(mem, unsafe, expectedSize))
+        fail("can't send Take()");
+
+    // these checks also shouldn't fail in the child
+    char uc1 = *unsafeptr;  (void)uc1;
+    char uc2 = *unsafecopy.get<char>(); (void)uc2;
+
+    return true;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestShmem.h b/ipc/ipdl/test/cxx/TestShmem.h
new file mode 100644
index 000000000..d583fe978
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestShmem.h
@@ -0,0 +1,66 @@
+#ifndef mozilla__ipdltest_TestShmem_h
+#define mozilla__ipdltest_TestShmem_h
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestShmemParent.h"
+#include "mozilla/_ipdltest/PTestShmemChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestShmemParent :
+    public PTestShmemParent
+{
+public:
+    TestShmemParent() { }
+    virtual ~TestShmemParent() { }
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool RecvTake(
+            Shmem&& mem,
+            Shmem&& unsafe,
+            const size_t& expectedSize) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestShmemChild :
+    public PTestShmemChild
+{
+public:
+    TestShmemChild() { }
+    virtual ~TestShmemChild() { }
+
+protected:
+    virtual bool RecvGive(
+            Shmem&& mem,
+            Shmem&& unsafe,
+            const size_t& expectedSize) override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+#endif // ifndef mozilla__ipdltest_TestShmem_h
diff --git a/ipc/ipdl/test/cxx/TestShutdown.cpp b/ipc/ipdl/test/cxx/TestShutdown.cpp
new file mode 100644
index 000000000..95a242bff
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestShutdown.cpp
@@ -0,0 +1,235 @@
+#include "TestShutdown.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Parent side
+void
+TestShutdownParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start()");
+}
+
+void
+TestShutdownParent::ActorDestroy(ActorDestroyReason why)
+{
+    if (AbnormalShutdown != why)
+        fail("should have ended test with crash!");
+
+    passed("ok");
+
+    QuitParent();
+}
+
+void
+TestShutdownSubParent::ActorDestroy(ActorDestroyReason why)
+{
+    if (Manager()->ManagedPTestShutdownSubParent().Count() == 0)
+        fail("manager should still have managees!");
+
+    if (mExpectCrash && AbnormalShutdown != why)
+        fail("expected crash!");
+    else if (!mExpectCrash && AbnormalShutdown == why)
+        fail("wasn't expecting crash!");
+
+    if (mExpectCrash && 0 == ManagedPTestShutdownSubsubParent().Count())
+        fail("expected to *still* have kids");
+}
+
+void
+TestShutdownSubsubParent::ActorDestroy(ActorDestroyReason why)
+{
+    if (Manager()->ManagedPTestShutdownSubsubParent().Count() == 0)
+        fail("manager should still have managees!");
+
+    if (mExpectParentDeleted && AncestorDeletion != why)
+        fail("expected ParentDeleted == why");
+    else if (!mExpectParentDeleted && AncestorDeletion == why)
+        fail("wasn't expecting parent delete");
+}
+
+//-----------------------------------------------------------------------------
+// Child side
+
+bool
+TestShutdownChild::RecvStart()
+{
+    // test 1: alloc some actors and subactors, delete in
+    // managee-before-manager order
+    {
+        bool expectCrash = false, expectParentDeleted = false;
+
+        PTestShutdownSubChild* c1 =
+            SendPTestShutdownSubConstructor(expectCrash);
+        if (!c1)
+            fail("problem sending ctor");
+
+        PTestShutdownSubChild* c2 =
+            SendPTestShutdownSubConstructor(expectCrash);
+        if (!c2)
+            fail("problem sending ctor");
+
+        PTestShutdownSubsubChild* c1s1 =
+            c1->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c1s1)
+            fail("problem sending ctor");
+        PTestShutdownSubsubChild* c1s2 =
+            c1->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c1s2)
+            fail("problem sending ctor");
+
+        PTestShutdownSubsubChild* c2s1 =
+            c2->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c2s1)
+            fail("problem sending ctor");
+        PTestShutdownSubsubChild* c2s2 =
+            c2->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c2s2)
+            fail("problem sending ctor");
+
+        if (!PTestShutdownSubsubChild::Send__delete__(c1s1))
+            fail("problem sending dtor");
+        if (!PTestShutdownSubsubChild::Send__delete__(c1s2))
+            fail("problem sending dtor");
+        if (!PTestShutdownSubsubChild::Send__delete__(c2s1))
+            fail("problem sending dtor");
+        if (!PTestShutdownSubsubChild::Send__delete__(c2s2))
+            fail("problem sending dtor");
+
+        if (!c1->CallStackFrame())
+            fail("problem creating dummy stack frame");
+        if (!c2->CallStackFrame())
+            fail("problem creating dummy stack frame");
+    }
+
+    // test 2: alloc some actors and subactors, delete managers first
+    {
+        bool expectCrash = false, expectParentDeleted = true;
+
+        PTestShutdownSubChild* c1 =
+            SendPTestShutdownSubConstructor(expectCrash);
+        if (!c1)
+            fail("problem sending ctor");
+
+        PTestShutdownSubChild* c2 =
+            SendPTestShutdownSubConstructor(expectCrash);
+        if (!c2)
+            fail("problem sending ctor");
+
+        PTestShutdownSubsubChild* c1s1 =
+            c1->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c1s1)
+            fail("problem sending ctor");
+        PTestShutdownSubsubChild* c1s2 =
+            c1->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c1s2)
+            fail("problem sending ctor");
+
+        PTestShutdownSubsubChild* c2s1 =
+            c2->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c2s1)
+            fail("problem sending ctor");
+        PTestShutdownSubsubChild* c2s2 =
+            c2->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c2s2)
+            fail("problem sending ctor");
+
+        // delete parents without deleting kids
+        if (!c1->CallStackFrame())
+            fail("problem creating dummy stack frame");
+        if (!c2->CallStackFrame())
+            fail("problem creating dummy stack frame");
+    }
+
+    // test 3: alloc some actors and subactors, then crash
+    {
+        bool expectCrash = true, expectParentDeleted = false;
+
+        PTestShutdownSubChild* c1 =
+            SendPTestShutdownSubConstructor(expectCrash);
+        if (!c1)
+            fail("problem sending ctor");
+
+        PTestShutdownSubChild* c2 =
+            SendPTestShutdownSubConstructor(expectCrash);
+        if (!c2)
+            fail("problem sending ctor");
+
+        PTestShutdownSubsubChild* c1s1 =
+            c1->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c1s1)
+            fail("problem sending ctor");
+        PTestShutdownSubsubChild* c1s2 =
+            c1->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c1s2)
+            fail("problem sending ctor");
+
+        PTestShutdownSubsubChild* c2s1 =
+            c2->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c2s1)
+            fail("problem sending ctor");
+        PTestShutdownSubsubChild* c2s2 =
+            c2->SendPTestShutdownSubsubConstructor(expectParentDeleted);
+        if (!c2s2)
+            fail("problem sending ctor");
+
+        // make sure the ctors have been processed by the other side;
+        // the write end of the socket may temporarily be unwriteable
+        if (!SendSync())
+            fail("can't synchronize with parent");
+
+        // "crash", but without tripping tinderbox assert/abort
+        // detectors
+        _exit(0);
+    }
+}
+
+void
+TestShutdownChild::ActorDestroy(ActorDestroyReason why)
+{
+    fail("hey wait ... we should have crashed!");
+}
+
+bool
+TestShutdownSubChild::AnswerStackFrame()
+{
+    if (!PTestShutdownSubChild::Send__delete__(this))
+        fail("problem sending dtor");
+
+    // WATCH OUT!  |this| has just deleted
+
+    return true;
+}
+
+void
+TestShutdownSubChild::ActorDestroy(ActorDestroyReason why)
+{
+    if (Manager()->ManagedPTestShutdownSubChild().Count() == 0)
+        fail("manager should still have managees!");
+
+    if (mExpectCrash && AbnormalShutdown != why)
+        fail("expected crash!");
+    else if (!mExpectCrash && AbnormalShutdown == why)
+        fail("wasn't expecting crash!");
+
+    if (mExpectCrash && 0 == ManagedPTestShutdownSubsubChild().Count())
+        fail("expected to *still* have kids");
+}
+
+void
+TestShutdownSubsubChild::ActorDestroy(ActorDestroyReason why)
+{
+    if (Manager()->ManagedPTestShutdownSubsubChild().Count() == 0)
+        fail("manager should still have managees!");
+
+    if (mExpectParentDeleted && AncestorDeletion != why)
+        fail("expected ParentDeleted == why");
+    else if (!mExpectParentDeleted && AncestorDeletion == why)
+        fail("wasn't expecting parent delete");
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestShutdown.h b/ipc/ipdl/test/cxx/TestShutdown.h
new file mode 100644
index 000000000..c79cbb8fc
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestShutdown.h
@@ -0,0 +1,225 @@
+#ifndef mozilla__ipdltest_TestShutdown_h
+#define mozilla__ipdltest_TestShutdown_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestShutdownParent.h"
+#include "mozilla/_ipdltest/PTestShutdownChild.h"
+
+#include "mozilla/_ipdltest/PTestShutdownSubParent.h"
+#include "mozilla/_ipdltest/PTestShutdownSubChild.h"
+
+#include "mozilla/_ipdltest/PTestShutdownSubsubParent.h"
+#include "mozilla/_ipdltest/PTestShutdownSubsubChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// Parent side
+
+class TestShutdownSubsubParent :
+    public PTestShutdownSubsubParent
+{
+public:
+    explicit TestShutdownSubsubParent(bool expectParentDeleted) :
+        mExpectParentDeleted(expectParentDeleted)
+    {
+    }
+
+    virtual ~TestShutdownSubsubParent()
+    {
+    }
+
+protected:
+    virtual void
+    ActorDestroy(ActorDestroyReason why) override;
+
+private:
+    bool mExpectParentDeleted;
+};
+
+
+class TestShutdownSubParent :
+    public PTestShutdownSubParent
+{
+public:
+    explicit TestShutdownSubParent(bool expectCrash) :
+        mExpectCrash(expectCrash),
+        mDeletedCount(0)
+    {
+    }
+
+    virtual ~TestShutdownSubParent()
+    {
+        if (2 != mDeletedCount)
+            fail("managees outliving manager!");
+    }
+
+protected:
+    virtual bool
+    AnswerStackFrame() override
+    {
+        return CallStackFrame();
+    }
+
+    virtual PTestShutdownSubsubParent*
+    AllocPTestShutdownSubsubParent(const bool& expectParentDelete) override
+    {
+        return new TestShutdownSubsubParent(expectParentDelete);
+    }
+
+    virtual bool
+    DeallocPTestShutdownSubsubParent(PTestShutdownSubsubParent* actor) override
+    {
+        delete actor;
+        ++mDeletedCount;
+        return true;
+    }
+
+    virtual void
+    ActorDestroy(ActorDestroyReason why) override;
+
+private:
+    bool mExpectCrash;
+    int mDeletedCount;
+};
+
+
+class TestShutdownParent :
+    public PTestShutdownParent
+{
+public:
+    TestShutdownParent()
+    {
+    }
+    virtual ~TestShutdownParent()
+    {
+    }
+
+    static bool RunTestInProcesses() { return true; }
+    // FIXME/bug 703323 Could work if modified
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:
+    virtual bool RecvSync() override { return true; }
+
+    virtual PTestShutdownSubParent*
+    AllocPTestShutdownSubParent(const bool& expectCrash) override
+    {
+        return new TestShutdownSubParent(expectCrash);
+    }
+
+    virtual bool
+    DeallocPTestShutdownSubParent(PTestShutdownSubParent* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void
+    ActorDestroy(ActorDestroyReason why) override;
+};
+
+
+//-----------------------------------------------------------------------------
+// Child side
+
+class TestShutdownSubsubChild :
+    public PTestShutdownSubsubChild
+{
+public:
+    explicit TestShutdownSubsubChild(bool expectParentDeleted) :
+        mExpectParentDeleted(expectParentDeleted)
+    {
+    }
+    virtual ~TestShutdownSubsubChild()
+    {
+    }
+
+protected:
+    virtual void
+    ActorDestroy(ActorDestroyReason why) override;
+
+private:
+    bool mExpectParentDeleted;
+};
+
+
+class TestShutdownSubChild :
+    public PTestShutdownSubChild
+{
+public:
+    explicit TestShutdownSubChild(bool expectCrash) : mExpectCrash(expectCrash)
+    {
+    }
+
+    virtual ~TestShutdownSubChild()
+    {
+    }
+
+protected:
+    virtual bool AnswerStackFrame() override;
+
+    virtual PTestShutdownSubsubChild*
+    AllocPTestShutdownSubsubChild(const bool& expectParentDelete) override
+    {
+        return new TestShutdownSubsubChild(expectParentDelete);
+    }
+
+    virtual bool
+    DeallocPTestShutdownSubsubChild(PTestShutdownSubsubChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void
+    ActorDestroy(ActorDestroyReason why) override;
+
+private:
+    bool mExpectCrash;
+};
+
+
+class TestShutdownChild :
+    public PTestShutdownChild
+{
+public:
+    TestShutdownChild()
+    {
+    }
+    virtual ~TestShutdownChild()
+    {
+    }
+
+protected:
+    virtual bool
+    RecvStart();
+
+    virtual PTestShutdownSubChild*
+    AllocPTestShutdownSubChild(
+        const bool& expectCrash) override
+    {
+        return new TestShutdownSubChild(expectCrash);
+    }
+
+    virtual bool
+    DeallocPTestShutdownSubChild(PTestShutdownSubChild* actor) override
+    {
+        delete actor;
+        return true;
+    }
+
+    virtual void
+    ActorDestroy(ActorDestroyReason why) override;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestShutdown_h
diff --git a/ipc/ipdl/test/cxx/TestStackHooks.cpp b/ipc/ipdl/test/cxx/TestStackHooks.cpp
new file mode 100644
index 000000000..b4181985c
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestStackHooks.cpp
@@ -0,0 +1,168 @@
+#include "TestStackHooks.h"
+
+#include "base/task.h"
+#include "IPDLUnitTests.h"      // fail etc.
+
+
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestStackHooksParent::TestStackHooksParent() :
+    mOnStack(false), mIncallDepth(0)
+{
+    MOZ_COUNT_CTOR(TestStackHooksParent);
+}
+
+TestStackHooksParent::~TestStackHooksParent()
+{
+    MOZ_COUNT_DTOR(TestStackHooksParent);
+}
+
+void
+TestStackHooksParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start()");
+}
+
+
+bool
+TestStackHooksParent::AnswerStackFrame()
+{
+    if (!mOnStack)
+        fail("not on C++ stack?!");
+
+    if (!CallStackFrame())
+        fail("calling StackFrame()");
+
+    if (!mOnStack)
+        fail("not on C++ stack?!");
+
+    if (1 != mIncallDepth)
+        fail("missed EnteredCall or ExitedCall hook");
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestStackHooksChild::TestStackHooksChild() :
+    mOnStack(false),
+    mEntered(0),
+    mExited(0),
+    mIncallDepth(0)
+{
+    MOZ_COUNT_CTOR(TestStackHooksChild);
+}
+
+TestStackHooksChild::~TestStackHooksChild()
+{
+    MOZ_COUNT_DTOR(TestStackHooksChild);
+}
+
+namespace {
+void RunTestsFn() {
+    static_cast<TestStackHooksChild*>(gChildActor)->RunTests();
+}
+}
+
+bool
+TestStackHooksChild::RecvStart()
+{
+    if (!mOnStack)
+        fail("missed stack notification");
+
+    if (0 != mIncallDepth)
+        fail("EnteredCall/ExitedCall malfunction");
+
+    // kick off tests from a runnable so that we can start with
+    // MessageChannel code on the C++ stack
+    MessageLoop::current()->PostTask(NewRunnableFunction(RunTestsFn));
+
+    return true;
+}
+
+bool
+TestStackHooksChild::AnswerStackFrame()
+{
+    if (!mOnStack)
+        fail("missed stack notification");
+
+    if (1 != mIncallDepth)
+        fail("missed EnteredCall or ExitedCall hook");
+
+    if (PTestStackHooks::TEST4_3 == state()) {
+        if (!SendAsync())
+            fail("sending Async()");
+    }
+    else if (PTestStackHooks::TEST5_3 == state()) {
+        if (!SendSync())
+            fail("sending Sync()");
+    }
+    else {
+        fail("unexpected state");
+    }
+
+    if (!mOnStack)
+        fail("bad stack exit notification");
+
+    return true;
+}
+
+void
+TestStackHooksChild::RunTests()
+{
+    // 1 because of RecvStart()
+    if (1 != mEntered)
+        fail("missed stack notification");
+    if (mOnStack)
+        fail("spurious stack notification");
+    if (0 != mIncallDepth)
+        fail("EnteredCall/ExitedCall malfunction");
+
+    if (!SendAsync())
+        fail("sending Async()");
+    if (mOnStack)
+        fail("spurious stack notification");
+    if (0 != mIncallDepth)
+        fail("EnteredCall/ExitedCall malfunction");
+    if (2 != mEntered)
+        fail("missed stack notification");
+
+    if (!SendSync())
+        fail("sending Sync()");
+    if (mOnStack)
+        fail("spurious stack notification");
+    if (0 != mIncallDepth)
+        fail("EnteredCall/ExitedCall malfunction");
+    if (3 != mEntered)
+        fail("missed stack notification");
+
+    if (!CallRpc())
+        fail("calling RPC()");
+    if (mOnStack)
+        fail("spurious stack notification");
+    if (0 != mIncallDepth)
+        fail("EnteredCall/ExitedCall malfunction");
+    if (4 != mEntered)
+        fail("missed stack notification");
+
+    if (!CallStackFrame())
+        fail("calling StackFrame()");
+    if (mOnStack)
+        fail("spurious stack notification");
+    if (0 != mIncallDepth)
+        fail("EnteredCall/ExitedCall malfunction");
+    if (5 != mEntered)
+        fail("missed stack notification");
+
+    Close();
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestStackHooks.h b/ipc/ipdl/test/cxx/TestStackHooks.h
new file mode 100644
index 000000000..c26d5f937
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestStackHooks.h
@@ -0,0 +1,130 @@
+#ifndef mozilla__ipdltest_TestStackHooks_h
+#define mozilla__ipdltest_TestStackHooks_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestStackHooksParent.h"
+#include "mozilla/_ipdltest/PTestStackHooksChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestStackHooksParent :
+    public PTestStackHooksParent
+{
+public:
+    TestStackHooksParent();
+    virtual ~TestStackHooksParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual bool RecvAsync() override {
+        if (!mOnStack)
+            fail("not on C++ stack?!");
+        return true;
+    }
+
+    virtual bool RecvSync() override {
+        if (!mOnStack)
+            fail("not on C++ stack?!");
+        return true;
+    }
+
+    virtual bool AnswerRpc() override {
+        if (!mOnStack)
+            fail("not on C++ stack?!");
+        return true;
+    }
+
+    virtual bool AnswerStackFrame() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+
+    virtual void EnteredCxxStack() override {
+        mOnStack = true;
+    }
+    virtual void ExitedCxxStack() override {
+        mOnStack = false;
+    }
+
+    virtual void EnteredCall() override {
+        ++mIncallDepth;
+    }
+    virtual void ExitedCall() override {
+        --mIncallDepth;
+    }
+
+private:
+    bool mOnStack;
+    int mIncallDepth;
+};
+
+
+class TestStackHooksChild :
+    public PTestStackHooksChild
+{
+public:
+    TestStackHooksChild();
+    virtual ~TestStackHooksChild();
+
+    void RunTests();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual bool AnswerStackFrame() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+
+        if (mEntered != mExited)
+            fail("unbalanced enter/exit notifications");
+
+        if (mOnStack)
+            fail("computing mOnStack went awry; should have failed above assertion");
+
+        QuitChild();
+    }
+
+    virtual void EnteredCxxStack() override {
+        ++mEntered;
+        mOnStack = true;
+    }
+    virtual void ExitedCxxStack() override {
+        ++mExited;
+        mOnStack = false;
+    }
+
+    virtual void EnteredCall() override {
+        ++mIncallDepth;
+    }
+    virtual void ExitedCall() override {
+        --mIncallDepth;
+    }
+
+private:
+    bool mOnStack;
+    int mEntered;
+    int mExited;
+    int mIncallDepth;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestStackHooks_h
diff --git a/ipc/ipdl/test/cxx/TestSyncError.cpp b/ipc/ipdl/test/cxx/TestSyncError.cpp
new file mode 100644
index 000000000..b9d8ec938
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSyncError.cpp
@@ -0,0 +1,61 @@
+#include "TestSyncError.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestSyncErrorParent::TestSyncErrorParent()
+{
+    MOZ_COUNT_CTOR(TestSyncErrorParent);
+}
+
+TestSyncErrorParent::~TestSyncErrorParent()
+{
+    MOZ_COUNT_DTOR(TestSyncErrorParent);
+}
+
+void
+TestSyncErrorParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start");
+}
+
+bool
+TestSyncErrorParent::RecvError()
+{
+    return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// child
+
+TestSyncErrorChild::TestSyncErrorChild()
+{
+    MOZ_COUNT_CTOR(TestSyncErrorChild);
+}
+
+TestSyncErrorChild::~TestSyncErrorChild()
+{
+    MOZ_COUNT_DTOR(TestSyncErrorChild);
+}
+
+bool
+TestSyncErrorChild::RecvStart()
+{
+    if (SendError())
+        fail("Error() should have return false");
+
+    Close();
+
+    return true;
+}
+
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestSyncError.h b/ipc/ipdl/test/cxx/TestSyncError.h
new file mode 100644
index 000000000..c39402a87
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSyncError.h
@@ -0,0 +1,71 @@
+#ifndef mozilla__ipdltest_TestSyncError_h
+#define mozilla__ipdltest_TestSyncError_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestSyncErrorParent.h"
+#include "mozilla/_ipdltest/PTestSyncErrorChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestSyncErrorParent :
+    public PTestSyncErrorParent
+{
+public:
+    TestSyncErrorParent();
+    virtual ~TestSyncErrorParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:    
+    virtual bool RecvError() override;
+
+    virtual void ProcessingError(Result aCode, const char* aReason) override
+    {
+        // Ignore errors
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestSyncErrorChild :
+    public PTestSyncErrorChild
+{
+public:
+    TestSyncErrorChild();
+    virtual ~TestSyncErrorChild();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual void ProcessingError(Result aCode, const char* aReason) override
+    {
+        // Ignore errors
+    }
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestSyncError_h
diff --git a/ipc/ipdl/test/cxx/TestSyncHang.cpp b/ipc/ipdl/test/cxx/TestSyncHang.cpp
new file mode 100644
index 000000000..62b9ae723
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSyncHang.cpp
@@ -0,0 +1,70 @@
+#include "TestSyncHang.h"
+#include "base/task.h"
+#include "mozilla/ipc/GeckoChildProcessHost.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+using std::vector;
+using std::string;
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+mozilla::ipc::GeckoChildProcessHost* gSyncHangSubprocess;
+
+TestSyncHangParent::TestSyncHangParent()
+{
+    MOZ_COUNT_CTOR(TestSyncHangParent);
+}
+
+TestSyncHangParent::~TestSyncHangParent()
+{
+    MOZ_COUNT_DTOR(TestSyncHangParent);
+}
+
+void
+DeleteSyncHangSubprocess(MessageLoop* uiLoop)
+{
+  delete gSyncHangSubprocess;
+}
+
+void
+DeferredSyncHangParentShutdown()
+{
+  // ping to DeleteSubprocess
+  XRE_GetIOMessageLoop()->PostTask(
+      NewRunnableFunction(DeleteSyncHangSubprocess, MessageLoop::current()));
+}
+
+void
+TestSyncHangParent::Main()
+{
+  vector<string> args;
+  args.push_back("fake/path");
+  gSyncHangSubprocess = new mozilla::ipc::GeckoChildProcessHost(GeckoProcessType_Plugin);
+  bool launched = gSyncHangSubprocess->SyncLaunch(args, 2);
+  if (launched)
+    fail("Calling SyncLaunch with an invalid path should return false");
+
+  MessageLoop::current()->PostTask(NewRunnableFunction(DeferredSyncHangParentShutdown));
+  Close();
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestSyncHangChild::TestSyncHangChild()
+{
+    MOZ_COUNT_CTOR(TestSyncHangChild);
+}
+
+TestSyncHangChild::~TestSyncHangChild()
+{
+    MOZ_COUNT_DTOR(TestSyncHangChild);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestSyncHang.h b/ipc/ipdl/test/cxx/TestSyncHang.h
new file mode 100644
index 000000000..87533d661
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSyncHang.h
@@ -0,0 +1,58 @@
+#ifndef mozilla__ipdltest_TestSyncHang_h
+#define mozilla__ipdltest_TestSyncHang_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestSyncHangParent.h"
+#include "mozilla/_ipdltest/PTestSyncHangChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestSyncHangParent :
+    public PTestSyncHangParent
+{
+public:
+    TestSyncHangParent();
+    virtual ~TestSyncHangParent();
+
+    static bool RunTestInProcesses() { return true; }
+    // FIXME/bug 703323 Could work if modified
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+protected:    
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestSyncHangChild :
+    public PTestSyncHangChild
+{
+public:
+    TestSyncHangChild();
+    virtual ~TestSyncHangChild();
+
+protected:
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestSyncHang_h
diff --git a/ipc/ipdl/test/cxx/TestSyncWakeup.cpp b/ipc/ipdl/test/cxx/TestSyncWakeup.cpp
new file mode 100644
index 000000000..cce0ca34f
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSyncWakeup.cpp
@@ -0,0 +1,134 @@
+#if defined(OS_POSIX)
+#include <unistd.h>             // sleep()
+#endif
+
+#include "TestSyncWakeup.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestSyncWakeupParent::TestSyncWakeupParent()
+{
+    MOZ_COUNT_CTOR(TestSyncWakeupParent);
+}
+
+TestSyncWakeupParent::~TestSyncWakeupParent()
+{
+    MOZ_COUNT_DTOR(TestSyncWakeupParent);
+}
+
+void
+TestSyncWakeupParent::Main()
+{
+    if (!SendStart())
+        fail("sending Start()");
+}
+
+bool
+TestSyncWakeupParent::AnswerStackFrame()
+{
+    if (!CallStackFrame())
+        fail("calling StackFrame()");
+    return true;
+}
+
+bool
+TestSyncWakeupParent::RecvSync1()
+{
+    if (!SendNote1())
+        fail("sending Note1()");
+
+    // XXX ugh ... need to ensure that the async message and sync
+    // reply come in "far enough" apart that this test doesn't pass on
+    // accident
+#if defined(OS_POSIX)
+    // NB: can't use PR_Sleep (i.e. Sleep() on windows) because it's
+    // only spec'd to block the current thread, not the current
+    // process.  We need the IO thread to sleep as well.
+    puts(" (sleeping for 5 seconds. sorry!)");
+    sleep(5);
+#endif
+
+    return true;
+}
+
+bool
+TestSyncWakeupParent::RecvSync2()
+{
+    if (!SendNote2())
+        fail("sending Note2()");
+
+#if defined(OS_POSIX)
+    // see above
+    sleep(5);
+    puts(" (sleeping for 5 seconds. sorry!)");
+#endif
+
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+TestSyncWakeupChild::TestSyncWakeupChild() : mDone(false)
+{
+    MOZ_COUNT_CTOR(TestSyncWakeupChild);
+}
+
+TestSyncWakeupChild::~TestSyncWakeupChild()
+{
+    MOZ_COUNT_DTOR(TestSyncWakeupChild);
+}
+
+bool
+TestSyncWakeupChild::RecvStart()
+{
+    // First test: the parent fires back an async message while
+    // replying to a sync one
+    if (!SendSync1())
+        fail("sending Sync()");
+
+    // drop back into the event loop to get Note1(), then kick off the
+    // second test
+    return true;
+}
+
+bool
+TestSyncWakeupChild::RecvNote1()
+{
+    // Second test: the parent fires back an async message while
+    // replying to a sync one, with a frame on the RPC stack
+    if (!CallStackFrame())
+        fail("calling StackFrame()");
+
+    if (!mDone)
+        fail("should have received Note2()!");
+
+    Close();
+
+    return true;
+}
+
+bool
+TestSyncWakeupChild::AnswerStackFrame()
+{
+    if (!SendSync2())
+        fail("sending Sync()");
+
+    return true;
+}
+
+bool
+TestSyncWakeupChild::RecvNote2()
+{
+    mDone = true;
+    return true;
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestSyncWakeup.h b/ipc/ipdl/test/cxx/TestSyncWakeup.h
new file mode 100644
index 000000000..dac3f4312
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestSyncWakeup.h
@@ -0,0 +1,74 @@
+#ifndef mozilla__ipdltest_TestSyncWakeup_h
+#define mozilla__ipdltest_TestSyncWakeup_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestSyncWakeupParent.h"
+#include "mozilla/_ipdltest/PTestSyncWakeupChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestSyncWakeupParent :
+    public PTestSyncWakeupParent
+{
+public:
+    TestSyncWakeupParent();
+    virtual ~TestSyncWakeupParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return true; }
+
+    void Main();
+
+protected:
+    virtual bool AnswerStackFrame() override;
+
+    virtual bool RecvSync1() override;
+
+    virtual bool RecvSync2() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");  
+        passed("ok");
+        QuitParent();
+    }
+};
+
+
+class TestSyncWakeupChild :
+    public PTestSyncWakeupChild
+{
+public:
+    TestSyncWakeupChild();
+    virtual ~TestSyncWakeupChild();
+
+protected:
+    virtual bool RecvStart() override;
+
+    virtual bool RecvNote1() override;
+
+    virtual bool AnswerStackFrame() override;
+
+    virtual bool RecvNote2() override;
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        if (NormalShutdown != why)
+            fail("unexpected destruction!");
+        QuitChild();
+    }
+
+private:
+    bool mDone;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestSyncWakeup_h
diff --git a/ipc/ipdl/test/cxx/TestUrgency.cpp b/ipc/ipdl/test/cxx/TestUrgency.cpp
new file mode 100644
index 000000000..b9b05bcea
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestUrgency.cpp
@@ -0,0 +1,162 @@
+#include "TestUrgency.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#if defined(OS_POSIX)
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+namespace mozilla {
+namespace _ipdltest {
+
+#if defined(OS_POSIX)
+static void Sleep(int ms)
+{
+    sleep(ms / 1000);
+}
+#endif
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestUrgencyParent::TestUrgencyParent()
+  : inreply_(false)
+{
+    MOZ_COUNT_CTOR(TestUrgencyParent);
+}
+
+TestUrgencyParent::~TestUrgencyParent()
+{
+    MOZ_COUNT_DTOR(TestUrgencyParent);
+}
+
+void
+TestUrgencyParent::Main()
+{
+  if (!SendStart())
+    fail("sending Start");
+}
+
+bool
+TestUrgencyParent::RecvTest1(uint32_t *value)
+{
+  if (!SendReply1(value))
+    fail("sending Reply1");
+  if (*value != 99)
+    fail("bad value");
+  return true;
+}
+
+bool
+TestUrgencyParent::RecvTest2()
+{
+  uint32_t value;
+  inreply_ = true;
+  if (!SendReply2(&value))
+    fail("sending Reply2");
+  inreply_ = false;
+  if (value != 500)
+    fail("bad value");
+  return true;
+}
+
+bool
+TestUrgencyParent::RecvTest3(uint32_t *value)
+{
+  if (inreply_)
+    fail("nested non-urgent on top of urgent rpc");
+  *value = 1000;
+  return true;
+}
+
+bool
+TestUrgencyParent::RecvFinalTest_Begin()
+{
+  return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+enum {
+  kFirstTestBegin = 1,
+  kFirstTestGotReply,
+  kSecondTestBegin,
+  kSecondTestGotReply,
+};
+
+bool
+TestUrgencyChild::RecvStart()
+{
+  uint32_t result;
+  
+  // Send a synchronous message, expect to get an urgent message while
+  // blocked.
+  test_ = kFirstTestBegin;
+  if (!SendTest1(&result))
+    fail("calling SendTest1");
+  if (result != 99)
+    fail("bad result in RecvStart");
+  if (test_ != kFirstTestGotReply)
+    fail("never received urgent message");
+
+  // Initiate the next test by sending an asynchronous message, then becoming
+  // blocked. This tests that the urgent message is still delivered properly,
+  // and that the parent does not try to service the sync 
+  test_ = kSecondTestBegin;
+  if (!SendTest2())
+    fail("calling SendTest2");
+  if (!SendTest3(&result))
+    fail("calling SendTest3");
+  if (test_ != kSecondTestGotReply)
+    fail("never received urgent message #2");
+  if (result != 1000)
+    fail("wrong value from test3");
+
+  if (!SendFinalTest_Begin())
+    fail("Final test should have succeeded");
+
+  Close();
+
+  return true;
+}
+
+bool
+TestUrgencyChild::RecvReply1(uint32_t *reply)
+{
+  if (test_ != kFirstTestBegin)
+    fail("wrong test # in RecvReply1");
+
+  *reply = 99;
+  test_ = kFirstTestGotReply;
+  return true;
+}
+
+bool
+TestUrgencyChild::RecvReply2(uint32_t *reply)
+{
+  if (test_ != kSecondTestBegin)
+    fail("wrong test # in RecvReply2");
+
+  // sleep for 5 seconds so the parent process tries to deliver more messages.
+  Sleep(5000);
+
+  *reply = 500;
+  test_ = kSecondTestGotReply;
+  return true;
+}
+
+TestUrgencyChild::TestUrgencyChild()
+  : test_(0)
+{
+    MOZ_COUNT_CTOR(TestUrgencyChild);
+}
+
+TestUrgencyChild::~TestUrgencyChild()
+{
+    MOZ_COUNT_DTOR(TestUrgencyChild);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestUrgency.h b/ipc/ipdl/test/cxx/TestUrgency.h
new file mode 100644
index 000000000..07a31b1c1
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestUrgency.h
@@ -0,0 +1,72 @@
+#ifndef mozilla__ipdltest_TestUrgency_h
+#define mozilla__ipdltest_TestUrgency_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestUrgencyParent.h"
+#include "mozilla/_ipdltest/PTestUrgencyChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestUrgencyParent :
+    public PTestUrgencyParent
+{
+public:
+    TestUrgencyParent();
+    virtual ~TestUrgencyParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+
+    bool RecvTest1(uint32_t *value);
+    bool RecvTest2();
+    bool RecvTest3(uint32_t *value);
+    bool RecvTest4_Begin();
+    bool RecvTest4_NestedSync();
+    bool RecvFinalTest_Begin();
+
+    bool ShouldContinueFromReplyTimeout() override
+    {
+      return false;
+    }
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    bool inreply_;
+};
+
+
+class TestUrgencyChild :
+    public PTestUrgencyChild
+{
+public:
+    TestUrgencyChild();
+    virtual ~TestUrgencyChild();
+
+    bool RecvStart();
+    bool RecvReply1(uint32_t *reply);
+    bool RecvReply2(uint32_t *reply);
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        QuitChild();
+    }
+
+private:
+    uint32_t test_;
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestUrgency_h
diff --git a/ipc/ipdl/test/cxx/TestUrgentHangs.cpp b/ipc/ipdl/test/cxx/TestUrgentHangs.cpp
new file mode 100644
index 000000000..b798ae18d
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestUrgentHangs.cpp
@@ -0,0 +1,217 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: sw=4 ts=4 et :
+ */
+#include "TestUrgentHangs.h"
+
+#include "IPDLUnitTests.h"      // fail etc.
+#include "prthread.h"
+#if defined(OS_POSIX)
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+namespace mozilla {
+namespace _ipdltest {
+
+//-----------------------------------------------------------------------------
+// parent
+
+TestUrgentHangsParent::TestUrgentHangsParent()
+  : mInnerCount(0),
+    mInnerUrgentCount(0)
+{
+    MOZ_COUNT_CTOR(TestUrgentHangsParent);
+}
+
+TestUrgentHangsParent::~TestUrgentHangsParent()
+{
+    MOZ_COUNT_DTOR(TestUrgentHangsParent);
+}
+
+void
+TestUrgentHangsParent::Main()
+{
+    SetReplyTimeoutMs(1000);
+
+    // Should succeed despite the nested sleep call because the content process
+    // responded to the transaction.
+    if (!SendTest1_1())
+        fail("sending Test1_1");
+
+    // Fails with a timeout.
+    if (SendTest2())
+        fail("sending Test2");
+
+    // Also fails since we haven't gotten a response for Test2 yet.
+    if (SendTest3())
+        fail("sending Test3");
+
+    // Do a second round of testing once the reply to Test2 comes back.
+    MessageLoop::current()->PostDelayedTask(
+        NewNonOwningRunnableMethod(this, &TestUrgentHangsParent::SecondStage),
+        3000);
+}
+
+void
+TestUrgentHangsParent::SecondStage()
+{
+    // Send an async message that waits 2 seconds and then sends a sync message
+    // (which should be processed).
+    if (!SendTest4())
+        fail("sending Test4");
+
+    // Send a sync message that will time out because the child is waiting
+    // inside RecvTest4.
+    if (SendTest4_1())
+        fail("sending Test4_1");
+
+    MessageLoop::current()->PostDelayedTask(
+        NewNonOwningRunnableMethod(this, &TestUrgentHangsParent::ThirdStage),
+        3000);
+}
+
+void
+TestUrgentHangsParent::ThirdStage()
+{
+    // The third stage does the same thing as the second stage except that the
+    // child sends an urgent message to us. In this case, we actually answer
+    // that message unconditionally.
+
+    // Send an async message that waits 2 seconds and then sends a sync message
+    // (which should be processed).
+    if (!SendTest5())
+        fail("sending Test5");
+
+    // Send a sync message that will time out because the child is waiting
+    // inside RecvTest5.
+    if (SendTest5_1())
+        fail("sending Test5_1");
+
+    // Close the channel after the child finishes its work in RecvTest5.
+    MessageLoop::current()->PostDelayedTask(
+        NewNonOwningRunnableMethod(this, &TestUrgentHangsParent::Close),
+        3000);
+}
+
+bool
+TestUrgentHangsParent::RecvTest1_2()
+{
+    if (!SendTest1_3())
+        fail("sending Test1_3");
+    return true;
+}
+
+bool
+TestUrgentHangsParent::RecvTestInner()
+{
+    mInnerCount++;
+    return true;
+}
+
+bool
+TestUrgentHangsParent::RecvTestInnerUrgent()
+{
+    mInnerUrgentCount++;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// child
+
+bool
+TestUrgentHangsChild::RecvTest1_1()
+{
+    if (!SendTest1_2())
+        fail("sending Test1_2");
+
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest1_3()
+{
+    PR_Sleep(PR_SecondsToInterval(2));
+
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest2()
+{
+    PR_Sleep(PR_SecondsToInterval(2));
+
+    // Should fail because of the timeout.
+    if (SendTestInner())
+        fail("sending TestInner");
+
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest3()
+{
+    fail("RecvTest3 should never be called");
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest4()
+{
+    PR_Sleep(PR_SecondsToInterval(2));
+
+    // This won't fail because we should handle Test4_1 here before actually
+    // sending TestInner to the parent.
+    if (!SendTestInner())
+        fail("sending TestInner");
+
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest4_1()
+{
+    // This should fail because Test4_1 timed out and hasn't gotten a response
+    // yet.
+    if (SendTestInner())
+        fail("sending TestInner");
+
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest5()
+{
+    PR_Sleep(PR_SecondsToInterval(2));
+
+    // This message will actually be handled by the parent even though it's in
+    // the timeout state.
+    if (!SendTestInnerUrgent())
+        fail("sending TestInner");
+
+    return true;
+}
+
+bool
+TestUrgentHangsChild::RecvTest5_1()
+{
+    // This message will actually be handled by the parent even though it's in
+    // the timeout state.
+    if (!SendTestInnerUrgent())
+        fail("sending TestInner");
+
+    return true;
+}
+
+TestUrgentHangsChild::TestUrgentHangsChild()
+{
+    MOZ_COUNT_CTOR(TestUrgentHangsChild);
+}
+
+TestUrgentHangsChild::~TestUrgentHangsChild()
+{
+    MOZ_COUNT_DTOR(TestUrgentHangsChild);
+}
+
+} // namespace _ipdltest
+} // namespace mozilla
diff --git a/ipc/ipdl/test/cxx/TestUrgentHangs.h b/ipc/ipdl/test/cxx/TestUrgentHangs.h
new file mode 100644
index 000000000..bbe63d11e
--- /dev/null
+++ b/ipc/ipdl/test/cxx/TestUrgentHangs.h
@@ -0,0 +1,79 @@
+#ifndef mozilla__ipdltest_TestUrgentHangs_h
+#define mozilla__ipdltest_TestUrgentHangs_h 1
+
+#include "mozilla/_ipdltest/IPDLUnitTests.h"
+
+#include "mozilla/_ipdltest/PTestUrgentHangsParent.h"
+#include "mozilla/_ipdltest/PTestUrgentHangsChild.h"
+
+namespace mozilla {
+namespace _ipdltest {
+
+
+class TestUrgentHangsParent :
+    public PTestUrgentHangsParent
+{
+public:
+    TestUrgentHangsParent();
+    virtual ~TestUrgentHangsParent();
+
+    static bool RunTestInProcesses() { return true; }
+    static bool RunTestInThreads() { return false; }
+
+    void Main();
+    void SecondStage();
+    void ThirdStage();
+
+    bool RecvTest1_2();
+    bool RecvTestInner();
+    bool RecvTestInnerUrgent();
+
+    bool ShouldContinueFromReplyTimeout() override
+    {
+      return false;
+    }
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+	if (mInnerCount != 1) {
+	    fail("wrong mInnerCount");
+	}
+	if (mInnerUrgentCount != 2) {
+	    fail("wrong mInnerUrgentCount");
+	}
+        passed("ok");
+        QuitParent();
+    }
+
+private:
+    size_t mInnerCount, mInnerUrgentCount;
+};
+
+
+class TestUrgentHangsChild :
+    public PTestUrgentHangsChild
+{
+public:
+    TestUrgentHangsChild();
+    virtual ~TestUrgentHangsChild();
+
+    bool RecvTest1_1();
+    bool RecvTest1_3();
+    bool RecvTest2();
+    bool RecvTest3();
+    bool RecvTest4();
+    bool RecvTest4_1();
+    bool RecvTest5();
+    bool RecvTest5_1();
+
+    virtual void ActorDestroy(ActorDestroyReason why) override
+    {
+        QuitChild();
+    }
+};
+
+
+} // namespace _ipdltest
+} // namespace mozilla
+
+
+#endif // ifndef mozilla__ipdltest_TestUrgentHangs_h
diff --git a/ipc/ipdl/test/cxx/app/Makefile.in b/ipc/ipdl/test/cxx/app/Makefile.in
new file mode 100644
index 000000000..3738d44d3
--- /dev/null
+++ b/ipc/ipdl/test/cxx/app/Makefile.in
@@ -0,0 +1,5 @@
+# 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/.
+
+NSDISTMODE = copy
diff --git a/ipc/ipdl/test/cxx/app/TestIPDL.cpp b/ipc/ipdl/test/cxx/app/TestIPDL.cpp
new file mode 100644
index 000000000..a34cca080
--- /dev/null
+++ b/ipc/ipdl/test/cxx/app/TestIPDL.cpp
@@ -0,0 +1,20 @@
+/* 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 "nsXULAppAPI.h"
+
+#if defined(XP_WIN)
+#include <windows.h>
+#include "nsWindowsWMain.cpp"
+#endif
+
+int
+main(int argc, char** argv)
+{
+    // the first argument specifies which IPDL test case/suite to load
+    if (argc < 2)
+        return 1;
+
+    return XRE_RunIPDLTest(argc, argv);
+}
diff --git a/ipc/ipdl/test/cxx/app/moz.build b/ipc/ipdl/test/cxx/app/moz.build
new file mode 100644
index 000000000..d464e78a6
--- /dev/null
+++ b/ipc/ipdl/test/cxx/app/moz.build
@@ -0,0 +1,20 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+GeckoProgram('ipdlunittest', linkage='dependent')
+
+SOURCES += [
+    'TestIPDL.cpp',
+]
+include('/ipc/chromium/chromium-config.mozbuild')
+
+LOCAL_INCLUDES += [
+    '/toolkit/xre',
+    '/xpcom/base',
+]
+
+if CONFIG['_MSC_VER']:
+    WIN32_EXE_LDFLAGS += ['-ENTRY:wmainCRTStartup']
diff --git a/ipc/ipdl/test/cxx/genIPDLUnitTests.py b/ipc/ipdl/test/cxx/genIPDLUnitTests.py
new file mode 100644
index 000000000..24026451b
--- /dev/null
+++ b/ipc/ipdl/test/cxx/genIPDLUnitTests.py
@@ -0,0 +1,141 @@
+# 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/.
+
+import string, sys
+
+def usage():
+    print >>sys.stderr, """
+%s template_file -t unit_tests... -e extra_protocols...
+
+  TEMPLATE_FILE is used to generate to generate the unit-tester .cpp
+  UNIT_TESTS are the top-level protocols defining unit tests
+  EXTRA_PROTOCOLS are top-level protocols for subprocesses that can be
+                  spawned in tests but are not unit tests in and of
+                  themselves
+"""% (sys.argv[0])
+    sys.exit(1)
+
+def main(argv):
+    template = argv[1]
+
+    if argv[2] != '-t': usage()
+    i = 3
+    unittests = []
+    while argv[i] != '-e':
+        unittests.append(argv[i])
+        i += 1
+
+    extras = argv[(i+1):]
+
+    includes = '\n'.join([
+        '#include "%s.h"'% (t) for t in unittests ])
+
+
+    enum_values = '\n'.join([
+        '    %s,'% (t) for t in unittests+extras ])
+    last_enum = unittests[-1]
+
+
+    string_to_enums = '\n'.join([
+        '''    else if (!strcmp(aString, "%s"))
+        return %s;'''% (t, t) for t in unittests+extras ])
+
+    enum_to_strings = '\n'.join([
+        '''    case %s:
+        return "%s";'''%(t, t) for t in unittests+extras ])
+
+    parent_delete_cases = '\n'.join([
+'''    case %s: {
+           delete reinterpret_cast<%sParent*>(gParentActor);
+           return;
+       }
+'''% (t, t) for t in unittests ])
+
+    parent_enabled_cases_proc = '\n'.join([
+'''    case %s: {
+        if (!%sParent::RunTestInProcesses()) {
+            passed("N/A to proc");
+            DeferredParentShutdown();
+            return;
+        }
+        break;
+       }
+''' % (t, t) for t in unittests ])
+
+    parent_main_cases_proc = '\n'.join([
+'''    case %s: {
+        %sParent** parent =
+        reinterpret_cast<%sParent**>(&gParentActor);
+        *parent = new %sParent();
+        (*parent)->Open(transport, child);
+        return (*parent)->Main();
+        }
+'''% (t, t, t, t) for t in unittests ])
+
+    parent_enabled_cases_thread = '\n'.join([
+'''    case %s: {
+        if (!%sParent::RunTestInThreads()) {
+            passed("N/A to threads");
+            DeferredParentShutdown();
+            return;
+        }
+        break;
+       }
+''' % (t, t) for t in unittests ])
+
+    parent_main_cases_thread = '\n'.join([
+'''    case %s: {
+        %sParent** parent =
+        reinterpret_cast<%sParent**>(&gParentActor);
+        *parent = new %sParent();
+
+        %sChild** child =
+        reinterpret_cast<%sChild**>(&gChildActor);
+        *child = new %sChild();
+
+        ::mozilla::ipc::MessageChannel *childChannel = (*child)->GetIPCChannel();
+        ::mozilla::ipc::Side parentSide =
+            ::mozilla::ipc::ParentSide;
+
+        (*parent)->Open(childChannel, childMessageLoop, parentSide);
+        return (*parent)->Main();
+        }
+'''% (t, t, t, t, t, t, t) for t in unittests ])
+
+    child_delete_cases = '\n'.join([
+'''    case %s: {
+           delete reinterpret_cast<%sChild*>(gChildActor);
+           return;
+       }
+'''% (t, t) for t in unittests+extras ])
+
+
+    child_init_cases = '\n'.join([
+'''    case %s: {
+        %sChild** child =
+            reinterpret_cast<%sChild**>(&gChildActor);
+        *child = new %sChild();
+        (*child)->Open(transport, parentPid, worker);
+        return;
+    }
+'''% (t, t, t, t) for t in unittests+extras ])
+
+    templatefile = open(template, 'r')
+    sys.stdout.write(
+        string.Template(templatefile.read()).substitute(
+            INCLUDES=includes,
+            ENUM_VALUES=enum_values, LAST_ENUM=last_enum,
+            STRING_TO_ENUMS=string_to_enums,
+            ENUM_TO_STRINGS=enum_to_strings,
+            PARENT_DELETE_CASES=parent_delete_cases,
+            PARENT_ENABLED_CASES_PROC=parent_enabled_cases_proc,
+            PARENT_MAIN_CASES_PROC=parent_main_cases_proc,
+            PARENT_ENABLED_CASES_THREAD=parent_enabled_cases_thread,
+            PARENT_MAIN_CASES_THREAD=parent_main_cases_thread,
+            CHILD_DELETE_CASES=child_delete_cases,
+            CHILD_INIT_CASES=child_init_cases))
+    templatefile.close()
+
+if __name__ == '__main__':
+    main(sys.argv)
diff --git a/ipc/ipdl/test/cxx/moz.build b/ipc/ipdl/test/cxx/moz.build
new file mode 100644
index 000000000..c87455e02
--- /dev/null
+++ b/ipc/ipdl/test/cxx/moz.build
@@ -0,0 +1,134 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+DIRS += ['app']
+
+EXPORTS.mozilla._ipdltest += [
+    'IPDLUnitTestProcessChild.h',
+    'IPDLUnitTests.h',
+    'IPDLUnitTestTypes.h',
+    'IPDLUnitTestUtils.h',
+]
+
+SOURCES += [
+    'TestActorPunning.cpp',
+    'TestBadActor.cpp',
+    'TestBridgeMain.cpp',
+    'TestCancel.cpp',
+    'TestCrashCleanup.cpp',
+    'TestDataStructures.cpp',
+    'TestDemon.cpp',
+    'TestDesc.cpp',
+    'TestEndpointBridgeMain.cpp',
+    'TestEndpointOpens.cpp',
+    'TestFailedCtor.cpp',
+    'TestHangs.cpp',
+    'TestHighestPrio.cpp',
+    'TestInterruptErrorCleanup.cpp',
+    'TestInterruptRaces.cpp',
+    'TestInterruptShutdownRace.cpp',
+    'TestJSON.cpp',
+    'TestLatency.cpp',
+    'TestManyChildAllocs.cpp',
+    'TestMultiMgrs.cpp',
+    'TestNestedLoops.cpp',
+    'TestOpens.cpp',
+    'TestRaceDeadlock.cpp',
+    'TestRaceDeferral.cpp',
+    'TestRacyInterruptReplies.cpp',
+    'TestRacyReentry.cpp',
+    'TestRacyUndefer.cpp',
+    'TestRPC.cpp',
+    'TestSanity.cpp',
+    'TestSelfManageRoot.cpp',
+    'TestShmem.cpp',
+    'TestShutdown.cpp',
+    'TestStackHooks.cpp',
+    'TestSyncError.cpp',
+    'TestSyncHang.cpp',
+    'TestSyncWakeup.cpp',
+    'TestUrgency.cpp',
+    'TestUrgentHangs.cpp',
+]
+
+SOURCES += [
+    '!IPDLUnitTests.cpp',
+    'IPDLUnitTestProcessChild.cpp',
+    'IPDLUnitTestSubprocess.cpp',
+]
+
+IPDL_SOURCES += [
+    'PTestActorPunning.ipdl',
+    'PTestActorPunningPunned.ipdl',
+    'PTestActorPunningSub.ipdl',
+    'PTestBadActor.ipdl',
+    'PTestBadActorSub.ipdl',
+    'PTestBridgeMain.ipdl',
+    'PTestBridgeMainSub.ipdl',
+    'PTestBridgeSub.ipdl',
+    'PTestCancel.ipdl',
+    'PTestCrashCleanup.ipdl',
+    'PTestDataStructures.ipdl',
+    'PTestDataStructuresCommon.ipdlh',
+    'PTestDataStructuresSub.ipdl',
+    'PTestDemon.ipdl',
+    'PTestDesc.ipdl',
+    'PTestDescSub.ipdl',
+    'PTestDescSubsub.ipdl',
+    'PTestEndpointBridgeMain.ipdl',
+    'PTestEndpointBridgeMainSub.ipdl',
+    'PTestEndpointBridgeSub.ipdl',
+    'PTestEndpointOpens.ipdl',
+    'PTestEndpointOpensOpened.ipdl',
+    'PTestFailedCtor.ipdl',
+    'PTestFailedCtorSub.ipdl',
+    'PTestFailedCtorSubsub.ipdl',
+    'PTestHandle.ipdl',
+    'PTestHangs.ipdl',
+    'PTestHighestPrio.ipdl',
+    'PTestIndirectProtocolParam.ipdlh',
+    'PTestIndirectProtocolParamFirst.ipdl',
+    'PTestIndirectProtocolParamManage.ipdl',
+    'PTestIndirectProtocolParamSecond.ipdl',
+    'PTestInterruptErrorCleanup.ipdl',
+    'PTestInterruptRaces.ipdl',
+    'PTestInterruptShutdownRace.ipdl',
+    'PTestJSON.ipdl',
+    'PTestLatency.ipdl',
+    'PTestManyChildAllocs.ipdl',
+    'PTestManyChildAllocsSub.ipdl',
+    'PTestMultiMgrs.ipdl',
+    'PTestMultiMgrsBottom.ipdl',
+    'PTestMultiMgrsLeft.ipdl',
+    'PTestMultiMgrsRight.ipdl',
+    'PTestNestedLoops.ipdl',
+    'PTestOpens.ipdl',
+    'PTestOpensOpened.ipdl',
+    'PTestPriority.ipdl',
+    'PTestRaceDeadlock.ipdl',
+    'PTestRaceDeferral.ipdl',
+    'PTestRacyInterruptReplies.ipdl',
+    'PTestRacyReentry.ipdl',
+    'PTestRacyUndefer.ipdl',
+    'PTestRPC.ipdl',
+    'PTestSanity.ipdl',
+    'PTestSelfManage.ipdl',
+    'PTestSelfManageRoot.ipdl',
+    'PTestShmem.ipdl',
+    'PTestShutdown.ipdl',
+    'PTestShutdownSub.ipdl',
+    'PTestShutdownSubsub.ipdl',
+    'PTestStackHooks.ipdl',
+    'PTestSyncError.ipdl',
+    'PTestSyncHang.ipdl',
+    'PTestSyncWakeup.ipdl',
+    'PTestUrgency.ipdl',
+    'PTestUrgentHangs.ipdl',
+]
+
+include('/ipc/chromium/chromium-config.mozbuild')
+
+FINAL_LIBRARY = 'xul'