summaryrefslogtreecommitdiffstats
path: root/netwerk/ipc/NeckoChild.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/ipc/NeckoChild.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/ipc/NeckoChild.cpp')
-rw-r--r--netwerk/ipc/NeckoChild.cpp431
1 files changed, 431 insertions, 0 deletions
diff --git a/netwerk/ipc/NeckoChild.cpp b/netwerk/ipc/NeckoChild.cpp
new file mode 100644
index 000000000..00827b5a0
--- /dev/null
+++ b/netwerk/ipc/NeckoChild.cpp
@@ -0,0 +1,431 @@
+
+/* vim: set sw=2 ts=8 et 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/. */
+
+#include "necko-config.h"
+#include "nsHttp.h"
+#include "mozilla/net/NeckoChild.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/TabChild.h"
+#include "mozilla/net/HttpChannelChild.h"
+#include "mozilla/net/CookieServiceChild.h"
+#include "mozilla/net/WyciwygChannelChild.h"
+#include "mozilla/net/FTPChannelChild.h"
+#include "mozilla/net/WebSocketChannelChild.h"
+#include "mozilla/net/WebSocketEventListenerChild.h"
+#include "mozilla/net/DNSRequestChild.h"
+#include "mozilla/net/ChannelDiverterChild.h"
+#include "mozilla/net/IPCTransportProvider.h"
+#include "mozilla/dom/network/TCPSocketChild.h"
+#include "mozilla/dom/network/TCPServerSocketChild.h"
+#include "mozilla/dom/network/UDPSocketChild.h"
+#include "mozilla/net/AltDataOutputStreamChild.h"
+
+#ifdef NECKO_PROTOCOL_rtsp
+#include "mozilla/net/RtspControllerChild.h"
+#include "mozilla/net/RtspChannelChild.h"
+#endif
+#include "SerializedLoadContext.h"
+#include "nsIOService.h"
+#include "nsINetworkPredictor.h"
+#include "nsINetworkPredictorVerifier.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "nsNetUtil.h"
+
+using mozilla::dom::TCPSocketChild;
+using mozilla::dom::TCPServerSocketChild;
+using mozilla::dom::UDPSocketChild;
+
+namespace mozilla {
+namespace net {
+
+PNeckoChild *gNeckoChild = nullptr;
+
+// C++ file contents
+NeckoChild::NeckoChild()
+{
+}
+
+NeckoChild::~NeckoChild()
+{
+ //Send__delete__(gNeckoChild);
+ gNeckoChild = nullptr;
+}
+
+void NeckoChild::InitNeckoChild()
+{
+ MOZ_ASSERT(IsNeckoChild(), "InitNeckoChild called by non-child!");
+
+ if (!gNeckoChild) {
+ mozilla::dom::ContentChild * cpc =
+ mozilla::dom::ContentChild::GetSingleton();
+ NS_ASSERTION(cpc, "Content Protocol is NULL!");
+ gNeckoChild = cpc->SendPNeckoConstructor();
+ NS_ASSERTION(gNeckoChild, "PNecko Protocol init failed!");
+ }
+}
+
+PHttpChannelChild*
+NeckoChild::AllocPHttpChannelChild(const PBrowserOrId& browser,
+ const SerializedLoadContext& loadContext,
+ const HttpChannelCreationArgs& aOpenArgs)
+{
+ // We don't allocate here: instead we always use IPDL constructor that takes
+ // an existing HttpChildChannel
+ NS_NOTREACHED("AllocPHttpChannelChild should not be called on child");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPHttpChannelChild(PHttpChannelChild* channel)
+{
+ MOZ_ASSERT(IsNeckoChild(), "DeallocPHttpChannelChild called by non-child!");
+
+ HttpChannelChild* child = static_cast<HttpChannelChild*>(channel);
+ child->ReleaseIPDLReference();
+ return true;
+}
+
+PAltDataOutputStreamChild*
+NeckoChild::AllocPAltDataOutputStreamChild(
+ const nsCString& type,
+ PHttpChannelChild* channel)
+{
+ AltDataOutputStreamChild* stream = new AltDataOutputStreamChild();
+ stream->AddIPDLReference();
+ return stream;
+}
+
+bool
+NeckoChild::DeallocPAltDataOutputStreamChild(PAltDataOutputStreamChild* aActor)
+{
+ AltDataOutputStreamChild* child = static_cast<AltDataOutputStreamChild*>(aActor);
+ child->ReleaseIPDLReference();
+ return true;
+}
+
+PFTPChannelChild*
+NeckoChild::AllocPFTPChannelChild(const PBrowserOrId& aBrowser,
+ const SerializedLoadContext& aSerialized,
+ const FTPChannelCreationArgs& aOpenArgs)
+{
+ // We don't allocate here: see FTPChannelChild::AsyncOpen()
+ NS_RUNTIMEABORT("AllocPFTPChannelChild should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPFTPChannelChild(PFTPChannelChild* channel)
+{
+ MOZ_ASSERT(IsNeckoChild(), "DeallocPFTPChannelChild called by non-child!");
+
+ FTPChannelChild* child = static_cast<FTPChannelChild*>(channel);
+ child->ReleaseIPDLReference();
+ return true;
+}
+
+PCookieServiceChild*
+NeckoChild::AllocPCookieServiceChild()
+{
+ // We don't allocate here: see nsCookieService::GetSingleton()
+ NS_NOTREACHED("AllocPCookieServiceChild should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPCookieServiceChild(PCookieServiceChild* cs)
+{
+ NS_ASSERTION(IsNeckoChild(), "DeallocPCookieServiceChild called by non-child!");
+
+ CookieServiceChild *p = static_cast<CookieServiceChild*>(cs);
+ p->Release();
+ return true;
+}
+
+PWyciwygChannelChild*
+NeckoChild::AllocPWyciwygChannelChild()
+{
+ WyciwygChannelChild *p = new WyciwygChannelChild();
+ p->AddIPDLReference();
+ return p;
+}
+
+bool
+NeckoChild::DeallocPWyciwygChannelChild(PWyciwygChannelChild* channel)
+{
+ MOZ_ASSERT(IsNeckoChild(), "DeallocPWyciwygChannelChild called by non-child!");
+
+ WyciwygChannelChild *p = static_cast<WyciwygChannelChild*>(channel);
+ p->ReleaseIPDLReference();
+ return true;
+}
+
+PWebSocketChild*
+NeckoChild::AllocPWebSocketChild(const PBrowserOrId& browser,
+ const SerializedLoadContext& aSerialized,
+ const uint32_t& aSerial)
+{
+ NS_NOTREACHED("AllocPWebSocketChild should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPWebSocketChild(PWebSocketChild* child)
+{
+ WebSocketChannelChild* p = static_cast<WebSocketChannelChild*>(child);
+ p->ReleaseIPDLReference();
+ return true;
+}
+
+PWebSocketEventListenerChild*
+NeckoChild::AllocPWebSocketEventListenerChild(const uint64_t& aInnerWindowID)
+{
+ RefPtr<WebSocketEventListenerChild> c =
+ new WebSocketEventListenerChild(aInnerWindowID);
+ return c.forget().take();
+}
+
+bool
+NeckoChild::DeallocPWebSocketEventListenerChild(PWebSocketEventListenerChild* aActor)
+{
+ RefPtr<WebSocketEventListenerChild> c =
+ dont_AddRef(static_cast<WebSocketEventListenerChild*>(aActor));
+ MOZ_ASSERT(c);
+ return true;
+}
+
+PDataChannelChild*
+NeckoChild::AllocPDataChannelChild(const uint32_t& channelId)
+{
+ MOZ_ASSERT_UNREACHABLE("Should never get here");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPDataChannelChild(PDataChannelChild* child)
+{
+ // NB: See DataChannelChild::ActorDestroy.
+ return true;
+}
+
+PRtspControllerChild*
+NeckoChild::AllocPRtspControllerChild()
+{
+ NS_NOTREACHED("AllocPRtspController should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPRtspControllerChild(PRtspControllerChild* child)
+{
+#ifdef NECKO_PROTOCOL_rtsp
+ RtspControllerChild* p = static_cast<RtspControllerChild*>(child);
+ p->ReleaseIPDLReference();
+#endif
+ return true;
+}
+
+PRtspChannelChild*
+NeckoChild::AllocPRtspChannelChild(const RtspChannelConnectArgs& aArgs)
+{
+ NS_NOTREACHED("AllocPRtspController should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPRtspChannelChild(PRtspChannelChild* child)
+{
+#ifdef NECKO_PROTOCOL_rtsp
+ RtspChannelChild* p = static_cast<RtspChannelChild*>(child);
+ p->ReleaseIPDLReference();
+#endif
+ return true;
+}
+
+PTCPSocketChild*
+NeckoChild::AllocPTCPSocketChild(const nsString& host,
+ const uint16_t& port)
+{
+ TCPSocketChild* p = new TCPSocketChild(host, port);
+ p->AddIPDLReference();
+ return p;
+}
+
+bool
+NeckoChild::DeallocPTCPSocketChild(PTCPSocketChild* child)
+{
+ TCPSocketChild* p = static_cast<TCPSocketChild*>(child);
+ p->ReleaseIPDLReference();
+ return true;
+}
+
+PTCPServerSocketChild*
+NeckoChild::AllocPTCPServerSocketChild(const uint16_t& aLocalPort,
+ const uint16_t& aBacklog,
+ const bool& aUseArrayBuffers)
+{
+ NS_NOTREACHED("AllocPTCPServerSocket should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPTCPServerSocketChild(PTCPServerSocketChild* child)
+{
+ TCPServerSocketChild* p = static_cast<TCPServerSocketChild*>(child);
+ p->ReleaseIPDLReference();
+ return true;
+}
+
+PUDPSocketChild*
+NeckoChild::AllocPUDPSocketChild(const Principal& aPrincipal,
+ const nsCString& aFilter)
+{
+ NS_NOTREACHED("AllocPUDPSocket should not be called");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPUDPSocketChild(PUDPSocketChild* child)
+{
+
+ UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
+ p->ReleaseIPDLReference();
+ return true;
+}
+
+PDNSRequestChild*
+NeckoChild::AllocPDNSRequestChild(const nsCString& aHost,
+ const uint32_t& aFlags,
+ const nsCString& aNetworkInterface)
+{
+ // We don't allocate here: instead we always use IPDL constructor that takes
+ // an existing object
+ NS_NOTREACHED("AllocPDNSRequestChild should not be called on child");
+ return nullptr;
+}
+
+bool
+NeckoChild::DeallocPDNSRequestChild(PDNSRequestChild* aChild)
+{
+ DNSRequestChild *p = static_cast<DNSRequestChild*>(aChild);
+ p->ReleaseIPDLReference();
+ return true;
+}
+
+PChannelDiverterChild*
+NeckoChild::AllocPChannelDiverterChild(const ChannelDiverterArgs& channel)
+{
+ return new ChannelDiverterChild();;
+}
+
+bool
+NeckoChild::DeallocPChannelDiverterChild(PChannelDiverterChild* child)
+{
+ delete static_cast<ChannelDiverterChild*>(child);
+ return true;
+}
+
+PTransportProviderChild*
+NeckoChild::AllocPTransportProviderChild()
+{
+ // This refcount is transferred to the receiver of the message that
+ // includes the PTransportProviderChild actor.
+ RefPtr<TransportProviderChild> res = new TransportProviderChild();
+
+ return res.forget().take();
+}
+
+bool
+NeckoChild::DeallocPTransportProviderChild(PTransportProviderChild* aActor)
+{
+ return true;
+}
+
+bool
+NeckoChild::RecvAsyncAuthPromptForNestedFrame(const TabId& aNestedFrameId,
+ const nsCString& aUri,
+ const nsString& aRealm,
+ const uint64_t& aCallbackId)
+{
+ RefPtr<dom::TabChild> tabChild = dom::TabChild::FindTabChild(aNestedFrameId);
+ if (!tabChild) {
+ MOZ_CRASH();
+ return false;
+ }
+ tabChild->SendAsyncAuthPrompt(aUri, aRealm, aCallbackId);
+ return true;
+}
+
+/* Predictor Messages */
+bool
+NeckoChild::RecvPredOnPredictPrefetch(const URIParams& aURI,
+ const uint32_t& aHttpStatus)
+{
+ MOZ_ASSERT(NS_IsMainThread(), "PredictorChild::RecvOnPredictPrefetch "
+ "off main thread.");
+
+ nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
+
+ // Get the current predictor
+ nsresult rv = NS_OK;
+ nsCOMPtr<nsINetworkPredictorVerifier> predictor =
+ do_GetService("@mozilla.org/network/predictor;1", &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ predictor->OnPredictPrefetch(uri, aHttpStatus);
+ return true;
+}
+
+bool
+NeckoChild::RecvPredOnPredictPreconnect(const URIParams& aURI)
+{
+ MOZ_ASSERT(NS_IsMainThread(), "PredictorChild::RecvOnPredictPreconnect "
+ "off main thread.");
+
+ nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
+
+ // Get the current predictor
+ nsresult rv = NS_OK;
+ nsCOMPtr<nsINetworkPredictorVerifier> predictor =
+ do_GetService("@mozilla.org/network/predictor;1", &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ predictor->OnPredictPreconnect(uri);
+ return true;
+}
+
+bool
+NeckoChild::RecvPredOnPredictDNS(const URIParams& aURI)
+{
+ MOZ_ASSERT(NS_IsMainThread(), "PredictorChild::RecvOnPredictDNS off "
+ "main thread.");
+
+ nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
+
+ // Get the current predictor
+ nsresult rv = NS_OK;
+ nsCOMPtr<nsINetworkPredictorVerifier> predictor =
+ do_GetService("@mozilla.org/network/predictor;1", &rv);
+ NS_ENSURE_SUCCESS(rv, false);
+
+ predictor->OnPredictDNS(uri);
+ return true;
+}
+
+bool
+NeckoChild::RecvSpeculativeConnectRequest()
+{
+ nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();
+ if (obsService) {
+ obsService->NotifyObservers(nullptr, "speculative-connect-request",
+ nullptr);
+ }
+ return true;
+}
+
+} // namespace net
+} // namespace mozilla
+