Bug 1263991 part 6: Add e10s support for incoming websocket connections to FlyWebPublishedServer. r=baku,michal

Author: sicking

dom/flyweb/FlyWebPublishedServer.cpp

@@ -13,9 +13,12 @@
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/InternalResponse.h"
 #include "mozilla/ipc/IPCStreamUtils.h"
+#include "mozilla/net/NeckoParent.h"
+#include "mozilla/net/IPCTransportProvider.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/unused.h"
+#include "nsCharSeparatedTokenizer.h"
 #include "nsGlobalWindow.h"
 #include "WebSocketChannel.h"
 
@@ -295,6 +298,26 @@ FlyWebPublishedServerChild::RecvFetchRequest(const IPCInternalRequest& aRequest,
   return true;
 }
 
+bool
+FlyWebPublishedServerChild::RecvWebSocketRequest(const IPCInternalRequest& aRequest,
+                                                 const uint64_t& aRequestId,
+                                                 PTransportProviderChild* aProvider)
+{
+  LOG_I("FlyWebPublishedServerChild::RecvWebSocketRequest(%p)", this);
+
+  RefPtr<InternalRequest> request = new InternalRequest(aRequest);
+  mPendingRequests.Put(request, aRequestId);
+
+  // Not addreffing here. The addref was already done when the
+  // PTransportProvider child constructor original ran.
+  mPendingTransportProviders.Put(aRequestId,
+    dont_AddRef(static_cast<TransportProviderChild*>(aProvider)));
+
+  FireWebsocketEvent(request);
+
+  return true;
+}
+
 void
 FlyWebPublishedServerChild::ActorDestroy(ActorDestroyReason aWhy)
 {
@@ -328,21 +351,70 @@ FlyWebPublishedServerChild::OnFetchResponse(InternalRequest* aRequest,
 }
 
 already_AddRefed<nsITransportProvider>
-FlyWebPublishedServerChild::OnWebSocketAcceptInternal(InternalRequest* aConnectRequest,
+FlyWebPublishedServerChild::OnWebSocketAcceptInternal(InternalRequest* aRequest,
                                                       const Optional<nsAString>& aProtocol,
                                                       ErrorResult& aRv)
 {
   LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p)", this);
 
-  aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
-  return nullptr;
+  if (mActorDestroyed) {
+    LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p) - No actor!", this);
+    return nullptr;
+  }
+
+  uint64_t id = mPendingRequests.Get(aRequest);
+  MOZ_ASSERT(id);
+  mPendingRequests.Remove(aRequest);
+
+  RefPtr<TransportProviderChild> provider;
+  mPendingTransportProviders.Remove(id, getter_AddRefs(provider));
+
+  nsString protocol;
+  if (aProtocol.WasPassed()) {
+    protocol = aProtocol.Value();
+
+    nsAutoCString reqProtocols;
+    aRequest->Headers()->
+      Get(NS_LITERAL_CSTRING("Sec-WebSocket-Protocol"), reqProtocols, aRv);
+    if (!ContainsToken(reqProtocols, NS_ConvertUTF16toUTF8(protocol))) {
+      // Should throw a better error here
+      aRv.Throw(NS_ERROR_FAILURE);
+      return nullptr;
+    }
+  } else {
+    protocol.SetIsVoid(true);
+  }
+
+  Unused << SendWebSocketAccept(protocol, id);
+
+  return provider.forget();
 }
 
 void
-FlyWebPublishedServerChild::OnWebSocketResponse(InternalRequest* aConnectRequest,
+FlyWebPublishedServerChild::OnWebSocketResponse(InternalRequest* aRequest,
                                                 InternalResponse* aResponse)
 {
-  // Send ipdl message to parent
+  LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p)", this);
+
+  if (mActorDestroyed) {
+    LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p) - No actor!", this);
+    return;
+  }
+
+  uint64_t id = mPendingRequests.Get(aRequest);
+  MOZ_ASSERT(id);
+  mPendingRequests.Remove(aRequest);
+
+  mPendingTransportProviders.Remove(id);
+
+  IPCInternalResponse ipcResp;
+  UniquePtr<mozilla::ipc::AutoIPCStream> autoStream;
+  aResponse->ToIPC(&ipcResp, Manager(), autoStream);
+
+  Unused << SendWebSocketResponse(ipcResp, id);
+  if (autoStream) {
+    autoStream->TakeOptionalValue();
+  }
 }
 
 void
@@ -397,6 +469,8 @@ FlyWebPublishedServerParent::FlyWebPublishedServerParent(const nsAString& aName,
 
       mPublishedServer->AddEventListener(NS_LITERAL_STRING("fetch"),
                                          this, false, false, 2);
+      mPublishedServer->AddEventListener(NS_LITERAL_STRING("websocket"),
+                                         this, false, false, 2);
       mPublishedServer->AddEventListener(NS_LITERAL_STRING("close"),
                                          this, false, false, 2);
       Unused << SendServerReady(NS_OK);
@@ -435,6 +509,24 @@ FlyWebPublishedServerParent::HandleEvent(nsIDOMEvent* aEvent)
     return NS_OK;
   }
 
+  if (type.EqualsLiteral("websocket")) {
+    RefPtr<InternalRequest> request =
+      static_cast<FlyWebWebSocketEvent*>(aEvent)->Request()->GetInternalRequest();
+    uint64_t id = mNextRequestId++;
+    mPendingRequests.Put(id, request);
+
+    RefPtr<TransportProviderParent> provider =
+      static_cast<TransportProviderParent*>(
+        mozilla::net::gNeckoParent->SendPTransportProviderConstructor());
+
+    IPCInternalRequest ipcReq;
+    request->ToIPC(&ipcReq);
+    Unused << SendWebSocketRequest(ipcReq, id, provider);
+
+    mPendingTransportProviders.Put(id, provider.forget());
+    return NS_OK;
+  }
+
   MOZ_CRASH("Unknown event type");
 
   return NS_OK;
@@ -444,8 +536,8 @@ bool
 FlyWebPublishedServerParent::RecvFetchResponse(const IPCInternalResponse& aResponse,
                                                const uint64_t& aRequestId)
 {
-  RefPtr<InternalRequest> request = mPendingRequests.GetWeak(aRequestId);
-  mPendingRequests.Remove(aRequestId);
+  RefPtr<InternalRequest> request;
+  mPendingRequests.Remove(aRequestId, getter_AddRefs(request));
   if (!request) {
      static_cast<ContentParent*>(Manager())->KillHard("unknown request id");
      return false;
@@ -458,6 +550,58 @@ FlyWebPublishedServerParent::RecvFetchResponse(const IPCInternalResponse& aRespo
   return true;
 }
 
+bool
+FlyWebPublishedServerParent::RecvWebSocketResponse(const IPCInternalResponse& aResponse,
+                                                   const uint64_t& aRequestId)
+{
+  mPendingTransportProviders.Remove(aRequestId);
+
+  RefPtr<InternalRequest> request;
+  mPendingRequests.Remove(aRequestId, getter_AddRefs(request));
+  if (!request) {
+     static_cast<ContentParent*>(Manager())->KillHard("unknown websocket request id");
+     return false;
+  }
+
+  RefPtr<InternalResponse> response = InternalResponse::FromIPC(aResponse);
+
+  mPublishedServer->OnWebSocketResponse(request, response);
+
+  return true;
+}
+
+bool
+FlyWebPublishedServerParent::RecvWebSocketAccept(const nsString& aProtocol,
+                                                 const uint64_t& aRequestId)
+{
+  RefPtr<TransportProviderParent> providerIPC;
+  mPendingTransportProviders.Remove(aRequestId, getter_AddRefs(providerIPC));
+
+  RefPtr<InternalRequest> request;
+  mPendingRequests.Remove(aRequestId, getter_AddRefs(request));
+
+  if (!request || !providerIPC) {
+     static_cast<ContentParent*>(Manager())->KillHard("unknown websocket request id");
+     return false;
+  }
+
+  Optional<nsAString> protocol;
+  if (!aProtocol.IsVoid()) {
+    protocol = &aProtocol;
+  }
+
+  ErrorResult result;
+  nsCOMPtr<nsITransportProvider> providerServer =
+    mPublishedServer->OnWebSocketAcceptInternal(request, protocol, result);
+  if (result.Failed()) {
+    return false;
+  }
+
+  providerServer->SetListener(providerIPC);
+
+  return true;
+}
+
 void
 FlyWebPublishedServerParent::ActorDestroy(ActorDestroyReason aWhy)
 {
@@ -474,6 +618,8 @@ FlyWebPublishedServerParent::Recv__delete__()
   if (mPublishedServer) {
     mPublishedServer->RemoveEventListener(NS_LITERAL_STRING("fetch"),
                                           this, false);
+    mPublishedServer->RemoveEventListener(NS_LITERAL_STRING("websocket"),
+                                          this, false);
     mPublishedServer->RemoveEventListener(NS_LITERAL_STRING("close"),
                                           this, false);
     mPublishedServer->Close();

dom/flyweb/FlyWebPublishedServerIPC.h

@@ -19,6 +19,11 @@
 class nsPIDOMWindowInner;
 
 namespace mozilla {
+namespace net {
+class TransportProviderParent;
+class TransportProviderChild;
+}
+
 namespace dom {
 
 class FlyWebPublishedServerParent;
@@ -97,6 +102,9 @@ class FlyWebPublishedServerChild final : public FlyWebPublishedServer
   virtual bool RecvServerClose() override;
   virtual bool RecvFetchRequest(const IPCInternalRequest& aRequest,
                                 const uint64_t& aRequestId) override;
+  virtual bool RecvWebSocketRequest(const IPCInternalRequest& aRequest,
+                                    const uint64_t& aRequestId,
+                                    PTransportProviderChild* aProvider) override;
 
   virtual void OnFetchResponse(InternalRequest* aRequest,
                                InternalResponse* aResponse) override;
@@ -115,6 +123,8 @@ class FlyWebPublishedServerChild final : public FlyWebPublishedServer
   ~FlyWebPublishedServerChild() {}
 
   nsDataHashtable<nsRefPtrHashKey<InternalRequest>, uint64_t> mPendingRequests;
+  nsRefPtrHashtable<nsUint64HashKey, TransportProviderChild>
+    mPendingTransportProviders;
   bool mActorDestroyed;
 };
 
@@ -137,12 +147,20 @@ class FlyWebPublishedServerParent final : public PFlyWebPublishedServerParent
   virtual bool
   RecvFetchResponse(const IPCInternalResponse& aResponse,
                     const uint64_t& aRequestId) override;
+  virtual bool
+  RecvWebSocketResponse(const IPCInternalResponse& aResponse,
+                        const uint64_t& aRequestId) override;
+  virtual bool
+  RecvWebSocketAccept(const nsString& aProtocol,
+                      const uint64_t& aRequestId) override;
 
   ~FlyWebPublishedServerParent() {}
 
   bool mActorDestroyed;
   uint64_t mNextRequestId;
   nsRefPtrHashtable<nsUint64HashKey, InternalRequest> mPendingRequests;
+  nsRefPtrHashtable<nsUint64HashKey, TransportProviderParent>
+    mPendingTransportProviders;
   RefPtr<FlyWebPublishedServerImpl> mPublishedServer;
 };
 

dom/flyweb/HttpServer.cpp

@@ -260,6 +260,13 @@ HttpServer::TransportProvider::SetListener(nsIHttpUpgradeListener* aListener)
   return NS_OK;
 }
 
+NS_IMETHODIMP_(PTransportProviderChild*)
+HttpServer::TransportProvider::GetIPCChild()
+{
+  MOZ_CRASH("Don't call this in parent process");
+  return nullptr;
+}
+
 void
 HttpServer::TransportProvider::SetTransport(nsISocketTransport* aTransport,
                                             nsIAsyncInputStream* aInput,
@@ -492,7 +499,7 @@ HttpServer::Connection::ConsumeInput(const char*& aBuffer,
   return NS_OK;
 }
 
-static bool
+bool
 ContainsToken(const nsCString& aList, const nsCString& aToken)
 {
   nsCCharSeparatedTokenizer tokens(aList, ',');

dom/flyweb/HttpServer.h

@@ -23,6 +23,9 @@ class nsIX509Cert;
 namespace mozilla {
 namespace dom {
 
+extern bool
+ContainsToken(const nsCString& aList, const nsCString& aToken);
+
 class InternalRequest;
 class InternalResponse;
 

dom/flyweb/PFlyWebPublishedServer.ipdl

@@ -7,6 +7,7 @@
 include protocol PContent;
 include protocol PSendStream;
 include protocol PFileDescriptorSet;
+include protocol PTransportProvider;
 include FetchTypes;
 include ChannelInfo;
 include PBackgroundSharedTypes;
@@ -21,12 +22,16 @@ async protocol PFlyWebPublishedServer
 child:
   async ServerReady(nsresult aStatus);
   async FetchRequest(IPCInternalRequest aRequest, uint64_t aRequestId);
+  async WebSocketRequest(IPCInternalRequest aRequest, uint64_t aRequestId,
+                         PTransportProvider aProvider);
   async ServerClose();
 
 parent:
   async __delete__();
 
   async FetchResponse(IPCInternalResponse aResponse, uint64_t aRequestId);
+  async WebSocketResponse(IPCInternalResponse aResponse, uint64_t aRequestId);
+  async WebSocketAccept(nsString aProtocol, uint64_t aRequestId);
 };
 
 } // namespace dom

netwerk/ipc/NeckoChild.cpp

@@ -19,6 +19,7 @@
 #include "mozilla/net/DNSRequestChild.h"
 #include "mozilla/net/RemoteOpenFileChild.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"
@@ -327,6 +328,22 @@ NeckoChild::DeallocPChannelDiverterChild(PChannelDiverterChild* 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,

netwerk/ipc/NeckoChild.h

@@ -75,6 +75,10 @@ class NeckoChild :
   AllocPChannelDiverterChild(const ChannelDiverterArgs& channel) override;
   virtual bool
   DeallocPChannelDiverterChild(PChannelDiverterChild* actor) override;
+  virtual PTransportProviderChild*
+  AllocPTransportProviderChild() override;
+  virtual bool
+  DeallocPTransportProviderChild(PTransportProviderChild* aActor) override;
   virtual bool RecvAsyncAuthPromptForNestedFrame(const TabId& aNestedFrameId,
                                                  const nsCString& aUri,
                                                  const nsString& aRealm,