Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-24 21:31:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1374574 - Remove the FlyWeb service and DOM interfaces. r=bz,djvj

Browse Source 
MozReview-Commit-ID: 4hp9pLbMh4R

--HG--
extra : rebase_source : 82f417640211ede4fd7aa290c1f2609b07f38025
This commit is contained in:
Johann Hofmann 2017-11-22 15:00:10 +01:00
parent d655438426
commit d28b4dd837
38 changed files with 2 additions and 4737 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
dom/base/Navigator.cpp
View File

@ -37,8 +37,6 @@
#include "mozilla/dom/GamepadServiceTest.h"
#include "mozilla/dom/WakeLock.h"
#include "mozilla/dom/power/PowerManagerService.h"
#include "mozilla/dom/FlyWebPublishedServer.h"
#include "mozilla/dom/FlyWebService.h"
#include "mozilla/dom/Permissions.h"
#include "mozilla/dom/Presentation.h"
#include "mozilla/dom/ServiceWorkerContainer.h"
@ -1374,41 +1372,6 @@ Navigator::GetBattery(ErrorResult& aRv)
return mBatteryPromise;
}
already_AddRefed<Promise>
Navigator::PublishServer(const nsAString& aName,
const FlyWebPublishOptions& aOptions,
ErrorResult& aRv)
{
RefPtr<FlyWebService> service = FlyWebService::GetOrCreate();
if (!service) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
RefPtr<FlyWebPublishPromise> mozPromise =
service->PublishServer(aName, aOptions, mWindow);
MOZ_ASSERT(mozPromise);
nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(mWindow);
ErrorResult result;
RefPtr<Promise> domPromise = Promise::Create(global, result);
if (result.Failed()) {
aRv.Throw(NS_ERROR_FAILURE);
return nullptr;
}
mozPromise->Then(global->AbstractMainThreadFor(TaskCategory::Other),
__func__,
[domPromise] (FlyWebPublishedServer* aServer) {
domPromise->MaybeResolve(aServer);
},
[domPromise] (nsresult aStatus) {
domPromise->MaybeReject(aStatus);
});
return domPromise.forget();
}
already_AddRefed<LegacyMozTCPSocket>
Navigator::MozTCPSocket()
{

5
dom/base/Navigator.h
View File

@ -40,8 +40,6 @@ class WakeLock;
class ArrayBufferOrArrayBufferViewOrBlobOrFormDataOrUSVStringOrURLSearchParams;
class ServiceWorkerContainer;
class DOMRequest;
struct FlyWebPublishOptions;
struct FlyWebFilter;
class CredentialsContainer;
} // namespace dom
} // namespace mozilla
@ -139,9 +137,6 @@ public:
Geolocation* GetGeolocation(ErrorResult& aRv);
Promise* GetBattery(ErrorResult& aRv);
already_AddRefed<Promise> PublishServer(const nsAString& aName,
const FlyWebPublishOptions& aOptions,
ErrorResult& aRv);
static void AppName(nsAString& aAppName, bool aUsePrefOverriddenValue);
static nsresult GetPlatform(nsAString& aPlatform,

8
dom/base/nsDocument.cpp
View File

@ -173,7 +173,6 @@
#include "mozilla/dom/HTMLImageElement.h"
#include "mozilla/dom/HTMLTextAreaElement.h"
#include "mozilla/dom/MediaSource.h"
#include "mozilla/dom/FlyWebService.h"
#include "mozAutoDocUpdate.h"
#include "nsGlobalWindow.h"
@ -9122,13 +9121,6 @@ nsDocument::CanSavePresentation(nsIRequest *aNewRequest)
return false;
}
// Don't save presentation if there are active FlyWeb connections or FlyWeb
// servers.
FlyWebService* flyWebService = FlyWebService::GetExisting();
if (flyWebService && flyWebService->HasConnectionOrServer(win->WindowID())) {
return false;
}
if (mSubDocuments) {
for (auto iter = mSubDocuments->Iter(); !iter.Done(); iter.Next()) {
auto entry = static_cast<SubDocMapEntry*>(iter.Get());

8
dom/bindings/Bindings.conf
View File

@ -356,14 +356,6 @@ DOMInterfaces = {
'wrapperCache': False,
},
'FlyWebFetchEvent': {
'headerFile': 'FlyWebServerEvents.h',
},
'FlyWebWebSocketEvent': {
'headerFile': 'FlyWebServerEvents.h',
},
'FontFaceSet': {
'implicitJSContext': [ 'load' ],
},

4
dom/events/test/test_all_synthetic_events.html
View File

@ -122,10 +122,6 @@ const kEventConstructors = {
return new ErrorEvent(aName, aProps);
},
},
FlyWebFetchEvent: { create: null, // Cannot create untrusted event from JS.
},
FlyWebWebSocketEvent: { create: null, // Cannot create untrusted event from JS.
},
FocusEvent: { create: function (aName, aProps) {
return new FocusEvent(aName, aProps);
},

126
dom/flyweb/FlyWebDiscoveryManager.cpp
View File

@ -1,126 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#include "nsString.h"
#include "nsTHashtable.h"
#include "nsClassHashtable.h"
#include "nsIUUIDGenerator.h"
#include "jsapi.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/Logging.h"
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"
#include "mozilla/dom/FlyWebDiscoveryManager.h"
#include "mozilla/dom/FlyWebDiscoveryManagerBinding.h"
#include "mozilla/dom/Element.h"
namespace mozilla {
namespace dom {
static LazyLogModule gFlyWebDiscoveryManagerLog("FlyWebDiscoveryManager");
#undef LOG_I
#define LOG_I(...) MOZ_LOG(mozilla::dom::gFlyWebDiscoveryManagerLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
#undef LOG_E
#define LOG_E(...) MOZ_LOG(mozilla::dom::gFlyWebDiscoveryManagerLog, mozilla::LogLevel::Error, (__VA_ARGS__))
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(FlyWebDiscoveryManager)
NS_IMPL_CYCLE_COLLECTING_ADDREF(FlyWebDiscoveryManager)
NS_IMPL_CYCLE_COLLECTING_RELEASE(FlyWebDiscoveryManager)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FlyWebDiscoveryManager)
NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
FlyWebDiscoveryManager::FlyWebDiscoveryManager(nsISupports* aParent,
FlyWebService* aService)
: mParent(aParent)
, mService(aService)
, mNextId(0)
{
}
FlyWebDiscoveryManager::~FlyWebDiscoveryManager()
{
mService->UnregisterDiscoveryManager(this);
}
JSObject*
FlyWebDiscoveryManager::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return FlyWebDiscoveryManagerBinding::Wrap(aCx, this, aGivenProto);
}
nsISupports*
FlyWebDiscoveryManager::GetParentObject() const
{
return mParent;
}
/* static */ already_AddRefed<FlyWebDiscoveryManager>
FlyWebDiscoveryManager::Constructor(const GlobalObject& aGlobal, ErrorResult& rv)
{
RefPtr<FlyWebService> service = FlyWebService::GetOrCreate();
if (!service) {
return nullptr;
}
RefPtr<FlyWebDiscoveryManager> result = new FlyWebDiscoveryManager(
aGlobal.GetAsSupports(), service);
return result.forget();
}
void
FlyWebDiscoveryManager::ListServices(nsTArray<FlyWebDiscoveredService>& aServices)
{
return mService->ListDiscoveredServices(aServices);
}
uint32_t
FlyWebDiscoveryManager::StartDiscovery(FlyWebDiscoveryCallback& aCallback)
{
uint32_t id = GenerateId();
mCallbackMap.Put(id, &aCallback);
mService->RegisterDiscoveryManager(this);
return id;
}
void
FlyWebDiscoveryManager::StopDiscovery(uint32_t aId)
{
mCallbackMap.Remove(aId);
if (mCallbackMap.Count() == 0) {
mService->UnregisterDiscoveryManager(this);
}
}
void
FlyWebDiscoveryManager::PairWithService(const nsAString& aServiceId,
FlyWebPairingCallback& aCallback)
{
mService->PairWithService(aServiceId, aCallback);
}
void
FlyWebDiscoveryManager::NotifyDiscoveredServicesChanged()
{
nsTArray<FlyWebDiscoveredService> services;
ListServices(services);
Sequence<FlyWebDiscoveredService> servicesSeq;
servicesSeq.SwapElements(services);
for (auto iter = mCallbackMap.Iter(); !iter.Done(); iter.Next()) {
FlyWebDiscoveryCallback *callback = iter.UserData();
ErrorResult err;
callback->OnDiscoveredServicesChanged(servicesSeq, err);
ENSURE_SUCCESS_VOID(err);
}
}
} // namespace dom
} // namespace mozilla

61
dom/flyweb/FlyWebDiscoveryManager.h
View File

@ -1,61 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_FlyWebDiscoveryManager_h
#define mozilla_dom_FlyWebDiscoveryManager_h
#include "nsISupportsImpl.h"
#include "mozilla/ErrorResult.h"
#include "nsRefPtrHashtable.h"
#include "nsWrapperCache.h"
#include "FlyWebDiscoveryManagerBinding.h"
#include "FlyWebService.h"
namespace mozilla {
namespace dom {
class FlyWebDiscoveryManager final : public nsISupports
, public nsWrapperCache
{
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(FlyWebDiscoveryManager)
virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
nsISupports* GetParentObject() const;
static already_AddRefed<FlyWebDiscoveryManager> Constructor(const GlobalObject& aGlobal,
ErrorResult& rv);
void ListServices(nsTArray<FlyWebDiscoveredService>& aServices);
uint32_t StartDiscovery(FlyWebDiscoveryCallback& aCallback);
void StopDiscovery(uint32_t aId);
void PairWithService(const nsAString& aServiceId,
FlyWebPairingCallback& callback);
void NotifyDiscoveredServicesChanged();
private:
FlyWebDiscoveryManager(nsISupports* mParent, FlyWebService* aService);
~FlyWebDiscoveryManager();
uint32_t GenerateId() {
return ++mNextId;
}
nsCOMPtr<nsISupports> mParent;
RefPtr<FlyWebService> mService;
uint32_t mNextId;
nsRefPtrHashtable<nsUint32HashKey, FlyWebDiscoveryCallback> mCallbackMap;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_FlyWebDiscoveryManager_h

33
dom/flyweb/FlyWebPublishOptionsIPCSerializer.h
View File

@ -1,33 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_FlyWebPublishOptionsIPCSerialiser_h
#define mozilla_dom_FlyWebPublishOptionsIPCSerialiser_h
#include "mozilla/dom/FlyWebPublishBinding.h"
namespace IPC {
template <>
struct ParamTraits<mozilla::dom::FlyWebPublishOptions>
{
typedef mozilla::dom::FlyWebPublishOptions paramType;
// Function to serialize a FlyWebPublishOptions
static void Write(Message *aMsg, const paramType& aParam)
{
WriteParam(aMsg, aParam.mUiUrl);
}
// Function to de-serialize a FlyWebPublishOptions
static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
{
return ReadParam(aMsg, aIter, &(aResult->mUiUrl));
}
};
}
#endif // mozilla_dom_FlyWebPublishOptionsIPCSerialiser_h

685
dom/flyweb/FlyWebPublishedServer.cpp
View File

@ -1,685 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#include "mozilla/dom/FlyWebPublishedServerIPC.h"
#include "mozilla/dom/FlyWebPublishBinding.h"
#include "mozilla/dom/FlyWebService.h"
#include "mozilla/dom/DocGroup.h"
#include "mozilla/dom/Request.h"
#include "mozilla/dom/FlyWebServerEvents.h"
#include "mozilla/dom/ContentChild.h"
#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"
namespace mozilla {
namespace dom {
static LazyLogModule gFlyWebPublishedServerLog("FlyWebPublishedServer");
#undef LOG_I
#define LOG_I(...) MOZ_LOG(mozilla::dom::gFlyWebPublishedServerLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
#undef LOG_E
#define LOG_E(...) MOZ_LOG(mozilla::dom::gFlyWebPublishedServerLog, mozilla::LogLevel::Error, (__VA_ARGS__))
/******** FlyWebPublishedServer ********/
FlyWebPublishedServer::FlyWebPublishedServer(nsPIDOMWindowInner* aOwner,
const nsAString& aName,
const FlyWebPublishOptions& aOptions)
: mozilla::DOMEventTargetHelper(aOwner)
, mOwnerWindowID(aOwner ? aOwner->WindowID() : 0)
, mName(aName)
, mUiUrl(aOptions.mUiUrl)
, mIsRegistered(true) // Registered by the FlyWebService
{
}
void
FlyWebPublishedServer::LastRelease()
{
// Make sure to unregister to avoid dangling pointers. Use the LastRelease
// hook rather than dtor since calling virtual functions during dtor
// wouldn't do what we want. Also, LastRelease is called earlier than dtor
// for CC objects.
Close();
}
JSObject*
FlyWebPublishedServer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return FlyWebPublishedServerBinding::Wrap(aCx, this, aGivenProto);
}
void
FlyWebPublishedServer::Close()
{
LOG_I("FlyWebPublishedServer::Close(%p)", this);
// Unregister from server.
if (mIsRegistered) {
MOZ_ASSERT(FlyWebService::GetExisting());
FlyWebService::GetExisting()->UnregisterServer(this);
mIsRegistered = false;
DispatchTrustedEvent(NS_LITERAL_STRING("close"));
}
}
void
FlyWebPublishedServer::FireFetchEvent(InternalRequest* aRequest)
{
nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
RefPtr<FlyWebFetchEvent> e = new FlyWebFetchEvent(this,
new Request(global,
aRequest,
nullptr),
aRequest);
e->Init(this);
e->InitEvent(NS_LITERAL_STRING("fetch"), false, false);
DispatchTrustedEvent(e);
}
void
FlyWebPublishedServer::FireWebsocketEvent(InternalRequest* aConnectRequest)
{
nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
RefPtr<FlyWebFetchEvent> e = new FlyWebWebSocketEvent(this,
new Request(global,
aConnectRequest,
nullptr),
aConnectRequest);
e->Init(this);
e->InitEvent(NS_LITERAL_STRING("websocket"), false, false);
DispatchTrustedEvent(e);
}
void
FlyWebPublishedServer::PublishedServerStarted(nsresult aStatus)
{
LOG_I("FlyWebPublishedServer::PublishedServerStarted(%p)", this);
RefPtr<FlyWebPublishPromise> promise = mPublishPromise.Ensure(__func__);
if (NS_SUCCEEDED(aStatus)) {
mPublishPromise.Resolve(this, __func__);
} else {
Close();
mPublishPromise.Reject(aStatus, __func__);
}
}
already_AddRefed<WebSocket>
FlyWebPublishedServer::OnWebSocketAccept(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv)
{
MOZ_ASSERT(aConnectRequest);
LOG_I("FlyWebPublishedServer::OnWebSocketAccept(%p)", this);
nsCOMPtr<nsITransportProvider> provider =
OnWebSocketAcceptInternal(aConnectRequest,
aProtocol,
aRv);
if (aRv.Failed()) {
return nullptr;
}
MOZ_ASSERT(provider);
nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(GetOwner());
AutoJSContext cx;
GlobalObject global(cx, nsGlobalWindowInner::Cast(window)->FastGetGlobalJSObject());
nsAutoCString extensions, negotiatedExtensions;
aConnectRequest->Headers()->
GetFirst(NS_LITERAL_CSTRING("Sec-WebSocket-Extensions"), extensions, aRv);
mozilla::net::ProcessServerWebSocketExtensions(extensions,
negotiatedExtensions);
nsCString url;
aConnectRequest->GetURL(url);
Sequence<nsString> protocols;
if (aProtocol.WasPassed() &&
!protocols.AppendElement(aProtocol.Value(), fallible)) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
return WebSocket::ConstructorCommon(global,
NS_ConvertUTF8toUTF16(url),
protocols,
provider,
negotiatedExtensions,
aRv);
}
/******** FlyWebPublishedServerImpl ********/
NS_IMPL_ISUPPORTS_INHERITED0(FlyWebPublishedServerImpl, mozilla::DOMEventTargetHelper)
FlyWebPublishedServerImpl::FlyWebPublishedServerImpl(nsPIDOMWindowInner* aOwner,
const nsAString& aName,
const FlyWebPublishOptions& aOptions)
: FlyWebPublishedServer(aOwner, aName, aOptions)
, mHttpServer(
new HttpServer(aOwner ?
aOwner->GetDocGroup()->EventTargetFor(TaskCategory::Other) :
GetMainThreadSerialEventTarget()))
{
LOG_I("FlyWebPublishedServerImpl::FlyWebPublishedServerImpl(%p)", this);
}
void
FlyWebPublishedServerImpl::PermissionGranted(bool aGranted)
{
LOG_I("FlyWebPublishedServerImpl::PermissionGranted(%d)", aGranted);
if (!aGranted) {
PublishedServerStarted(NS_ERROR_FAILURE);
return;
}
mHttpServer->Init(-1, Preferences::GetBool("flyweb.use-tls", false), this);
}
void
FlyWebPublishedServerImpl::Close()
{
FlyWebPublishedServer::Close();
if (mMDNSCancelRegister) {
mMDNSCancelRegister->Cancel(NS_BINDING_ABORTED);
mMDNSCancelRegister = nullptr;
}
if (mHttpServer) {
RefPtr<HttpServer> server = mHttpServer.forget();
server->Close();
}
}
void
FlyWebPublishedServerImpl::OnServerStarted(nsresult aStatus)
{
if (NS_SUCCEEDED(aStatus)) {
FlyWebService::GetOrCreate()->StartDiscoveryOf(this);
} else {
PublishedServerStarted(aStatus);
}
}
void
FlyWebPublishedServerImpl::OnFetchResponse(InternalRequest* aRequest,
InternalResponse* aResponse)
{
MOZ_ASSERT(aRequest);
MOZ_ASSERT(aResponse);
LOG_I("FlyWebPublishedServerImpl::OnFetchResponse(%p)", this);
if (mHttpServer) {
mHttpServer->SendResponse(aRequest, aResponse);
}
}
void
FlyWebPublishedServerImpl::OnWebSocketResponse(InternalRequest* aConnectRequest,
InternalResponse* aResponse)
{
MOZ_ASSERT(aConnectRequest);
MOZ_ASSERT(aResponse);
LOG_I("FlyWebPublishedMDNSServer::OnWebSocketResponse(%p)", this);
if (mHttpServer) {
mHttpServer->SendWebSocketResponse(aConnectRequest, aResponse);
}
}
already_AddRefed<nsITransportProvider>
FlyWebPublishedServerImpl::OnWebSocketAcceptInternal(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv)
{
LOG_I("FlyWebPublishedServerImpl::OnWebSocketAcceptInternal(%p)", this);
if (!mHttpServer) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
return mHttpServer->AcceptWebSocket(aConnectRequest,
aProtocol,
aRv);
}
/******** FlyWebPublishedServerChild ********/
FlyWebPublishedServerChild::FlyWebPublishedServerChild(nsPIDOMWindowInner* aOwner,
const nsAString& aName,
const FlyWebPublishOptions& aOptions)
: FlyWebPublishedServer(aOwner, aName, aOptions)
, mActorExists(false)
{
LOG_I("FlyWebPublishedServerChild::FlyWebPublishedServerChild(%p)", this);
// The matching release happens when the actor is destroyed, in
// ContentChild::DeallocPFlyWebPublishedServerChild
NS_ADDREF_THIS();
}
void
FlyWebPublishedServerChild::PermissionGranted(bool aGranted)
{
if (!aGranted) {
PublishedServerStarted(NS_ERROR_FAILURE);
return;
}
mActorExists = true;
FlyWebPublishOptions options;
options.mUiUrl = mUiUrl;
// Proceed with initialization.
ContentChild::GetSingleton()->
SendPFlyWebPublishedServerConstructor(this, mName, options);
}
mozilla::ipc::IPCResult
FlyWebPublishedServerChild::RecvServerReady(const nsresult& aStatus)
{
LOG_I("FlyWebPublishedServerChild::RecvServerReady(%p)", this);
MOZ_ASSERT(mActorExists);
PublishedServerStarted(aStatus);
return IPC_OK();
}
mozilla::ipc::IPCResult
FlyWebPublishedServerChild::RecvServerClose()
{
LOG_I("FlyWebPublishedServerChild::RecvServerClose(%p)", this);
MOZ_ASSERT(mActorExists);
Close();
return IPC_OK();
}
mozilla::ipc::IPCResult
FlyWebPublishedServerChild::RecvFetchRequest(const IPCInternalRequest& aRequest,
const uint64_t& aRequestId)
{
LOG_I("FlyWebPublishedServerChild::RecvFetchRequest(%p)", this);
MOZ_ASSERT(mActorExists);
RefPtr<InternalRequest> request = new InternalRequest(aRequest);
mPendingRequests.Put(request, aRequestId);
FireFetchEvent(request);
return IPC_OK();
}
mozilla::ipc::IPCResult
FlyWebPublishedServerChild::RecvWebSocketRequest(const IPCInternalRequest& aRequest,
const uint64_t& aRequestId,
PTransportProviderChild* aProvider)
{
LOG_I("FlyWebPublishedServerChild::RecvWebSocketRequest(%p)", this);
MOZ_ASSERT(mActorExists);
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 IPC_OK();
}
void
FlyWebPublishedServerChild::ActorDestroy(ActorDestroyReason aWhy)
{
LOG_I("FlyWebPublishedServerChild::ActorDestroy(%p)", this);
mActorExists = false;
}
void
FlyWebPublishedServerChild::OnFetchResponse(InternalRequest* aRequest,
InternalResponse* aResponse)
{
LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p)", this);
if (!mActorExists) {
LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p) - No actor!", this);
return;
}
uint64_t id = mPendingRequests.Get(aRequest);
MOZ_ASSERT(id);
mPendingRequests.Remove(aRequest);
IPCInternalResponse ipcResp;
UniquePtr<mozilla::ipc::AutoIPCStream> autoStream;
nsIContentChild* cc = static_cast<ContentChild*>(Manager());
aResponse->ToIPC(&ipcResp, cc, autoStream);
Unused << SendFetchResponse(ipcResp, id);
if (autoStream) {
autoStream->TakeOptionalValue();
}
}
already_AddRefed<nsITransportProvider>
FlyWebPublishedServerChild::OnWebSocketAcceptInternal(InternalRequest* aRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv)
{
LOG_I("FlyWebPublishedServerChild::OnWebSocketAcceptInternal(%p)", this);
if (!mActorExists) {
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()->
GetFirst(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* aRequest,
InternalResponse* aResponse)
{
LOG_I("FlyWebPublishedServerChild::OnFetchResponse(%p)", this);
if (!mActorExists) {
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;
nsIContentChild* cc = static_cast<ContentChild*>(Manager());
aResponse->ToIPC(&ipcResp, cc, autoStream);
Unused << SendWebSocketResponse(ipcResp, id);
if (autoStream) {
autoStream->TakeOptionalValue();
}
}
void
FlyWebPublishedServerChild::Close()
{
LOG_I("FlyWebPublishedServerChild::Close(%p)", this);
FlyWebPublishedServer::Close();
if (mActorExists) {
LOG_I("FlyWebPublishedServerChild::Close - sending __delete__ (%p)", this);
Send__delete__(this);
}
}
/******** FlyWebPublishedServerParent ********/
NS_IMPL_ISUPPORTS(FlyWebPublishedServerParent, nsIDOMEventListener)
FlyWebPublishedServerParent::FlyWebPublishedServerParent(const nsAString& aName,
const FlyWebPublishOptions& aOptions)
: mActorDestroyed(false)
, mNextRequestId(1)
{
LOG_I("FlyWebPublishedServerParent::FlyWebPublishedServerParent(%p)", this);
RefPtr<FlyWebService> service = FlyWebService::GetOrCreate();
if (!service) {
Unused << SendServerReady(NS_ERROR_FAILURE);
return;
}
RefPtr<FlyWebPublishPromise> mozPromise =
service->PublishServer(aName, aOptions, nullptr);
if (!mozPromise) {
Unused << SendServerReady(NS_ERROR_FAILURE);
return;
}
RefPtr<FlyWebPublishedServerParent> self = this;
mozPromise->Then(
// Non DocGroup-version for the task in parent.
GetMainThreadSerialEventTarget(),
__func__,
[this, self] (FlyWebPublishedServer* aServer) {
mPublishedServer = static_cast<FlyWebPublishedServerImpl*>(aServer);
if (mActorDestroyed) {
mPublishedServer->Close();
return;
}
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);
},
[this, self] (nsresult aStatus) {
MOZ_ASSERT(NS_FAILED(aStatus));
if (!mActorDestroyed) {
Unused << SendServerReady(aStatus);
}
});
}
NS_IMETHODIMP
FlyWebPublishedServerParent::HandleEvent(nsIDOMEvent* aEvent)
{
if (mActorDestroyed) {
return NS_OK;
}
nsAutoString type;
aEvent->GetType(type);
if (type.EqualsLiteral("close")) {
Unused << SendServerClose();
return NS_OK;
}
if (type.EqualsLiteral("fetch")) {
RefPtr<InternalRequest> request =
static_cast<FlyWebFetchEvent*>(aEvent)->Request()->GetInternalRequest();
uint64_t id = mNextRequestId++;
mPendingRequests.Put(id, request);
IPCInternalRequest ipcReq;
request->ToIPC(&ipcReq);
Unused << SendFetchRequest(ipcReq, id);
return NS_OK;
}
if (type.EqualsLiteral("websocket")) {
RefPtr<InternalRequest> request =
static_cast<FlyWebWebSocketEvent*>(aEvent)->Request()->GetInternalRequest();
uint64_t id = mNextRequestId++;
mPendingRequests.Put(id, request);
nsTArray<PNeckoParent*> neckoParents;
Manager()->ManagedPNeckoParent(neckoParents);
if (neckoParents.Length() != 1) {
MOZ_CRASH("Expected exactly 1 PNeckoParent instance per PNeckoChild");
}
RefPtr<TransportProviderParent> provider =
static_cast<TransportProviderParent*>(
neckoParents[0]->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;
}
mozilla::ipc::IPCResult
FlyWebPublishedServerParent::RecvFetchResponse(const IPCInternalResponse& aResponse,
const uint64_t& aRequestId)
{
MOZ_ASSERT(!mActorDestroyed);
RefPtr<InternalRequest> request;
mPendingRequests.Remove(aRequestId, getter_AddRefs(request));
if (!request) {
static_cast<ContentParent*>(Manager())->KillHard("unknown request id");
return IPC_FAIL_NO_REASON(this);
}
RefPtr<InternalResponse> response = InternalResponse::FromIPC(aResponse);
mPublishedServer->OnFetchResponse(request, response);
return IPC_OK();
}
mozilla::ipc::IPCResult
FlyWebPublishedServerParent::RecvWebSocketResponse(const IPCInternalResponse& aResponse,
const uint64_t& aRequestId)
{
MOZ_ASSERT(!mActorDestroyed);
mPendingTransportProviders.Remove(aRequestId);
RefPtr<InternalRequest> request;
mPendingRequests.Remove(aRequestId, getter_AddRefs(request));
if (!request) {
static_cast<ContentParent*>(Manager())->KillHard("unknown websocket request id");
return IPC_FAIL_NO_REASON(this);
}
RefPtr<InternalResponse> response = InternalResponse::FromIPC(aResponse);
mPublishedServer->OnWebSocketResponse(request, response);
return IPC_OK();
}
mozilla::ipc::IPCResult
FlyWebPublishedServerParent::RecvWebSocketAccept(const nsString& aProtocol,
const uint64_t& aRequestId)
{
MOZ_ASSERT(!mActorDestroyed);
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 IPC_FAIL_NO_REASON(this);
}
Optional<nsAString> protocol;
if (!aProtocol.IsVoid()) {
protocol = &aProtocol;
}
ErrorResult result;
nsCOMPtr<nsITransportProvider> providerServer =
mPublishedServer->OnWebSocketAcceptInternal(request, protocol, result);
if (result.Failed()) {
return IPC_FAIL_NO_REASON(this);
}
DebugOnly<nsresult> rv = providerServer->SetListener(providerIPC);
MOZ_ASSERT(NS_SUCCEEDED(rv));
return IPC_OK();
}
void
FlyWebPublishedServerParent::ActorDestroy(ActorDestroyReason aWhy)
{
LOG_I("FlyWebPublishedServerParent::ActorDestroy(%p)", this);
mActorDestroyed = true;
}
mozilla::ipc::IPCResult
FlyWebPublishedServerParent::Recv__delete__()
{
LOG_I("FlyWebPublishedServerParent::Recv__delete__(%p)", this);
MOZ_ASSERT(!mActorDestroyed);
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();
mPublishedServer = nullptr;
}
return IPC_OK();
}
} // namespace dom
} // namespace mozilla

109
dom/flyweb/FlyWebPublishedServer.h
View File

@ -1,109 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_FlyWebPublishedServer_h
#define mozilla_dom_FlyWebPublishedServer_h
#include "mozilla/DOMEventTargetHelper.h"
#include "mozilla/MozPromise.h"
class nsPIDOMWindowInner;
class nsITransportProvider;
namespace mozilla {
class ErrorResult;
namespace dom {
class InternalResponse;
class InternalRequest;
class WebSocket;
struct FlyWebPublishOptions;
class FlyWebPublishedServer;
typedef MozPromise<RefPtr<FlyWebPublishedServer>, nsresult, false>
FlyWebPublishPromise;
class FlyWebPublishedServer : public mozilla::DOMEventTargetHelper
{
public:
FlyWebPublishedServer(nsPIDOMWindowInner* aOwner,
const nsAString& aName,
const FlyWebPublishOptions& aOptions);
virtual void LastRelease() override;
virtual JSObject* WrapObject(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override;
uint64_t OwnerWindowID() const {
return mOwnerWindowID;
}
void GetName(nsAString& aName)
{
aName = mName;
}
nsAString& Name()
{
return mName;
}
void GetUiUrl(nsAString& aUiUrl)
{
aUiUrl = mUiUrl;
}
virtual void PermissionGranted(bool aGranted) = 0;
virtual void OnFetchResponse(InternalRequest* aRequest,
InternalResponse* aResponse) = 0;
already_AddRefed<WebSocket>
OnWebSocketAccept(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv);
virtual void OnWebSocketResponse(InternalRequest* aConnectRequest,
InternalResponse* aResponse) = 0;
virtual already_AddRefed<nsITransportProvider>
OnWebSocketAcceptInternal(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv) = 0;
virtual void Close();
void FireFetchEvent(InternalRequest* aRequest);
void FireWebsocketEvent(InternalRequest* aConnectRequest);
void PublishedServerStarted(nsresult aStatus);
IMPL_EVENT_HANDLER(fetch)
IMPL_EVENT_HANDLER(websocket)
IMPL_EVENT_HANDLER(close)
already_AddRefed<FlyWebPublishPromise>
GetPublishPromise()
{
return mPublishPromise.Ensure(__func__);
}
protected:
virtual ~FlyWebPublishedServer()
{
MOZ_ASSERT(!mIsRegistered, "Subclass dtor forgot to call Close()");
}
uint64_t mOwnerWindowID;
MozPromiseHolder<FlyWebPublishPromise> mPublishPromise;
nsString mName;
nsString mUiUrl;
bool mIsRegistered;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_FlyWebPublishedServer_h

172
dom/flyweb/FlyWebPublishedServerIPC.h
View File

@ -1,172 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_FlyWebPublishedServerIPC_h
#define mozilla_dom_FlyWebPublishedServerIPC_h
#include "HttpServer.h"
#include "mozilla/dom/FlyWebPublishedServer.h"
#include "mozilla/dom/PFlyWebPublishedServerParent.h"
#include "mozilla/dom/PFlyWebPublishedServerChild.h"
#include "mozilla/MozPromise.h"
#include "nsICancelable.h"
#include "nsIDOMEventListener.h"
#include "nsISupportsImpl.h"
class nsPIDOMWindowInner;
namespace mozilla {
namespace net {
class TransportProviderParent;
class TransportProviderChild;
}
namespace dom {
class FlyWebPublishedServerParent;
class FlyWebPublishedServerImpl final : public FlyWebPublishedServer
, public HttpServerListener
{
public:
FlyWebPublishedServerImpl(nsPIDOMWindowInner* aOwner,
const nsAString& aName,
const FlyWebPublishOptions& aOptions);
NS_DECL_ISUPPORTS_INHERITED
int32_t Port()
{
return mHttpServer ? mHttpServer->GetPort() : 0;
}
void GetCertKey(nsACString& aKey) {
if (mHttpServer) {
mHttpServer->GetCertKey(aKey);
} else {
aKey.Truncate();
}
}
virtual void PermissionGranted(bool aGranted) override;
virtual void OnFetchResponse(InternalRequest* aRequest,
InternalResponse* aResponse) override;
virtual void OnWebSocketResponse(InternalRequest* aConnectRequest,
InternalResponse* aResponse) override;
virtual already_AddRefed<nsITransportProvider>
OnWebSocketAcceptInternal(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv) override;
void SetCancelRegister(nsICancelable* aCancelRegister)
{
mMDNSCancelRegister = aCancelRegister;
}
virtual void Close() override;
// HttpServerListener
virtual void OnServerStarted(nsresult aStatus) override;
virtual void OnRequest(InternalRequest* aRequest) override
{
FireFetchEvent(aRequest);
}
virtual void OnWebSocket(InternalRequest* aConnectRequest) override
{
FireWebsocketEvent(aConnectRequest);
}
virtual void OnServerClose() override
{
mHttpServer = nullptr;
Close();
}
private:
~FlyWebPublishedServerImpl() {}
RefPtr<HttpServer> mHttpServer;
nsCOMPtr<nsICancelable> mMDNSCancelRegister;
RefPtr<FlyWebPublishedServerParent> mServerParent;
};
class FlyWebPublishedServerChild final : public FlyWebPublishedServer
, public PFlyWebPublishedServerChild
{
public:
FlyWebPublishedServerChild(nsPIDOMWindowInner* aOwner,
const nsAString& aName,
const FlyWebPublishOptions& aOptions);
virtual void PermissionGranted(bool aGranted) override;
virtual mozilla::ipc::IPCResult RecvServerReady(const nsresult& aStatus) override;
virtual mozilla::ipc::IPCResult RecvServerClose() override;
virtual mozilla::ipc::IPCResult RecvFetchRequest(const IPCInternalRequest& aRequest,
const uint64_t& aRequestId) override;
virtual mozilla::ipc::IPCResult RecvWebSocketRequest(const IPCInternalRequest& aRequest,
const uint64_t& aRequestId,
PTransportProviderChild* aProvider) override;
virtual void OnFetchResponse(InternalRequest* aRequest,
InternalResponse* aResponse) override;
virtual void OnWebSocketResponse(InternalRequest* aConnectRequest,
InternalResponse* aResponse) override;
virtual already_AddRefed<nsITransportProvider>
OnWebSocketAcceptInternal(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv) override;
virtual void Close() override;
virtual void ActorDestroy(ActorDestroyReason aWhy) override;
private:
~FlyWebPublishedServerChild() {}
nsDataHashtable<nsRefPtrHashKey<InternalRequest>, uint64_t> mPendingRequests;
nsRefPtrHashtable<nsUint64HashKey, TransportProviderChild>
mPendingTransportProviders;
bool mActorExists;
};
class FlyWebPublishedServerParent final : public PFlyWebPublishedServerParent
, public nsIDOMEventListener
{
public:
FlyWebPublishedServerParent(const nsAString& aName,
const FlyWebPublishOptions& aOptions);
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMEVENTLISTENER
private:
virtual void
ActorDestroy(ActorDestroyReason aWhy) override;
virtual mozilla::ipc::IPCResult
Recv__delete__() override;
virtual mozilla::ipc::IPCResult
RecvFetchResponse(const IPCInternalResponse& aResponse,
const uint64_t& aRequestId) override;
virtual mozilla::ipc::IPCResult
RecvWebSocketResponse(const IPCInternalResponse& aResponse,
const uint64_t& aRequestId) override;
virtual mozilla::ipc::IPCResult
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;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_FlyWebPublishedServerIPC_h

147
dom/flyweb/FlyWebServerEvents.cpp
View File

@ -1,147 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#include "mozilla/dom/EventBinding.h"
#include "mozilla/dom/FlyWebFetchEventBinding.h"
#include "mozilla/dom/FlyWebPublishedServer.h"
#include "mozilla/dom/FlyWebServerEvents.h"
#include "mozilla/dom/FlyWebWebSocketEventBinding.h"
#include "mozilla/dom/Nullable.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/Response.h"
namespace mozilla {
namespace dom {
NS_IMPL_CYCLE_COLLECTION_CLASS(FlyWebFetchEvent)
NS_IMPL_ADDREF_INHERITED(FlyWebFetchEvent, Event)
NS_IMPL_RELEASE_INHERITED(FlyWebFetchEvent, Event)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(FlyWebFetchEvent, Event)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRequest)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(FlyWebFetchEvent, Event)
NS_IMPL_CYCLE_COLLECTION_TRACE_END
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(FlyWebFetchEvent, Event)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mRequest)
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(FlyWebFetchEvent)
NS_INTERFACE_MAP_END_INHERITING(Event)
FlyWebFetchEvent::FlyWebFetchEvent(FlyWebPublishedServer* aServer,
class Request* aRequest,
InternalRequest* aInternalRequest)
: Event(aServer, nullptr, nullptr)
, mRequest(aRequest)
, mInternalRequest(aInternalRequest)
, mServer(aServer)
, mResponded(false)
{
MOZ_ASSERT(aServer);
MOZ_ASSERT(aRequest);
MOZ_ASSERT(aInternalRequest);
}
FlyWebFetchEvent::~FlyWebFetchEvent()
{
}
JSObject*
FlyWebFetchEvent::WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return FlyWebFetchEventBinding::Wrap(aCx, this, aGivenProto);
}
void
FlyWebFetchEvent::RespondWith(Promise& aArg, ErrorResult& aRv)
{
if (mResponded) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return;
}
mResponded = true;
aArg.AppendNativeHandler(this);
}
void
FlyWebFetchEvent::ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue)
{
RefPtr<Response> response;
if (aValue.isObject()) {
UNWRAP_OBJECT(Response, &aValue.toObject(), response);
}
RefPtr<InternalResponse> intResponse;
if (response && response->Type() != ResponseType::Opaque) {
intResponse = response->GetInternalResponse();
IgnoredErrorResult rv;
response->SetBodyUsed(aCx, rv);
if (NS_WARN_IF(rv.Failed())) {
// Let's nullify the response. In this way we end up using a NetworkError
// response.
intResponse = nullptr;
}
}
if (!intResponse) {
intResponse = InternalResponse::NetworkError(NS_ERROR_FAILURE);
}
NotifyServer(intResponse);
}
void
FlyWebFetchEvent::NotifyServer(InternalResponse* aResponse)
{
mServer->OnFetchResponse(mInternalRequest, aResponse);
}
void
FlyWebFetchEvent::RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue)
{
RefPtr<InternalResponse> err = InternalResponse::NetworkError(NS_ERROR_FAILURE);
NotifyServer(err);
}
JSObject*
FlyWebWebSocketEvent::WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return FlyWebWebSocketEventBinding::Wrap(aCx, this, aGivenProto);
}
already_AddRefed<WebSocket>
FlyWebWebSocketEvent::Accept(const Optional<nsAString>& aProtocol,
ErrorResult& aRv)
{
if (mResponded) {
aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
mResponded = true;
return mServer->OnWebSocketAccept(mInternalRequest, aProtocol, aRv);
}
void
FlyWebWebSocketEvent::NotifyServer(InternalResponse* aResponse)
{
mServer->OnWebSocketResponse(mInternalRequest, aResponse);
}
} // namespace dom
} // namespace mozilla

88
dom/flyweb/FlyWebServerEvents.h
View File

@ -1,88 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_FlyWebFetchEvent_h
#define mozilla_dom_FlyWebFetchEvent_h
#include "mozilla/Attributes.h"
#include "mozilla/ErrorResult.h"
#include "mozilla/dom/BindingUtils.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/FlyWebFetchEventBinding.h"
#include "mozilla/dom/PromiseNativeHandler.h"
#include "mozilla/dom/WebSocket.h"
struct JSContext;
namespace mozilla {
namespace dom {
class Request;
class Response;
class FlyWebPublishedServer;
class InternalRequest;
class InternalResponse;
class FlyWebFetchEvent : public Event
, public PromiseNativeHandler
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(FlyWebFetchEvent, Event)
virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
virtual void
ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;
virtual void
RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;
class Request* Request() const
{
return mRequest;
}
void RespondWith(Promise& aArg, ErrorResult& aRv);
FlyWebFetchEvent(FlyWebPublishedServer* aServer,
class Request* aRequest,
InternalRequest* aInternalRequest);
protected:
virtual ~FlyWebFetchEvent();
virtual void NotifyServer(InternalResponse* aResponse);
RefPtr<class Request> mRequest;
RefPtr<InternalRequest> mInternalRequest;
RefPtr<FlyWebPublishedServer> mServer;
bool mResponded;
};
class FlyWebWebSocketEvent final : public FlyWebFetchEvent
{
public:
FlyWebWebSocketEvent(FlyWebPublishedServer* aServer,
class Request* aRequest,
InternalRequest* aInternalRequest)
: FlyWebFetchEvent(aServer, aRequest, aInternalRequest)
{}
virtual JSObject* WrapObjectInternal(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override;
already_AddRefed<WebSocket> Accept(const Optional<nsAString>& aProtocol,
ErrorResult& aRv);
private:
~FlyWebWebSocketEvent() {};
virtual void NotifyServer(InternalResponse* aResponse) override;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_FlyWebFetchEvent_h

1331
dom/flyweb/FlyWebService.cpp
View File

File diff suppressed because it is too large Load Diff

113
dom/flyweb/FlyWebService.h
View File

@ -1,113 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_FlyWebService_h
#define mozilla_dom_FlyWebService_h
#include "nsISupportsImpl.h"
#include "mozilla/ErrorResult.h"
#include "nsIProtocolHandler.h"
#include "nsDataHashtable.h"
#include "nsClassHashtable.h"
#include "nsIObserver.h"
#include "mozilla/MozPromise.h"
#include "mozilla/ReentrantMonitor.h"
#include "mozilla/dom/FlyWebDiscoveryManagerBinding.h"
#include "nsITimer.h"
#include "nsICancelable.h"
#include "nsIDNSServiceDiscovery.h"
class nsPIDOMWindowInner;
class nsIProxyInfo;
class nsISocketTransport;
namespace mozilla {
namespace dom {
struct FlyWebPublishOptions;
struct FlyWebFilter;
class FlyWebPublishedServer;
class FlyWebPublishedServerImpl;
class FlyWebPairingCallback;
class FlyWebDiscoveryManager;
class FlyWebMDNSService;
typedef MozPromise<RefPtr<FlyWebPublishedServer>, nsresult, false>
FlyWebPublishPromise;
class FlyWebService final : public nsIObserver
{
friend class FlyWebMDNSService;
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOBSERVER
static FlyWebService* GetExisting();
static FlyWebService* GetOrCreate();
static already_AddRefed<FlyWebService> GetOrCreateAddRefed()
{
return do_AddRef(GetOrCreate());
}
already_AddRefed<FlyWebPublishPromise>
PublishServer(const nsAString& aName,
const FlyWebPublishOptions& aOptions,
nsPIDOMWindowInner* aWindow);
void UnregisterServer(FlyWebPublishedServer* aServer);
bool HasConnectionOrServer(uint64_t aWindowID);
void ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices);
void PairWithService(const nsAString& aServiceId, FlyWebPairingCallback& aCallback);
nsresult CreateTransportForHost(const char **types,
uint32_t typeCount,
const nsACString &host,
int32_t port,
const nsACString &hostRoute,
int32_t portRoute,
nsIProxyInfo *proxyInfo,
nsISocketTransport **result);
already_AddRefed<FlyWebPublishedServer> FindPublishedServerByName(
const nsAString& aName);
void RegisterDiscoveryManager(FlyWebDiscoveryManager* aDiscoveryManager);
void UnregisterDiscoveryManager(FlyWebDiscoveryManager* aDiscoveryManager);
// Should only be called by FlyWebPublishedServerImpl
void StartDiscoveryOf(FlyWebPublishedServerImpl* aServer);
private:
FlyWebService();
~FlyWebService();
ErrorResult Init();
void NotifyDiscoveredServicesChanged();
// Might want to make these hashes for perf
nsTArray<FlyWebPublishedServer*> mServers;
RefPtr<FlyWebMDNSService> mMDNSHttpService;
RefPtr<FlyWebMDNSService> mMDNSFlywebService;
struct PairedInfo
{
FlyWebPairedService mService;
nsCOMPtr<nsIDNSServiceInfo> mDNSServiceInfo;
};
nsClassHashtable<nsCStringHashKey, PairedInfo>
mPairedServiceTable;
ReentrantMonitor mMonitor; // Protecting mPairedServiceTable
nsTHashtable<nsPtrHashKey<FlyWebDiscoveryManager>> mDiscoveryManagerTable;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_FlyWebService_h

1317
dom/flyweb/HttpServer.cpp
View File

File diff suppressed because it is too large Load Diff

195
dom/flyweb/HttpServer.h
View File

@ -1,195 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=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/. */
#ifndef mozilla_dom_HttpServer_h
#define mozilla_dom_HttpServer_h
#include "nsISupportsImpl.h"
#include "mozilla/DOMEventTargetHelper.h"
#include "nsITLSServerSocket.h"
#include "nsIAsyncInputStream.h"
#include "nsIAsyncOutputStream.h"
#include "mozilla/Variant.h"
#include "nsIRequestObserver.h"
#include "mozilla/MozPromise.h"
#include "nsITransportProvider.h"
#include "nsILocalCertService.h"
class nsIX509Cert;
class nsISerialEventTarget;
namespace mozilla {
namespace dom {
extern bool
ContainsToken(const nsCString& aList, const nsCString& aToken);
class InternalRequest;
class InternalResponse;
class HttpServerListener
{
public:
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
virtual void OnServerStarted(nsresult aStatus) = 0;
virtual void OnRequest(InternalRequest* aRequest) = 0;
virtual void OnWebSocket(InternalRequest* aConnectRequest) = 0;
virtual void OnServerClose() = 0;
};
class HttpServer final : public nsIServerSocketListener,
public nsILocalCertGetCallback
{
public:
explicit HttpServer(nsISerialEventTarget* aEventTarget);
NS_DECL_ISUPPORTS
NS_DECL_NSISERVERSOCKETLISTENER
NS_DECL_NSILOCALCERTGETCALLBACK
void Init(int32_t aPort, bool aHttps, HttpServerListener* aListener);
void SendResponse(InternalRequest* aRequest, InternalResponse* aResponse);
already_AddRefed<nsITransportProvider>
AcceptWebSocket(InternalRequest* aConnectRequest,
const Optional<nsAString>& aProtocol,
ErrorResult& aRv);
void SendWebSocketResponse(InternalRequest* aConnectRequest,
InternalResponse* aResponse);
void Close();
void GetCertKey(nsACString& aKey);
int32_t GetPort()
{
return mPort;
}
private:
~HttpServer();
nsresult StartServerSocket(nsIX509Cert* aCert);
void NotifyStarted(nsresult aStatus);
class TransportProvider final : public nsITransportProvider
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSITRANSPORTPROVIDER
void SetTransport(nsISocketTransport* aTransport,
nsIAsyncInputStream* aInput,
nsIAsyncOutputStream* aOutput);
private:
virtual ~TransportProvider();
void MaybeNotify();
nsCOMPtr<nsIHttpUpgradeListener> mListener;
nsCOMPtr<nsISocketTransport> mTransport;
nsCOMPtr<nsIAsyncInputStream> mInput;
nsCOMPtr<nsIAsyncOutputStream> mOutput;
};
class Connection final : public nsIInputStreamCallback
, public nsIOutputStreamCallback
, public nsITLSServerSecurityObserver
{
public:
Connection(nsISocketTransport* aTransport,
HttpServer* aServer,
nsresult& rv);
NS_DECL_ISUPPORTS
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSIOUTPUTSTREAMCALLBACK
NS_DECL_NSITLSSERVERSECURITYOBSERVER
bool TryHandleResponse(InternalRequest* aRequest,
InternalResponse* aResponse);
already_AddRefed<nsITransportProvider>
HandleAcceptWebSocket(const Optional<nsAString>& aProtocol,
ErrorResult& aRv);
void HandleWebSocketResponse(InternalResponse* aResponse);
bool HasPendingWebSocketRequest(InternalRequest* aRequest)
{
return aRequest == mPendingWebSocketRequest;
}
void Close();
private:
~Connection();
void SetSecurityObserver(bool aListen);
static nsresult ReadSegmentsFunc(nsIInputStream* aIn,
void* aClosure,
const char* aBuffer,
uint32_t aToOffset,
uint32_t aCount,
uint32_t* aWriteCount);
nsresult ConsumeInput(const char*& aBuffer,
const char* aEnd);
nsresult ConsumeLine(const char* aBuffer,
size_t aLength);
void MaybeAddPendingHeader();
void QueueResponse(InternalResponse* aResponse);
RefPtr<HttpServer> mServer;
nsCOMPtr<nsISocketTransport> mTransport;
nsCOMPtr<nsIAsyncInputStream> mInput;
nsCOMPtr<nsIAsyncOutputStream> mOutput;
enum { eRequestLine, eHeaders, eBody, ePause } mState;
RefPtr<InternalRequest> mPendingReq;
uint32_t mPendingReqVersion;
nsCString mInputBuffer;
nsCString mPendingHeaderName;
nsCString mPendingHeaderValue;
uint32_t mRemainingBodySize;
nsCOMPtr<nsIAsyncOutputStream> mCurrentRequestBody;
bool mCloseAfterRequest;
typedef Pair<RefPtr<InternalRequest>,
RefPtr<InternalResponse>> PendingRequest;
nsTArray<PendingRequest> mPendingRequests;
RefPtr<MozPromise<nsresult, bool, false>> mOutputCopy;
RefPtr<InternalRequest> mPendingWebSocketRequest;
RefPtr<TransportProvider> mWebSocketTransportProvider;
struct OutputBuffer {
nsCString mString;
nsCOMPtr<nsIInputStream> mStream;
bool mChunked;
};
nsTArray<OutputBuffer> mOutputBuffers;
};
friend class Connection;
RefPtr<HttpServerListener> mListener;
nsCOMPtr<nsIServerSocket> mServerSocket;
nsCOMPtr<nsIX509Cert> mCert;
nsTArray<RefPtr<Connection>> mConnections;
int32_t mPort;
bool mHttps;
const nsCOMPtr<nsISerialEventTarget> mEventTarget;
};
} // namespace dom
} // namespace mozilla
#endif // mozilla_dom_HttpServer_h

39
dom/flyweb/PFlyWebPublishedServer.ipdl
View File

@ -1,39 +0,0 @@
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et ft=cpp : */
/* 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 protocol PContent;
include protocol PChildToParentStream;
include protocol PParentToChildStream;
include protocol PFileDescriptorSet;
include protocol PTransportProvider;
include FetchTypes;
include ChannelInfo;
include PBackgroundSharedTypes;
namespace mozilla {
namespace dom {
async protocol PFlyWebPublishedServer
{
manager PContent;
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
} // namespace mozilla

45
dom/flyweb/moz.build
View File

@ -1,45 +0,0 @@
# -*- 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/.
with Files("**"):
BUG_COMPONENT = ("Core", "DOM: Flyweb")
EXPORTS.mozilla.dom += [
'FlyWebDiscoveryManager.h',
'FlyWebPublishedServer.h',
'FlyWebPublishedServerIPC.h',
'FlyWebPublishOptionsIPCSerializer.h',
'FlyWebServerEvents.h',
'FlyWebService.h',
'HttpServer.h',
]
UNIFIED_SOURCES += [
'FlyWebDiscoveryManager.cpp',
'FlyWebPublishedServer.cpp',
'FlyWebServerEvents.cpp',
'FlyWebService.cpp',
'HttpServer.cpp'
]
IPDL_SOURCES += [
'PFlyWebPublishedServer.ipdl',
]
FINAL_LIBRARY = 'xul'
LOCAL_INCLUDES += [
'/dom/base',
'/netwerk/base',
'/netwerk/dns',
'/netwerk/protocol/websocket',
'/xpcom/io'
]
include('/ipc/chromium/chromium-config.mozbuild')
if CONFIG['GNU_CXX']:
CXXFLAGS += ['-Wshadow']

17
dom/ipc/ContentChild.cpp
View File

@ -32,7 +32,6 @@
#include "mozilla/dom/DocGroup.h"
#include "mozilla/dom/ExternalHelperAppChild.h"
#include "mozilla/dom/FileCreatorHelper.h"
#include "mozilla/dom/FlyWebPublishedServerIPC.h"
#include "mozilla/dom/GetFilesHelper.h"
#include "mozilla/dom/IPCBlobUtils.h"
#include "mozilla/dom/MemoryReportRequest.h"
@ -1893,22 +1892,6 @@ ContentChild::DeallocPPresentationChild(PPresentationChild* aActor)
return true;
}
PFlyWebPublishedServerChild*
ContentChild::AllocPFlyWebPublishedServerChild(const nsString& name,
const FlyWebPublishOptions& params)
{
MOZ_CRASH("We should never be manually allocating PFlyWebPublishedServerChild actors");
return nullptr;
}
bool
ContentChild::DeallocPFlyWebPublishedServerChild(PFlyWebPublishedServerChild* aActor)
{
RefPtr<FlyWebPublishedServerChild> actor =
dont_AddRef(static_cast<FlyWebPublishedServerChild*>(aActor));
return true;
}
mozilla::ipc::IPCResult
ContentChild::RecvNotifyPresentationReceiverLaunched(PBrowserChild* aIframe,
const nsString& aSessionId)

6
dom/ipc/ContentChild.h
View File

@ -321,12 +321,6 @@ public:
virtual bool DeallocPPresentationChild(PPresentationChild* aActor) override;
virtual PFlyWebPublishedServerChild*
AllocPFlyWebPublishedServerChild(const nsString& name,
const FlyWebPublishOptions& params) override;
virtual bool DeallocPFlyWebPublishedServerChild(PFlyWebPublishedServerChild* aActor) override;
virtual mozilla::ipc::IPCResult
RecvNotifyPresentationReceiverLaunched(PBrowserChild* aIframe,
const nsString& aSessionId) override;

18
dom/ipc/ContentParent.cpp
View File

@ -56,7 +56,6 @@
#include "mozilla/dom/PresentationParent.h"
#include "mozilla/dom/PPresentationParent.h"
#include "mozilla/dom/PushNotifier.h"
#include "mozilla/dom/FlyWebPublishedServerIPC.h"
#include "mozilla/dom/quota/QuotaManagerService.h"
#include "mozilla/dom/time/DateCacheCleaner.h"
#include "mozilla/dom/URLClassifierParent.h"
@ -3456,23 +3455,6 @@ ContentParent::RecvPPresentationConstructor(PPresentationParent* aActor)
return IPC_OK();
}
PFlyWebPublishedServerParent*
ContentParent::AllocPFlyWebPublishedServerParent(const nsString& name,
const FlyWebPublishOptions& params)
{
RefPtr<FlyWebPublishedServerParent> actor =
new FlyWebPublishedServerParent(name, params);
return actor.forget().take();
}
bool
ContentParent::DeallocPFlyWebPublishedServerParent(PFlyWebPublishedServerParent* aActor)
{
RefPtr<FlyWebPublishedServerParent> actor =
dont_AddRef(static_cast<FlyWebPublishedServerParent*>(aActor));
return true;
}
PSpeechSynthesisParent*
ContentParent::AllocPSpeechSynthesisParent()
{

6
dom/ipc/ContentParent.h
View File

@ -943,12 +943,6 @@ private:
virtual mozilla::ipc::IPCResult RecvPPresentationConstructor(PPresentationParent* aActor) override;
virtual PFlyWebPublishedServerParent*
AllocPFlyWebPublishedServerParent(const nsString& name,
const FlyWebPublishOptions& params) override;
virtual bool DeallocPFlyWebPublishedServerParent(PFlyWebPublishedServerParent* aActor) override;
virtual PSpeechSynthesisParent* AllocPSpeechSynthesisParent() override;
virtual bool

5
dom/ipc/PContent.ipdl
View File

@ -43,7 +43,6 @@ include protocol PURLClassifier;
include protocol PURLClassifierLocal;
include protocol PVRManager;
include protocol PVideoDecoderManager;
include protocol PFlyWebPublishedServer;
include protocol PProfiler;
include protocol PScriptCache;
include DOMTypes;
@ -90,7 +89,6 @@ using mozilla::DataStorageType from "ipc/DataStorageIPCUtils.h";
using mozilla::OriginAttributes from "mozilla/ipc/BackgroundUtils.h";
using struct mozilla::layers::TextureFactoryIdentifier from "mozilla/layers/CompositorTypes.h";
using mozilla::layers::CompositorOptions from "mozilla/layers/CompositorOptions.h";
using struct mozilla::dom::FlyWebPublishOptions from "mozilla/dom/FlyWebPublishOptionsIPCSerializer.h";
using mozilla::Telemetry::HistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::KeyedHistogramAccumulation from "mozilla/TelemetryComms.h";
using mozilla::Telemetry::ScalarAction from "mozilla/TelemetryComms.h";
@ -313,7 +311,6 @@ nested(upto inside_cpow) sync protocol PContent
manages PWebBrowserPersistDocument;
manages PWebrtcGlobal;
manages PPresentation;
manages PFlyWebPublishedServer;
manages PURLClassifier;
manages PURLClassifierLocal;
manages PScriptCache;
@ -763,8 +760,6 @@ parent:
async PPresentation();
async PFlyWebPublishedServer(nsString name, FlyWebPublishOptions params);
sync PURLClassifier(Principal principal, bool useTrackingProtection)
returns (bool success);
sync ClassifyLocal(URIParams uri, nsCString tables)

1
dom/moz.build
View File

@ -59,7 +59,6 @@ DIRS += [
'file',
'filehandle',
'filesystem',
'flyweb',
'gamepad',
'geolocation',
'grid',

39
dom/webidl/FlyWebDiscoveryManager.webidl
View File

@ -1,39 +0,0 @@
/* -*- Mode: IDL; 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/.
*/
dictionary FlyWebDiscoveredService {
DOMString serviceId = "";
DOMString displayName = "";
DOMString transport = "";
DOMString serviceType = "";
DOMString cert = "";
DOMString path = "";
};
dictionary FlyWebPairedService {
FlyWebDiscoveredService discoveredService;
DOMString hostname = "";
DOMString uiUrl = "";
};
callback interface FlyWebPairingCallback {
void pairingSucceeded(optional FlyWebPairedService service);
void pairingFailed(DOMString error);
};
callback interface FlyWebDiscoveryCallback {
void onDiscoveredServicesChanged(sequence<FlyWebDiscoveredService> serviceList);
};
[ChromeOnly, ChromeConstructor, Exposed=(Window,System)]
interface FlyWebDiscoveryManager {
sequence<FlyWebDiscoveredService> listServices();
unsigned long startDiscovery(FlyWebDiscoveryCallback aCallback);
void stopDiscovery(unsigned long aId);
void pairWithService(DOMString serviceId, FlyWebPairingCallback callback);
};

13
dom/webidl/FlyWebFetchEvent.webidl
View File

@ -1,13 +0,0 @@
/* -*- Mode: IDL; 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/.
*/
[Pref="dom.flyweb.enabled"]
interface FlyWebFetchEvent : Event {
[SameObject] readonly attribute Request request;
[Throws]
void respondWith(Promise<Response> r);
};

23
dom/webidl/FlyWebPublish.webidl
View File

@ -1,23 +0,0 @@
/* -*- Mode: IDL; 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/.
*/
[Pref="dom.flyweb.enabled"]
interface FlyWebPublishedServer : EventTarget {
readonly attribute DOMString name;
readonly attribute DOMString? uiUrl;
void close();
attribute EventHandler onclose;
attribute EventHandler onfetch;
attribute EventHandler onwebsocket;
};
dictionary FlyWebPublishOptions {
DOMString? uiUrl = null; // URL to user interface. Can be different server. Makes
// endpoint show up in browser's "local services" UI.
// If relative, resolves against the root of the server.
};

16
dom/webidl/FlyWebWebSocketEvent.webidl
View File

@ -1,16 +0,0 @@
/* -*- Mode: IDL; 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/.
*/
[Pref="dom.flyweb.enabled"]
interface FlyWebWebSocketEvent : Event {
[SameObject] readonly attribute Request request;
[Throws]
WebSocket accept(optional DOMString protocol);
[Throws]
void respondWith(Promise<Response> r);
};

6
dom/webidl/Navigator.webidl
View File

@ -133,12 +133,6 @@ partial interface Navigator {
Promise<BatteryManager> getBattery();
};
partial interface Navigator {
[NewObject, Pref="dom.flyweb.enabled"]
Promise<FlyWebPublishedServer> publishServer(DOMString name,
optional FlyWebPublishOptions options);
};
// http://www.w3.org/TR/vibration/#vibration-interface
partial interface Navigator {
// We don't support sequences in unions yet

2
dom/webidl/WebSocket.webidl
View File

@ -64,7 +64,7 @@ interface WebSocket : EventTarget {
void send(ArrayBufferView data);
};
// Support for creating server-side chrome-only WebSocket. Used in FlyWeb and in
// Support for creating server-side chrome-only WebSocket. Used in
// devtools remote debugging server.
interface nsITransportProvider;

7
dom/webidl/moz.build
View File

@ -103,9 +103,6 @@ with Files("DesktopNotification.webidl"):
with Files("FakePluginTagInit.webidl"):
BUG_COMPONENT = ("Core", "Plug-ins")
with Files("FlyWeb*"):
BUG_COMPONENT = ("Core", "DOM: Flyweb")
with Files("FocusEvent.webidl"):
BUG_COMPONENT = ("Core", "DOM: Events")
@ -530,10 +527,6 @@ WEBIDL_FILES = [
'FileSystemDirectoryReader.webidl',
'FileSystemEntry.webidl',
'FileSystemFileEntry.webidl',
'FlyWebDiscoveryManager.webidl',
'FlyWebFetchEvent.webidl',
'FlyWebPublish.webidl',
'FlyWebWebSocketEvent.webidl',
'FocusEvent.webidl',
'FontFace.webidl',
'FontFaceSet.webidl',

11
layout/build/nsLayoutModule.cpp
View File

@ -167,8 +167,6 @@ static void Shutdown();
#include "AudioChannelService.h"
#include "mozilla/net/WebSocketEventService.h"
#include "mozilla/dom/FlyWebService.h"
#include "mozilla/dom/power/PowerManagerService.h"
#include "mozilla/dom/time/TimeService.h"
@ -506,17 +504,12 @@ NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(Geolocation, Init)
#define NS_WEBSOCKETEVENT_SERVICE_CID \
{ 0x31689828, 0xda66, 0x49a6, { 0x87, 0x0c, 0xdf, 0x62, 0xb8, 0x3f, 0xe7, 0x89 }}
#define NS_FLYWEB_SERVICE_CID \
{ 0x5de19ef0, 0x895e, 0x4c0c, { 0xa6, 0xe0, 0xea, 0xe0, 0x23, 0x2b, 0x84, 0x5a } }
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsGeolocationService, nsGeolocationService::GetGeolocationService)
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(AudioChannelService, AudioChannelService::GetOrCreate)
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(WebSocketEventService, WebSocketEventService::GetOrCreate)
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(FlyWebService, FlyWebService::GetOrCreateAddRefed)
#ifdef MOZ_WEBSPEECH_TEST_BACKEND
NS_GENERIC_FACTORY_CONSTRUCTOR(FakeSpeechRecognitionService)
#endif
@ -646,7 +639,6 @@ NS_DEFINE_NAMED_CID(NS_GEOLOCATION_SERVICE_CID);
NS_DEFINE_NAMED_CID(NS_GEOLOCATION_CID);
NS_DEFINE_NAMED_CID(NS_AUDIOCHANNEL_SERVICE_CID);
NS_DEFINE_NAMED_CID(NS_WEBSOCKETEVENT_SERVICE_CID);
NS_DEFINE_NAMED_CID(NS_FLYWEB_SERVICE_CID);
NS_DEFINE_NAMED_CID(NS_FOCUSMANAGER_CID);
NS_DEFINE_NAMED_CID(NS_CONTENTSECURITYMANAGER_CID);
NS_DEFINE_NAMED_CID(CSPSERVICE_CID);
@ -904,7 +896,6 @@ static const mozilla::Module::CIDEntry kLayoutCIDs[] = {
{ &kNS_GEOLOCATION_CID, false, nullptr, GeolocationConstructor },
{ &kNS_AUDIOCHANNEL_SERVICE_CID, false, nullptr, AudioChannelServiceConstructor },
{ &kNS_WEBSOCKETEVENT_SERVICE_CID, false, nullptr, WebSocketEventServiceConstructor },
{ &kNS_FLYWEB_SERVICE_CID, false, nullptr, FlyWebServiceConstructor },
{ &kNS_FOCUSMANAGER_CID, false, nullptr, CreateFocusManager },
#ifdef MOZ_WEBSPEECH_TEST_BACKEND
{ &kNS_FAKE_SPEECH_RECOGNITION_SERVICE_CID, false, nullptr, FakeSpeechRecognitionServiceConstructor },
@ -1028,8 +1019,6 @@ static const mozilla::Module::ContractIDEntry kLayoutContracts[] = {
{ "@mozilla.org/geolocation;1", &kNS_GEOLOCATION_CID },
{ "@mozilla.org/audiochannel/service;1", &kNS_AUDIOCHANNEL_SERVICE_CID },
{ "@mozilla.org/websocketevent/service;1", &kNS_WEBSOCKETEVENT_SERVICE_CID },
{ "@mozilla.org/flyweb-service;1", &kNS_FLYWEB_SERVICE_CID },
{ NS_NETWORK_PROTOCOL_CONTRACTID_PREFIX "flyweb", &kNS_FLYWEB_SERVICE_CID },
{ "@mozilla.org/focus-manager;1", &kNS_FOCUSMANAGER_CID },
#ifdef MOZ_WEBSPEECH_TEST_BACKEND
{ NS_SPEECH_RECOGNITION_SERVICE_CONTRACTID_PREFIX "fake", &kNS_FAKE_SPEECH_RECOGNITION_SERVICE_CID },

2
modules/libpref/init/all.js
View File

@ -5233,8 +5233,6 @@ pref("dom.forms.inputmode", false);
pref("dom.forms.inputmode", true);
#endif
pref("dom.flyweb.enabled", false);
// Enable mapped array buffer by default.
pref("dom.mapped_arraybuffer.enabled", true);

17
netwerk/base/nsSocketTransport2.cpp
View File

@ -930,23 +930,6 @@ nsSocketTransport::Init(const char **types, uint32_t typeCount,
return NS_OK;
}
nsresult
nsSocketTransport::InitPreResolved(const char **socketTypes, uint32_t typeCount,
const nsACString &host, uint16_t port,
const nsACString &hostRoute, uint16_t portRoute,
nsIProxyInfo *proxyInfo,
const mozilla::net::NetAddr* addr)
{
nsresult rv = Init(socketTypes, typeCount, host, port, hostRoute, portRoute, proxyInfo);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
mNetAddr = *addr;
mNetAddrPreResolved = true;
return NS_OK;
}
nsresult
nsSocketTransport::InitWithFilename(const char *filename)
{

9
netwerk/base/nsSocketTransport2.h
View File

@ -134,15 +134,6 @@ public:
const nsACString &hostRoute, uint16_t portRoute,
nsIProxyInfo *proxyInfo);
// Alternative Init method for when the IP-address of the host
// has been pre-resolved using a alternative means (e.g. FlyWeb service
// info).
nsresult InitPreResolved(const char **socketTypes, uint32_t typeCount,
const nsACString &host, uint16_t port,
const nsACString &hostRoute, uint16_t portRoute,
nsIProxyInfo *proxyInfo,
const mozilla::net::NetAddr* addr);
// this method instructs the socket transport to use an already connected
// socket with the given address.
nsresult InitWithConnectedSocket(PRFileDesc *socketFD,

15
netwerk/base/nsSocketTransportService2.cpp
View File

@ -27,7 +27,6 @@
#include "nsThreadUtils.h"
#include "nsIFile.h"
#include "nsIWidget.h"
#include "mozilla/dom/FlyWebService.h"
#ifdef MOZ_TASK_TRACER
#include "GeckoTaskTracer.h"
@ -750,20 +749,6 @@ nsSocketTransportService::CreateRoutedTransport(const char **types,
nsIProxyInfo *proxyInfo,
nsISocketTransport **result)
{
// Check FlyWeb table for host mappings. If one exists, then use that.
RefPtr<mozilla::dom::FlyWebService> fws =
mozilla::dom::FlyWebService::GetExisting();
if (fws) {
nsresult rv = fws->CreateTransportForHost(types, typeCount, host, port,
hostRoute, portRoute,
proxyInfo, result);
NS_ENSURE_SUCCESS(rv, rv);
if (*result) {
return NS_OK;
}
}
NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED);
NS_ENSURE_TRUE(port >= 0 && port <= 0xFFFF, NS_ERROR_ILLEGAL_VALUE);

3
netwerk/protocol/websocket/IPCTransportProvider.h
View File

@ -34,8 +34,7 @@
* the child. At this time the child gets its first addref.
*
* A reference to the TransportProvider is then sent as part of some other
* message from the parent to the child. For example in the
* PFlyWebPublishedServer.WebSocketRequest message.
* message from the parent to the child.
*
* The receiver of that message can then grab the TransportProviderChild and
* without addreffing it, effectively using the refcount that the