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); }