netwerk/ipc/NeckoChild.cpp

   1
   2 /* vim: set sw=2 ts=8 et tw=80 : */
   3
   4 /* This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7
   8 #include "necko-config.h"
   9 #include "nsHttp.h"
  10 #include "mozilla/net/NeckoChild.h"
  11 #include "mozilla/dom/ContentChild.h"
  12 #include "mozilla/dom/TabChild.h"
  13 #include "mozilla/net/HttpChannelChild.h"
  14 #include "mozilla/net/CookieServiceChild.h"
  15 #include "mozilla/net/WyciwygChannelChild.h"
  16 #include "mozilla/net/FTPChannelChild.h"
  17 #include "mozilla/net/WebSocketChannelChild.h"
  18 #include "mozilla/net/DNSRequestChild.h"
  19 #include "mozilla/net/RemoteOpenFileChild.h"
  20 #include "mozilla/net/ChannelDiverterChild.h"
  21 #include "mozilla/dom/network/TCPSocketChild.h"
  22 #include "mozilla/dom/network/TCPServerSocketChild.h"
  23 #include "mozilla/dom/network/UDPSocketChild.h"
  24 #ifdef NECKO_PROTOCOL_rtsp
  25 #include "mozilla/net/RtspControllerChild.h"
  26 #include "mozilla/net/RtspChannelChild.h"
  27 #endif
  28 #include "SerializedLoadContext.h"
  29
  30 using mozilla::dom::TCPSocketChild;
  31 using mozilla::dom::TCPServerSocketChild;
  32 using mozilla::dom::UDPSocketChild;
  33
  34 namespace mozilla {
  35 namespace net {
  36
  37 PNeckoChild *gNeckoChild = nullptr;
  38
  39 // C++ file contents
  40 NeckoChild::NeckoChild()
  41 {
  42 }
  43
  44 NeckoChild::~NeckoChild()
  45 {
  46 }
  47
  48 void NeckoChild::InitNeckoChild()
  49 {
  50   NS_ABORT_IF_FALSE(IsNeckoChild(), "InitNeckoChild called by non-child!");
  51
  52   if (!gNeckoChild) {
  53     mozilla::dom::ContentChild * cpc =
  54       mozilla::dom::ContentChild::GetSingleton();
  55     NS_ASSERTION(cpc, "Content Protocol is NULL!");
  56     gNeckoChild = cpc->SendPNeckoConstructor();
  57     NS_ASSERTION(gNeckoChild, "PNecko Protocol init failed!");
  58   }
  59 }
  60
  61 // Note: not actually called; has some lifespan as child process, so
  62 // automatically destroyed at exit.
  63 void NeckoChild::DestroyNeckoChild()
  64 {
  65   NS_ABORT_IF_FALSE(IsNeckoChild(), "DestroyNeckoChild called by non-child!");
  66   static bool alreadyDestroyed = false;
  67   NS_ABORT_IF_FALSE(!alreadyDestroyed, "DestroyNeckoChild already called!");
  68
  69   if (!alreadyDestroyed) {
  70     Send__delete__(gNeckoChild);
  71     gNeckoChild = nullptr;
  72     alreadyDestroyed = true;
  73   }
  74 }
  75
  76 PHttpChannelChild*
  77 NeckoChild::AllocPHttpChannelChild(const PBrowserOrId& browser,
  78                                    const SerializedLoadContext& loadContext,
  79                                    const HttpChannelCreationArgs& aOpenArgs)
  80 {
  81   // We don't allocate here: instead we always use IPDL constructor that takes
  82   // an existing HttpChildChannel
  83   NS_NOTREACHED("AllocPHttpChannelChild should not be called on child");
  84   return nullptr;
  85 }
  86
  87 bool
  88 NeckoChild::DeallocPHttpChannelChild(PHttpChannelChild* channel)
  89 {
  90   NS_ABORT_IF_FALSE(IsNeckoChild(), "DeallocPHttpChannelChild called by non-child!");
  91
  92   HttpChannelChild* child = static_cast<HttpChannelChild*>(channel);
  93   child->ReleaseIPDLReference();
  94   return true;
  95 }
  96
  97 PFTPChannelChild*
  98 NeckoChild::AllocPFTPChannelChild(const PBrowserOrId& aBrowser,
  99                                   const SerializedLoadContext& aSerialized,
 100                                   const FTPChannelCreationArgs& aOpenArgs)
 101 {
 102   // We don't allocate here: see FTPChannelChild::AsyncOpen()
 103   NS_RUNTIMEABORT("AllocPFTPChannelChild should not be called");
 104   return nullptr;
 105 }
 106
 107 bool
 108 NeckoChild::DeallocPFTPChannelChild(PFTPChannelChild* channel)
 109 {
 110   NS_ABORT_IF_FALSE(IsNeckoChild(), "DeallocPFTPChannelChild called by non-child!");
 111
 112   FTPChannelChild* child = static_cast<FTPChannelChild*>(channel);
 113   child->ReleaseIPDLReference();
 114   return true;
 115 }
 116
 117 PCookieServiceChild*
 118 NeckoChild::AllocPCookieServiceChild()
 119 {
 120   // We don't allocate here: see nsCookieService::GetSingleton()
 121   NS_NOTREACHED("AllocPCookieServiceChild should not be called");
 122   return nullptr;
 123 }
 124
 125 bool
 126 NeckoChild::DeallocPCookieServiceChild(PCookieServiceChild* cs)
 127 {
 128   NS_ASSERTION(IsNeckoChild(), "DeallocPCookieServiceChild called by non-child!");
 129
 130   CookieServiceChild *p = static_cast<CookieServiceChild*>(cs);
 131   p->Release();
 132   return true;
 133 }
 134
 135 PWyciwygChannelChild*
 136 NeckoChild::AllocPWyciwygChannelChild()
 137 {
 138   WyciwygChannelChild *p = new WyciwygChannelChild();
 139   p->AddIPDLReference();
 140   return p;
 141 }
 142
 143 bool
 144 NeckoChild::DeallocPWyciwygChannelChild(PWyciwygChannelChild* channel)
 145 {
 146   NS_ABORT_IF_FALSE(IsNeckoChild(), "DeallocPWyciwygChannelChild called by non-child!");
 147
 148   WyciwygChannelChild *p = static_cast<WyciwygChannelChild*>(channel);
 149   p->ReleaseIPDLReference();
 150   return true;
 151 }
 152
 153 PWebSocketChild*
 154 NeckoChild::AllocPWebSocketChild(const PBrowserOrId& browser,
 155                                  const SerializedLoadContext& aSerialized)
 156 {
 157   NS_NOTREACHED("AllocPWebSocketChild should not be called");
 158   return nullptr;
 159 }
 160
 161 bool
 162 NeckoChild::DeallocPWebSocketChild(PWebSocketChild* child)
 163 {
 164   WebSocketChannelChild* p = static_cast<WebSocketChannelChild*>(child);
 165   p->ReleaseIPDLReference();
 166   return true;
 167 }
 168
 169 PRtspControllerChild*
 170 NeckoChild::AllocPRtspControllerChild()
 171 {
 172   NS_NOTREACHED("AllocPRtspController should not be called");
 173   return nullptr;
 174 }
 175
 176 bool
 177 NeckoChild::DeallocPRtspControllerChild(PRtspControllerChild* child)
 178 {
 179 #ifdef NECKO_PROTOCOL_rtsp
 180   RtspControllerChild* p = static_cast<RtspControllerChild*>(child);
 181   p->ReleaseIPDLReference();
 182 #endif
 183   return true;
 184 }
 185
 186 PRtspChannelChild*
 187 NeckoChild::AllocPRtspChannelChild(const RtspChannelConnectArgs& aArgs)
 188 {
 189   NS_NOTREACHED("AllocPRtspController should not be called");
 190   return nullptr;
 191 }
 192
 193 bool
 194 NeckoChild::DeallocPRtspChannelChild(PRtspChannelChild* child)
 195 {
 196 #ifdef NECKO_PROTOCOL_rtsp
 197   RtspChannelChild* p = static_cast<RtspChannelChild*>(child);
 198   p->ReleaseIPDLReference();
 199 #endif
 200   return true;
 201 }
 202
 203 PTCPSocketChild*
 204 NeckoChild::AllocPTCPSocketChild(const nsString& host,
 205                                  const uint16_t& port)
 206 {
 207   TCPSocketChild* p = new TCPSocketChild();
 208   p->Init(host, port);
 209   p->AddIPDLReference();
 210   return p;
 211 }
 212
 213 bool
 214 NeckoChild::DeallocPTCPSocketChild(PTCPSocketChild* child)
 215 {
 216   TCPSocketChild* p = static_cast<TCPSocketChild*>(child);
 217   p->ReleaseIPDLReference();
 218   return true;
 219 }
 220
 221 PTCPServerSocketChild*
 222 NeckoChild::AllocPTCPServerSocketChild(const uint16_t& aLocalPort,
 223                                   const uint16_t& aBacklog,
 224                                   const nsString& aBinaryType)
 225 {
 226   NS_NOTREACHED("AllocPTCPServerSocket should not be called");
 227   return nullptr;
 228 }
 229
 230 bool
 231 NeckoChild::DeallocPTCPServerSocketChild(PTCPServerSocketChild* child)
 232 {
 233   TCPServerSocketChild* p = static_cast<TCPServerSocketChild*>(child);
 234   p->ReleaseIPDLReference();
 235   return true;
 236 }
 237
 238 PUDPSocketChild*
 239 NeckoChild::AllocPUDPSocketChild(const nsCString& aFilter)
 240 {
 241   NS_NOTREACHED("AllocPUDPSocket should not be called");
 242   return nullptr;
 243 }
 244
 245 bool
 246 NeckoChild::DeallocPUDPSocketChild(PUDPSocketChild* child)
 247 {
 248
 249   UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
 250   p->ReleaseIPDLReference();
 251   return true;
 252 }
 253
 254 PDNSRequestChild*
 255 NeckoChild::AllocPDNSRequestChild(const nsCString& aHost,
 256                                   const uint32_t& aFlags)
 257 {
 258   // We don't allocate here: instead we always use IPDL constructor that takes
 259   // an existing object
 260   NS_NOTREACHED("AllocPDNSRequestChild should not be called on child");
 261   return nullptr;
 262 }
 263
 264 bool
 265 NeckoChild::DeallocPDNSRequestChild(PDNSRequestChild* aChild)
 266 {
 267   DNSRequestChild *p = static_cast<DNSRequestChild*>(aChild);
 268   p->ReleaseIPDLReference();
 269   return true;
 270 }
 271
 272 PRemoteOpenFileChild*
 273 NeckoChild::AllocPRemoteOpenFileChild(const SerializedLoadContext& aSerialized,
 274                                       const URIParams&,
 275                                       const OptionalURIParams&)
 276 {
 277   // We don't allocate here: instead we always use IPDL constructor that takes
 278   // an existing RemoteOpenFileChild
 279   NS_NOTREACHED("AllocPRemoteOpenFileChild should not be called on child");
 280   return nullptr;
 281 }
 282
 283 bool
 284 NeckoChild::DeallocPRemoteOpenFileChild(PRemoteOpenFileChild* aChild)
 285 {
 286   RemoteOpenFileChild *p = static_cast<RemoteOpenFileChild*>(aChild);
 287   p->ReleaseIPDLReference();
 288   return true;
 289 }
 290
 291 PChannelDiverterChild*
 292 NeckoChild::AllocPChannelDiverterChild(const ChannelDiverterArgs& channel)
 293 {
 294   return new ChannelDiverterChild();;
 295 }
 296
 297 bool
 298 NeckoChild::DeallocPChannelDiverterChild(PChannelDiverterChild* child)
 299 {
 300   delete static_cast<ChannelDiverterChild*>(child);
 301   return true;
 302 }
 303
 304 bool
 305 NeckoChild::RecvAsyncAuthPromptForNestedFrame(const uint64_t& aNestedFrameId,
 306                                               const nsCString& aUri,
 307                                               const nsString& aRealm,
 308                                               const uint64_t& aCallbackId)
 309 {
 310   auto iter = dom::TabChild::NestedTabChildMap().find(aNestedFrameId);
 311   if (iter == dom::TabChild::NestedTabChildMap().end()) {
 312     MOZ_CRASH();
 313     return false;
 314   }
 315   dom::TabChild* tabChild = iter->second;
 316   tabChild->SendAsyncAuthPrompt(aUri, aRealm, aCallbackId);
 317   return true;
 318 }
 319
 320 }} // mozilla::net
 321