bool
VsyncParent::RecvUnobserve()
{
AssertIsOnBackgroundThread();
if (mObservingVsync) {
mVsyncDispatcher->RemoveChildRefreshTimer(this);
mObservingVsync = false;
return true;
}
return false;
}
GetFilesTaskParent::GetFilesTaskParent(FileSystemBase* aFileSystem,
const FileSystemGetFilesParams& aParam,
FileSystemRequestParent* aParent)
: FileSystemTaskParentBase(aFileSystem, aParam, aParent)
, GetFilesHelperBase(aParam.recursiveFlag())
, mDirectoryDOMPath(aParam.domPath())
{
MOZ_ASSERT(XRE_IsParentProcess(), "Only call from parent process!");
AssertIsOnBackgroundThread();
MOZ_ASSERT(aFileSystem);
}
// static
already_AddRefed<BroadcastChannelService>
BroadcastChannelService::GetOrCreate()
{
AssertIsOnBackgroundThread();
RefPtr<BroadcastChannelService> instance = sInstance;
if (!instance) {
instance = new BroadcastChannelService();
}
return instance.forget();
}
void
VsyncParent::ActorDestroy(ActorDestroyReason aReason)
{
MOZ_ASSERT(!mDestroyed);
AssertIsOnBackgroundThread();
if (mObservingVsync) {
mVsyncDispatcher->RemoveChildRefreshTimer(this);
}
mVsyncDispatcher = nullptr;
mDestroyed = true;
}
void RemoteWorkerManager::UnregisterActor(RemoteWorkerServiceParent* aActor) {
AssertIsOnBackgroundThread();
MOZ_ASSERT(XRE_IsParentProcess());
MOZ_ASSERT(aActor);
if (aActor == mParentActor) {
mParentActor = nullptr;
} else {
MOZ_ASSERT(mChildActors.Contains(aActor));
mChildActors.RemoveElement(aActor);
}
}
mozilla::ipc::IPCResult
BroadcastChannelParent::RecvPostMessage(const ClonedMessageData& aData)
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return IPC_FAIL_NO_REASON(this);
}
mService->PostMessage(this, aData, mOriginChannelKey);
return IPC_OK();
}
/* static */ MessagePortService*
MessagePortService::GetOrCreate()
{
AssertIsInMainProcess();
AssertIsOnBackgroundThread();
if (!gInstance) {
gInstance = new MessagePortService();
}
return gInstance;
}
void
BroadcastChannelService::PostMessage(BroadcastChannelParent* aParent,
const ClonedMessageData& aData,
const nsAString& aOriginChannelKey)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(aParent);
nsTArray<BroadcastChannelParent*>* parents;
if (!mAgents.Get(aOriginChannelKey, &parents)) {
MOZ_CRASH("Invalid state");
}
// We need to keep the array alive for the life-time of this operation.
nsTArray<RefPtr<BlobImpl>> blobImpls;
if (!aData.blobs().IsEmpty()) {
blobImpls.SetCapacity(aData.blobs().Length());
for (uint32_t i = 0, len = aData.blobs().Length(); i < len; ++i) {
RefPtr<BlobImpl> impl = IPCBlobUtils::Deserialize(aData.blobs()[i]);
MOZ_ASSERT(impl);
blobImpls.AppendElement(impl);
}
}
// For each parent actor, we notify the message.
for (uint32_t i = 0; i < parents->Length(); ++i) {
BroadcastChannelParent* parent = parents->ElementAt(i);
MOZ_ASSERT(parent);
if (parent == aParent) {
continue;
}
// We need to have a copy of the data for this parent.
ClonedMessageData newData(aData);
MOZ_ASSERT(blobImpls.Length() == newData.blobs().Length());
if (!blobImpls.IsEmpty()) {
// Serialize Blob objects for this message.
for (uint32_t i = 0, len = blobImpls.Length(); i < len; ++i) {
nsresult rv = IPCBlobUtils::Serialize(blobImpls[i], parent->Manager(),
newData.blobs()[i]);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
}
}
Unused << parent->SendNotify(newData);
}
}
bool
ServiceWorkerManagerParent::RecvPropagateRemove(const nsCString& aHost)
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->PropagateRemove(mID, aHost);
return true;
}
bool
ServiceWorkerManagerParent::RecvPropagateRemoveAll()
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->PropagateRemoveAll(mID);
return true;
}
mozilla::ipc::IProtocol*
NuwaParent::CloneProtocol(Channel* aChannel,
ProtocolCloneContext* aCtx)
{
MOZ_ASSERT(NS_IsMainThread());
RefPtr<NuwaParent> self = this;
MonitorAutoLock lock(mMonitor);
// Alloc NuwaParent on the worker thread.
nsCOMPtr<nsIRunnable> runnable = NS_NewRunnableFunction([self] () -> void
{
MonitorAutoLock lock(self->mMonitor);
// XXX Calling NuwaParent::Alloc() leads to a compilation error. Use
// self->Alloc() as a workaround.
self->mClonedActor = self->Alloc();
lock.Notify();
});
MOZ_ASSERT(runnable);
MOZ_ALWAYS_SUCCEEDS(mWorkerThread->Dispatch(runnable, NS_DISPATCH_NORMAL));
while (!mClonedActor) {
lock.Wait();
}
RefPtr<NuwaParent> actor = mClonedActor;
mClonedActor = nullptr;
// mManager of the cloned actor is assigned after returning from this method.
// We can't call ActorConstructed() right after Alloc() in the above runnable.
// To be safe we dispatch a runnable to the current thread to do it.
runnable = NS_NewRunnableFunction([actor] () -> void
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIRunnable> nested = NS_NewRunnableFunction([actor] () -> void
{
AssertIsOnBackgroundThread();
// Call NuwaParent::ActorConstructed() on the worker thread.
actor->ActorConstructed();
// The actor can finally be deleted after fully constructed.
mozilla::Unused << actor->Send__delete__(actor);
});
MOZ_ASSERT(nested);
MOZ_ALWAYS_SUCCEEDS(actor->mWorkerThread->Dispatch(nested, NS_DISPATCH_NORMAL));
});
MOZ_ASSERT(runnable);
MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
return actor;
}
void
ServiceWorkerManagerParent::ActorDestroy(ActorDestroyReason aWhy)
{
AssertIsOnBackgroundThread();
mActorDestroyed = true;
if (mService) {
// This object is about to be released and with it, also mService will be
// released too.
mService->UnregisterActor(this);
}
}
bool
BroadcastChannelParent::RecvPostMessage(const ClonedMessageData& aData)
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->PostMessage(this, aData, mOrigin, mAppId, mIsInBrowserElement,
mChannel, mPrivateBrowsing);
return true;
}
void
FileSystemTaskParentBase::HandleResult()
{
AssertIsOnBackgroundThread();
mFileSystem->AssertIsOnOwningThread();
if (mFileSystem->IsShutdown()) {
return;
}
MOZ_ASSERT(mRequestParent);
Unused << mRequestParent->Send__delete__(mRequestParent, GetRequestResult());
}
FileSystemResponseValue
CreateDirectoryTaskParent::GetSuccessRequestResult(ErrorResult& aRv) const
{
AssertIsOnBackgroundThread();
nsAutoString path;
aRv = mTargetPath->GetPath(path);
if (NS_WARN_IF(aRv.Failed())) {
return FileSystemDirectoryResponse();
}
return FileSystemDirectoryResponse(path);
}
bool
ServiceWorkerManagerParent::RecvPropagateUnregister(const PrincipalInfo& aPrincipalInfo,
const nsString& aScope)
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->PropagateUnregister(mID, aPrincipalInfo, aScope);
return true;
}
void
GamepadPlatformService::RemoveChannelParent(GamepadEventChannelParent* aParent)
{
// mChannelParents can only be modified once GamepadEventChannelParent
// is created or removed in Background thread
AssertIsOnBackgroundThread();
MOZ_ASSERT(aParent);
MOZ_ASSERT(mChannelParents.Contains(aParent));
// We use mutex here to prevent race condition with monitor thread
MutexAutoLock autoLock(mMutex);
mChannelParents.RemoveElement(aParent);
}
bool
ServiceWorkerManagerParent::RecvPropagateSoftUpdate(const OriginAttributes& aOriginAttributes,
const nsString& aScope)
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->PropagateSoftUpdate(mID, aOriginAttributes, aScope);
return true;
}
void
VsyncParent::DispatchVsyncEvent(TimeStamp aTimeStamp)
{
AssertIsOnBackgroundThread();
// If we call NotifyVsync() when we handle ActorDestroy() message, we might
// still call DispatchVsyncEvent().
// Similarly, we might also receive RecvUnobserveVsync() when call
// NotifyVsync(). We use mObservingVsync and mDestroyed flags to skip this
// notification.
if (mObservingVsync && !mDestroyed) {
Unused << SendNotify(aTimeStamp);
}
}
void
BroadcastChannelService::PostMessage(BroadcastChannelParent* aParent,
const ClonedMessageData& aData,
const nsAString& aOrigin,
const nsAString& aChannel,
bool aPrivateBrowsing)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(aParent);
MOZ_ASSERT(mAgents.Contains(aParent));
PostMessageData data(aParent, aData, aOrigin, aChannel, aPrivateBrowsing);
mAgents.EnumerateEntries(PostMessageEnumerator, &data);
}
FileSystemResponseValue
GetDirectoryListingTaskParent::GetSuccessRequestResult(ErrorResult& aRv) const
{
AssertIsOnBackgroundThread();
InfallibleTArray<PBlobParent*> blobs;
nsTArray<FileSystemDirectoryListingResponseData> inputs;
for (unsigned i = 0; i < mTargetData.Length(); i++) {
if (mTargetData[i].mType == FileOrDirectoryPath::eFilePath) {
nsCOMPtr<nsIFile> path;
nsresult rv = NS_NewLocalFile(mTargetData[i].mPath, true,
getter_AddRefs(path));
if (NS_WARN_IF(NS_FAILED(rv))) {
return FileSystemErrorResponse(rv);
}
FileSystemDirectoryListingResponseFile fileData;
RefPtr<BlobImpl> blobImpl = new FileBlobImpl(path);
nsAutoString filePath;
filePath.Assign(mDOMPath);
// This is specific for unix root filesystem.
if (!mDOMPath.EqualsLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL)) {
filePath.AppendLiteral(FILESYSTEM_DOM_PATH_SEPARATOR_LITERAL);
}
nsAutoString name;
blobImpl->GetName(name);
filePath.Append(name);
blobImpl->SetDOMPath(filePath);
fileData.blobParent() =
BlobParent::GetOrCreate(mRequestParent->Manager(), blobImpl);
inputs.AppendElement(fileData);
} else {
MOZ_ASSERT(mTargetData[i].mType == FileOrDirectoryPath::eDirectoryPath);
FileSystemDirectoryListingResponseDirectory directoryData;
directoryData.directoryRealPath() = mTargetData[i].mPath;
inputs.AppendElement(directoryData);
}
}
FileSystemDirectoryListingResponse response;
response.data().SwapElements(inputs);
return response;
}
void
ServiceWorkerManagerService::PropagateSoftUpdate(
uint64_t aParentID,
const PrincipalOriginAttributes& aOriginAttributes,
const nsAString& aScope)
{
AssertIsOnBackgroundThread();
nsAutoPtr<nsTArray<NotifySoftUpdateData>> notifySoftUpdateDataArray(
new nsTArray<NotifySoftUpdateData>());
DebugOnly<bool> parentFound = false;
for (auto iter = mAgents.Iter(); !iter.Done(); iter.Next()) {
RefPtr<ServiceWorkerManagerParent> parent = iter.Get()->GetKey();
MOZ_ASSERT(parent);
#ifdef DEBUG
if (parent->ID() == aParentID) {
parentFound = true;
}
#endif
RefPtr<ContentParent> contentParent = parent->GetContentParent();
// If the ContentParent is null we are dealing with a same-process actor.
if (!contentParent) {
Unused << parent->SendNotifySoftUpdate(aOriginAttributes,
nsString(aScope));
continue;
}
NotifySoftUpdateData* data = notifySoftUpdateDataArray->AppendElement();
data->mContentParent.swap(contentParent);
data->mParent.swap(parent);
}
if (notifySoftUpdateDataArray->IsEmpty()) {
return;
}
RefPtr<NotifySoftUpdateIfPrincipalOkRunnable> runnable =
new NotifySoftUpdateIfPrincipalOkRunnable(notifySoftUpdateDataArray,
aOriginAttributes, aScope);
MOZ_ASSERT(!notifySoftUpdateDataArray);
MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
#ifdef DEBUG
MOZ_ASSERT(parentFound);
#endif
}
bool
ServiceWorkerManagerParent::RecvShutdown()
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->UnregisterActor(this);
mService = nullptr;
unused << Send__delete__(this);
return true;
}
FileSystemTaskParentBase::FileSystemTaskParentBase(FileSystemBase* aFileSystem,
const FileSystemParams& aParam,
FileSystemRequestParent* aParent)
: mErrorValue(NS_OK)
, mFileSystem(aFileSystem)
, mRequestParent(aParent)
, mBackgroundEventTarget(NS_GetCurrentThread())
{
MOZ_ASSERT(XRE_IsParentProcess(),
"Only call from parent process!");
MOZ_ASSERT(aFileSystem, "aFileSystem should not be null.");
MOZ_ASSERT(aParent);
MOZ_ASSERT(mBackgroundEventTarget);
AssertIsOnBackgroundThread();
}
void
FileSystemTaskParentBase::Start()
{
AssertIsOnBackgroundThread();
mFileSystem->AssertIsOnOwningThread();
if (NeedToGoToMainThread()) {
nsresult rv = NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL);
NS_WARN_IF(NS_FAILED(rv));
return;
}
nsresult rv = DispatchToIOThread(this);
NS_WARN_IF(NS_FAILED(rv));
}
void
FileSystemRequestParent::ActorDestroy(ActorDestroyReason aWhy)
{
AssertIsOnBackgroundThread();
MOZ_ASSERT(!mDestroyed);
if (!mFileSystem) {
return;
}
mFileSystem->Shutdown();
mFileSystem = nullptr;
mTask = nullptr;
mDestroyed = true;
}
bool
BroadcastChannelParent::RecvClose()
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return false;
}
mService->UnregisterActor(this);
mService = nullptr;
unused << Send__delete__(this);
return true;
}
mozilla::ipc::IPCResult
BroadcastChannelParent::RecvClose()
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return IPC_FAIL_NO_REASON(this);
}
mService->UnregisterActor(this, mOriginChannelKey);
mService = nullptr;
Unused << Send__delete__(this);
return IPC_OK();
}
bool
GamepadPlatformService::HasGamepadListeners()
{
// mChannelParents may be accessed by background thread in the
// same time, we use mutex to prevent possible race condtion
AssertIsOnBackgroundThread();
// We use mutex here to prevent race condition with monitor thread
MutexAutoLock autoLock(mMutex);
for (uint32_t i = 0; i < mChannelParents.Length(); i++) {
if(mChannelParents[i]->HasGamepadListener()) {
return true;
}
}
return false;
}
void RemoteWorkerManager::LaunchNewContentProcess() {
AssertIsOnBackgroundThread();
MOZ_ASSERT(XRE_IsParentProcess());
// This runnable will spawn a new process if it doesn't exist yet.
nsCOMPtr<nsIRunnable> r =
NS_NewRunnableFunction("LaunchNewContentProcess", []() {
RefPtr<ContentParent> unused =
ContentParent::GetNewOrUsedBrowserProcess(
nullptr, NS_LITERAL_STRING(DEFAULT_REMOTE_TYPE));
});
nsCOMPtr<nsIEventTarget> target =
SystemGroup::EventTargetFor(TaskCategory::Other);
target->Dispatch(r.forget(), NS_DISPATCH_NORMAL);
}
