自学教程：C++ AssertIsOnBackgroundThread函数代码示例

boolVsyncParent::RecvUnobserve(){  AssertIsOnBackgroundThread();  if (mObservingVsync) {    mVsyncDispatcher->RemoveChildRefreshTimer(this);    mObservingVsync = false;    return true;  }  return false;}

// staticalready_AddRefed<BroadcastChannelService>BroadcastChannelService::GetOrCreate(){  AssertIsOnBackgroundThread();  RefPtr<BroadcastChannelService> instance = sInstance;  if (!instance) {    instance = new BroadcastChannelService();  }  return instance.forget();}

voidVsyncParent::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::IPCResultBroadcastChannelParent::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;}

boolServiceWorkerManagerParent::RecvPropagateRemove(const nsCString& aHost){  AssertIsOnBackgroundThread();  if (NS_WARN_IF(!mService)) {    return false;  }  mService->PropagateRemove(mID, aHost);  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;}

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

boolBroadcastChannelParent::RecvPostMessage(const ClonedMessageData& aData){  AssertIsOnBackgroundThread();  if (NS_WARN_IF(!mService)) {    return false;  }  mService->PostMessage(this, aData, mOrigin, mAppId, mIsInBrowserElement,                        mChannel, mPrivateBrowsing);  return true;}

voidFileSystemTaskParentBase::HandleResult(){  AssertIsOnBackgroundThread();  mFileSystem->AssertIsOnOwningThread();  if (mFileSystem->IsShutdown()) {    return;  }  MOZ_ASSERT(mRequestParent);  Unused << mRequestParent->Send__delete__(mRequestParent, GetRequestResult());}

FileSystemResponseValueCreateDirectoryTaskParent::GetSuccessRequestResult(ErrorResult& aRv) const{  AssertIsOnBackgroundThread();  nsAutoString path;  aRv = mTargetPath->GetPath(path);  if (NS_WARN_IF(aRv.Failed())) {    return FileSystemDirectoryResponse();  }  return FileSystemDirectoryResponse(path);}

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

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

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

voidServiceWorkerManagerService::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}

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

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

voidFileSystemRequestParent::ActorDestroy(ActorDestroyReason aWhy){  AssertIsOnBackgroundThread();  MOZ_ASSERT(!mDestroyed);  if (!mFileSystem) {    return;  }  mFileSystem->Shutdown();  mFileSystem = nullptr;  mTask = nullptr;  mDestroyed = true;}