From f13da4ca280ef5a2477d514a2832efd602c73cc4 Mon Sep 17 00:00:00 2001 From: Kershaw Chang Date: Fri, 11 Jan 2019 20:55:07 +0000 Subject: [PATCH] Bug 1513057 - P5: Create IPC between content process and socket process r=dragana,mayhemer Differential Revision: https://phabricator.services.mozilla.com/D14257 --HG-- extra : moz-landing-system : lando --- netwerk/ipc/NeckoParent.cpp | 40 ++++++- netwerk/ipc/NeckoParent.h | 5 + netwerk/ipc/PNecko.ipdl | 4 + netwerk/ipc/PSocketProcess.ipdl | 3 + netwerk/ipc/PSocketProcessBridge.ipdl | 25 ++++ netwerk/ipc/SocketProcessBridgeChild.cpp | 133 ++++++++++++++++++++++ netwerk/ipc/SocketProcessBridgeChild.h | 48 ++++++++ netwerk/ipc/SocketProcessBridgeParent.cpp | 49 ++++++++ netwerk/ipc/SocketProcessBridgeParent.h | 38 +++++++ netwerk/ipc/SocketProcessChild.cpp | 19 ++++ netwerk/ipc/SocketProcessChild.h | 11 ++ netwerk/ipc/SocketProcessParent.cpp | 13 +++ netwerk/ipc/SocketProcessParent.h | 2 + netwerk/ipc/moz.build | 7 +- 14 files changed, 395 insertions(+), 2 deletions(-) create mode 100644 netwerk/ipc/PSocketProcessBridge.ipdl create mode 100644 netwerk/ipc/SocketProcessBridgeChild.cpp create mode 100644 netwerk/ipc/SocketProcessBridgeChild.h create mode 100644 netwerk/ipc/SocketProcessBridgeParent.cpp create mode 100644 netwerk/ipc/SocketProcessBridgeParent.h diff --git a/netwerk/ipc/NeckoParent.cpp b/netwerk/ipc/NeckoParent.cpp index 655759ce2ca7..5615fd22f473 100644 --- a/netwerk/ipc/NeckoParent.cpp +++ b/netwerk/ipc/NeckoParent.cpp @@ -28,6 +28,8 @@ #include "mozilla/net/IPCTransportProvider.h" #include "mozilla/net/RequestContextService.h" #include "mozilla/net/TrackingDummyChannelParent.h" +#include "mozilla/net/SocketProcessParent.h" +#include "mozilla/net/PSocketProcessBridgeParent.h" #ifdef MOZ_WEBRTC #include "mozilla/net/StunAddrsRequestParent.h" #include "mozilla/net/WebrtcProxyChannelParent.h" @@ -74,7 +76,7 @@ namespace mozilla { namespace net { // C++ file contents -NeckoParent::NeckoParent() { +NeckoParent::NeckoParent() : mSocketProcessBridgeInited(false) { // Init HTTP protocol handler now since we need atomTable up and running very // early (IPDL argument handling for PHttpChannel constructor needs it) so // normal init (during 1st Http channel request) isn't early enough. @@ -954,5 +956,41 @@ bool NeckoParent::DeallocPTrackingDummyChannelParent( return true; } +mozilla::ipc::IPCResult NeckoParent::RecvInitSocketProcessBridge( + InitSocketProcessBridgeResolver&& aResolver) { + MOZ_ASSERT(NS_IsMainThread()); + + Endpoint invalidEndpoint; + if (NS_WARN_IF(mSocketProcessBridgeInited)) { + aResolver(std::move(invalidEndpoint)); + return IPC_OK(); + } + + SocketProcessParent* parent = SocketProcessParent::GetSingleton(); + if (NS_WARN_IF(!parent)) { + aResolver(std::move(invalidEndpoint)); + return IPC_OK(); + } + + Endpoint parentEndpoint; + Endpoint childEndpoint; + if (NS_WARN_IF(NS_FAILED(PSocketProcessBridge::CreateEndpoints( + parent->OtherPid(), Manager()->OtherPid(), &parentEndpoint, + &childEndpoint)))) { + aResolver(std::move(invalidEndpoint)); + return IPC_OK(); + } + + if (NS_WARN_IF(!parent->SendInitSocketProcessBridgeParent( + Manager()->OtherPid(), std::move(parentEndpoint)))) { + aResolver(std::move(invalidEndpoint)); + return IPC_OK(); + } + + aResolver(std::move(childEndpoint)); + mSocketProcessBridgeInited = true; + return IPC_OK(); +} + } // namespace net } // namespace mozilla diff --git a/netwerk/ipc/NeckoParent.h b/netwerk/ipc/NeckoParent.h index 483ca60847f1..00ccad2761b2 100644 --- a/netwerk/ipc/NeckoParent.h +++ b/netwerk/ipc/NeckoParent.h @@ -87,6 +87,8 @@ class NeckoParent : public PNeckoParent { }; protected: + bool mSocketProcessBridgeInited; + virtual PHttpChannelParent* AllocPHttpChannelParent( const PBrowserOrId&, const SerializedLoadContext&, const HttpChannelCreationArgs& aOpenArgs) override; @@ -246,6 +248,9 @@ class NeckoParent : public PNeckoParent { PTrackingDummyChannelParent* aActor, nsIURI* aURI, nsIURI* aTopWindowURI, const nsresult& aTopWindowURIResult, const OptionalLoadInfoArgs& aLoadInfo) override; + + virtual mozilla::ipc::IPCResult RecvInitSocketProcessBridge( + InitSocketProcessBridgeResolver&& aResolver) override; }; } // namespace net diff --git a/netwerk/ipc/PNecko.ipdl b/netwerk/ipc/PNecko.ipdl index fa8c03f45e25..5589469a2176 100644 --- a/netwerk/ipc/PNecko.ipdl +++ b/netwerk/ipc/PNecko.ipdl @@ -28,6 +28,7 @@ include protocol PStunAddrsRequest; include protocol PFileChannel; include protocol PTrackingDummyChannel; include protocol PWebrtcProxyChannel; +include protocol PSocketProcessBridge; include IPCStream; include URIParams; @@ -143,6 +144,9 @@ parent: async GetExtensionStream(URIParams uri) returns (nsIInputStream stream); async GetExtensionFD(URIParams uri) returns (FileDescriptor fd); + async InitSocketProcessBridge() + returns (Endpoint endpoint); + child: /* * Bring up the http auth prompt for a nested remote mozbrowser. diff --git a/netwerk/ipc/PSocketProcess.ipdl b/netwerk/ipc/PSocketProcess.ipdl index 8fad922152ad..db9d4a50620e 100644 --- a/netwerk/ipc/PSocketProcess.ipdl +++ b/netwerk/ipc/PSocketProcess.ipdl @@ -4,9 +4,11 @@ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ include MemoryReportTypes; +include protocol PSocketProcessBridge; include PrefsTypes; using mozilla::dom::NativeThreadId from "mozilla/dom/TabMessageUtils.h"; +using base::ProcessId from "base/process.h"; namespace mozilla { namespace net { @@ -25,6 +27,7 @@ child: bool minimizeMemoryUsage, MaybeFileDesc DMDFile); async SetOffline(bool offline); + async InitSocketProcessBridgeParent(ProcessId processId, Endpoint endpoint); }; } // namespace net diff --git a/netwerk/ipc/PSocketProcessBridge.ipdl b/netwerk/ipc/PSocketProcessBridge.ipdl new file mode 100644 index 000000000000..f0583391a56f --- /dev/null +++ b/netwerk/ipc/PSocketProcessBridge.ipdl @@ -0,0 +1,25 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=2 et sw=2 tw=80: */ +/* 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/. */ + +namespace mozilla { +namespace net { + +/** + * PSocketProcessBridge is the IPC protocol between content process and + * socket process. This protocol allows socket process to send data to + * content process bypassing parent process. + * Once created, PSocketProcessBridgeChild is the actor that lives in + * content process and PSocketProcessBridgeParent lives in + * socket process. + */ +nested(upto inside_cpow) sync protocol PSocketProcessBridge +{ +both: + async Test(); +}; + +} +} diff --git a/netwerk/ipc/SocketProcessBridgeChild.cpp b/netwerk/ipc/SocketProcessBridgeChild.cpp new file mode 100644 index 000000000000..d82914be30e1 --- /dev/null +++ b/netwerk/ipc/SocketProcessBridgeChild.cpp @@ -0,0 +1,133 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "SocketProcessBridgeChild.h" +#include "SocketProcessLogging.h" + +#include "mozilla/net/NeckoChild.h" +#include "nsIObserverService.h" +#include "nsThreadUtils.h" + +namespace mozilla { +namespace net { + +StaticRefPtr + SocketProcessBridgeChild::sSocketProcessBridgeChild; + +NS_IMPL_ISUPPORTS(SocketProcessBridgeChild, nsIObserver) + +// static +bool SocketProcessBridgeChild::Create( + Endpoint&& aEndpoint) { + MOZ_ASSERT(NS_IsMainThread()); + + sSocketProcessBridgeChild = + new SocketProcessBridgeChild(std::move(aEndpoint)); + if (sSocketProcessBridgeChild->Inited()) { + return true; + } + + sSocketProcessBridgeChild = nullptr; + return false; +} + +// static +already_AddRefed +SocketProcessBridgeChild::GetSinglton() { + MOZ_ASSERT(NS_IsMainThread()); + + if (!sSocketProcessBridgeChild) { + return nullptr; + } + + RefPtr child = sSocketProcessBridgeChild.get(); + return child.forget(); +} + +// static +void SocketProcessBridgeChild::EnsureSocketProcessBridge( + std::function&& aOnSuccess, std::function&& aOnFailure) { + MOZ_ASSERT(IsNeckoChild() && gNeckoChild); + MOZ_ASSERT(NS_IsMainThread()); + + if (!gNeckoChild) { + aOnFailure(); + return; + } + + if (sSocketProcessBridgeChild) { + aOnSuccess(); + return; + } + + gNeckoChild->SendInitSocketProcessBridge()->Then( + GetMainThreadSerialEventTarget(), __func__, + [onSuccess = std::move(aOnSuccess), onFailure = std::move(aOnFailure)]( + Endpoint&& aEndpoint) { + if (aEndpoint.IsValid()) { + if (SocketProcessBridgeChild::Create(std::move(aEndpoint))) { + onSuccess(); + return; + } + } + onFailure(); + }, + [onFailure = std::move(aOnFailure)]( + const mozilla::ipc::ResponseRejectReason) { onFailure(); }); +} + +SocketProcessBridgeChild::SocketProcessBridgeChild( + Endpoint&& aEndpoint) { + LOG(("CONSTRUCT SocketProcessBridgeChild::SocketProcessBridgeChild\n")); + + mInited = aEndpoint.Bind(this); + if (!mInited) { + MOZ_ASSERT(false, "Bind failed!"); + return; + } + + nsCOMPtr os = mozilla::services::GetObserverService(); + if (os) { + os->AddObserver(this, "content-child-shutdown", false); + } +} + +SocketProcessBridgeChild::~SocketProcessBridgeChild() { + LOG(("DESTRUCT SocketProcessBridgeChild::SocketProcessBridgeChild\n")); +} + +mozilla::ipc::IPCResult SocketProcessBridgeChild::RecvTest() { + LOG(("SocketProcessBridgeChild::RecvTest\n")); + return IPC_OK(); +} + +void SocketProcessBridgeChild::ActorDestroy(ActorDestroyReason aWhy) { + LOG(("SocketProcessBridgeChild::ActorDestroy\n")); + nsCOMPtr os = mozilla::services::GetObserverService(); + if (os) { + os->RemoveObserver(this, "content-child-shutdown"); + } + MessageLoop::current()->PostTask( + NewRunnableMethod("net::SocketProcessBridgeChild::DeferredDestroy", this, + &SocketProcessBridgeChild::DeferredDestroy)); +} + +NS_IMETHODIMP +SocketProcessBridgeChild::Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) { + if (!strcmp(aTopic, "content-child-shutdown")) { + PSocketProcessBridgeChild::Close(); + } + return NS_OK; +} + +void SocketProcessBridgeChild::DeferredDestroy() { + MOZ_ASSERT(NS_IsMainThread()); + + sSocketProcessBridgeChild = nullptr; +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/ipc/SocketProcessBridgeChild.h b/netwerk/ipc/SocketProcessBridgeChild.h new file mode 100644 index 000000000000..ec36c579c96e --- /dev/null +++ b/netwerk/ipc/SocketProcessBridgeChild.h @@ -0,0 +1,48 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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_net_SocketProcessBridgeChild_h +#define mozilla_net_SocketProcessBridgeChild_h + +#include +#include "mozilla/net/PSocketProcessBridgeChild.h" +#include "nsIObserver.h" + +namespace mozilla { +namespace net { + +// The IPC actor implements PSocketProcessBridgeChild in content process. +// This is allocated and kept alive by NeckoChild. When "content-child-shutdown" +// topic is observed, this actor will be destroyed. +class SocketProcessBridgeChild final : public PSocketProcessBridgeChild, + public nsIObserver { + public: + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + + static bool Create(Endpoint&& aEndpoint); + static already_AddRefed GetSinglton(); + static void EnsureSocketProcessBridge(std::function&& aOnSuccess, + std::function&& aOnFailure); + + mozilla::ipc::IPCResult RecvTest() override; + void ActorDestroy(ActorDestroyReason aWhy) override; + void DeferredDestroy(); + bool Inited() const { return mInited; }; + + private: + DISALLOW_COPY_AND_ASSIGN(SocketProcessBridgeChild); + explicit SocketProcessBridgeChild( + Endpoint&& aEndpoint); + virtual ~SocketProcessBridgeChild(); + + static StaticRefPtr sSocketProcessBridgeChild; + bool mInited = false; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_SocketProcessBridgeChild_h diff --git a/netwerk/ipc/SocketProcessBridgeParent.cpp b/netwerk/ipc/SocketProcessBridgeParent.cpp new file mode 100644 index 000000000000..f87975e9958b --- /dev/null +++ b/netwerk/ipc/SocketProcessBridgeParent.cpp @@ -0,0 +1,49 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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 "SocketProcessBridgeParent.h" +#include "SocketProcessLogging.h" + +#include "SocketProcessChild.h" + +namespace mozilla { +namespace net { + +SocketProcessBridgeParent::SocketProcessBridgeParent( + ProcessId aId, Endpoint&& aEndpoint) + : mId(aId) { + LOG(( + "CONSTRUCT SocketProcessBridgeParent::SocketProcessBridgeParent mId=%d\n", + mId)); + MOZ_COUNT_CTOR(SocketProcessBridgeParent); + DebugOnly ok = aEndpoint.Bind(this); + MOZ_ASSERT(ok); +} + +SocketProcessBridgeParent::~SocketProcessBridgeParent() { + LOG(("DESTRUCT SocketProcessBridgeParent::SocketProcessBridgeParent\n")); + MOZ_COUNT_DTOR(SocketProcessBridgeParent); +} + +mozilla::ipc::IPCResult SocketProcessBridgeParent::RecvTest() { + LOG(("SocketProcessBridgeParent::RecvTest\n")); + Unused << SendTest(); + return IPC_OK(); +} + +void SocketProcessBridgeParent::ActorDestroy(ActorDestroyReason aWhy) { + LOG(("SocketProcessBridgeParent::ActorDestroy mId=%d\n", mId)); + + MessageLoop::current()->PostTask( + NewRunnableMethod("net::SocketProcessBridgeParent::DeferredDestroy", this, + &SocketProcessBridgeParent::DeferredDestroy)); +} + +void SocketProcessBridgeParent::DeferredDestroy() { + SocketProcessChild::GetSingleton()->DestroySocketProcessBridgeParent(mId); +} + +} // namespace net +} // namespace mozilla diff --git a/netwerk/ipc/SocketProcessBridgeParent.h b/netwerk/ipc/SocketProcessBridgeParent.h new file mode 100644 index 000000000000..d18ea2bf77fa --- /dev/null +++ b/netwerk/ipc/SocketProcessBridgeParent.h @@ -0,0 +1,38 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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_net_SocketProcessBridgeParent_h +#define mozilla_net_SocketProcessBridgeParent_h + +#include "mozilla/net/PSocketProcessBridgeParent.h" + +namespace mozilla { +namespace net { + +// The IPC actor implements PSocketProcessBridgeParent in socket process. +// This is allocated and kept alive by SocketProcessChild. When |ActorDestroy| +// is called, |SocketProcessChild::DestroySocketProcessBridgeParent| will be +// called to destroy this actor. +class SocketProcessBridgeParent final : public PSocketProcessBridgeParent { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SocketProcessBridgeParent) + + explicit SocketProcessBridgeParent( + ProcessId aId, Endpoint&& aEndpoint); + + mozilla::ipc::IPCResult RecvTest() override; + void ActorDestroy(ActorDestroyReason aWhy) override; + void DeferredDestroy(); + + private: + ~SocketProcessBridgeParent(); + + ProcessId mId; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_SocketProcessBridgeParent_h diff --git a/netwerk/ipc/SocketProcessChild.cpp b/netwerk/ipc/SocketProcessChild.cpp index ce374cb7e485..730fcc81302d 100644 --- a/netwerk/ipc/SocketProcessChild.cpp +++ b/netwerk/ipc/SocketProcessChild.cpp @@ -15,6 +15,7 @@ #include "nsDebugImpl.h" #include "nsThreadManager.h" #include "ProcessUtils.h" +#include "SocketProcessBridgeParent.h" namespace mozilla { namespace net { @@ -118,5 +119,23 @@ mozilla::ipc::IPCResult SocketProcessChild::RecvSetOffline( return IPC_OK(); } +mozilla::ipc::IPCResult SocketProcessChild::RecvInitSocketProcessBridgeParent( + const ProcessId& aContentProcessId, + Endpoint&& aEndpoint) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!mSocketProcessBridgeParentMap.Get(aContentProcessId, nullptr)); + + mSocketProcessBridgeParentMap.Put( + aContentProcessId, + new SocketProcessBridgeParent(aContentProcessId, std::move(aEndpoint))); + return IPC_OK(); +} + +void SocketProcessChild::DestroySocketProcessBridgeParent(ProcessId aId) { + MOZ_ASSERT(NS_IsMainThread()); + + mSocketProcessBridgeParentMap.Remove(aId); +} + } // namespace net } // namespace mozilla diff --git a/netwerk/ipc/SocketProcessChild.h b/netwerk/ipc/SocketProcessChild.h index c26abe939b2f..e58be0d1c571 100644 --- a/netwerk/ipc/SocketProcessChild.h +++ b/netwerk/ipc/SocketProcessChild.h @@ -7,10 +7,13 @@ #define mozilla_net_SocketProcessChild_h #include "mozilla/net/PSocketProcessChild.h" +#include "nsRefPtrHashtable.h" namespace mozilla { namespace net { +class SocketProcessBridgeParent; + // The IPC actor implements PSocketProcessChild in child process. // This is allocated and kept alive by SocketProcessImpl. class SocketProcessChild final : public PSocketProcessChild { @@ -30,10 +33,18 @@ class SocketProcessChild final : public PSocketProcessChild { const uint32_t& generation, const bool& anonymize, const bool& minimizeMemoryUsage, const MaybeFileDesc& DMDFile) override; mozilla::ipc::IPCResult RecvSetOffline(const bool& aOffline) override; + mozilla::ipc::IPCResult RecvInitSocketProcessBridgeParent( + const ProcessId& aContentProcessId, + Endpoint&& aEndpoint) override; void CleanUp(); + void DestroySocketProcessBridgeParent(ProcessId aId); private: + // Mapping of content process id and the SocketProcessBridgeParent. + // This table keeps SocketProcessBridgeParent alive in socket process. + nsRefPtrHashtable + mSocketProcessBridgeParentMap; }; } // namespace net diff --git a/netwerk/ipc/SocketProcessParent.cpp b/netwerk/ipc/SocketProcessParent.cpp index 1c6af273f39a..d92b48aa3195 100644 --- a/netwerk/ipc/SocketProcessParent.cpp +++ b/netwerk/ipc/SocketProcessParent.cpp @@ -11,15 +11,28 @@ namespace mozilla { namespace net { +static SocketProcessParent* sSocketProcessParent; + SocketProcessParent::SocketProcessParent(SocketProcessHost* aHost) : mHost(aHost) { + MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(mHost); MOZ_COUNT_CTOR(SocketProcessParent); + sSocketProcessParent = this; } SocketProcessParent::~SocketProcessParent() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_COUNT_DTOR(SocketProcessParent); + sSocketProcessParent = nullptr; +} + +/* static */ SocketProcessParent* SocketProcessParent::GetSingleton() { + MOZ_ASSERT(NS_IsMainThread()); + + return sSocketProcessParent; } mozilla::ipc::IPCResult SocketProcessParent::RecvInitCrashReporter( diff --git a/netwerk/ipc/SocketProcessParent.h b/netwerk/ipc/SocketProcessParent.h index c4a885052707..773a2179787e 100644 --- a/netwerk/ipc/SocketProcessParent.h +++ b/netwerk/ipc/SocketProcessParent.h @@ -33,6 +33,8 @@ class SocketProcessParent final : public PSocketProcessParent { explicit SocketProcessParent(SocketProcessHost* aHost); ~SocketProcessParent(); + static SocketProcessParent* GetSingleton(); + mozilla::ipc::IPCResult RecvInitCrashReporter( Shmem&& aShmem, const NativeThreadId& aThreadId) override; mozilla::ipc::IPCResult RecvAddMemoryReport( diff --git a/netwerk/ipc/moz.build b/netwerk/ipc/moz.build index 019f7e996878..4eb6fbc780c9 100644 --- a/netwerk/ipc/moz.build +++ b/netwerk/ipc/moz.build @@ -11,6 +11,8 @@ EXPORTS.mozilla.net += [ 'NeckoMessageUtils.h', 'NeckoParent.h', 'NeckoTargetHolder.h', + 'SocketProcessBridgeChild.h', + 'SocketProcessBridgeParent.h', 'SocketProcessChild.h', 'SocketProcessHost.h', 'SocketProcessImpl.h', @@ -23,6 +25,8 @@ UNIFIED_SOURCES += [ 'NeckoCommon.cpp', 'NeckoParent.cpp', 'NeckoTargetHolder.cpp', + 'SocketProcessBridgeChild.cpp', + 'SocketProcessBridgeParent.cpp', 'SocketProcessChild.cpp', 'SocketProcessHost.cpp', 'SocketProcessImpl.cpp', @@ -36,7 +40,8 @@ IPDL_SOURCES = [ 'PFileChannel.ipdl', 'PNecko.ipdl', 'PSimpleChannel.ipdl', - 'PSocketProcess.ipdl' + 'PSocketProcess.ipdl', + 'PSocketProcessBridge.ipdl' ] # needed so --disable-webrtc builds work (yes, a bit messy)