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

int TestNrSocket::sendto(const void *msg, size_t len,                         int flags, nr_transport_addr *to) {  MOZ_ASSERT(my_addr_.protocol != IPPROTO_TCP);  ASSERT_ON_THREAD(ststhread_);  if (!nat_->enabled_ || nat_->is_an_internal_tuple(*to)) {    return NrSocket::sendto(msg, len, flags, to);  }  destroy_stale_port_mappings();  if (to->protocol == IPPROTO_UDP && nat_->block_udp_) {    // Silently eat the packet    return 0;  }  // Choose our port mapping based on our most selective criteria  PortMapping *port_mapping = get_port_mapping(*to,                                               std::max(nat_->filtering_type_,                                                        nat_->mapping_type_));  if (!port_mapping) {    // See if we have already made the external socket we need to use.    PortMapping *similar_port_mapping =      get_port_mapping(*to, nat_->mapping_type_);    nsRefPtr<NrSocket> external_socket;    if (similar_port_mapping) {      external_socket = similar_port_mapping->external_socket_;    } else {      external_socket = create_external_socket(*to);      if (!external_socket) {        MOZ_ASSERT(false);        return R_INTERNAL;      }    }    port_mapping = create_port_mapping(*to, external_socket);    port_mappings_.push_back(port_mapping);    if (poll_flags() & PR_POLL_READ) {      // Make sure the new port mapping is ready to receive traffic if the      // TestNrSocket is already waiting.      port_mapping->async_wait(NR_ASYNC_WAIT_READ,                              port_mapping_readable_callback,                              this,                              (char*)__FUNCTION__,                              __LINE__);    }  }  // We probably don't want to propagate the flags, since this is a simulated  // external IP address.  return port_mapping->sendto(msg, len, *to);}

LocalSourceStreamInfo*PeerConnectionMedia::GetLocalStreamByIndex(int aIndex){  ASSERT_ON_THREAD(mMainThread);  if(aIndex < 0 || aIndex >= (int) mLocalSourceStreams.Length()) {    return nullptr;  }  MOZ_ASSERT(mLocalSourceStreams[aIndex]);  return mLocalSourceStreams[aIndex];}

voidPeerConnectionMedia::UpdateSinkIdentity_m(const MediaStreamTrack* aTrack,                                          nsIPrincipal* aPrincipal,                                          const PeerIdentity* aSinkIdentity){  ASSERT_ON_THREAD(mMainThread);  for (RefPtr<TransceiverImpl>& transceiver : mTransceivers) {    transceiver->UpdateSinkIdentity(aTrack, aPrincipal, aSinkIdentity);  }}

void RemoteSourceStreamInfo::DetachTransport_s(){  ASSERT_ON_THREAD(mParent->GetSTSThread());  // walk through all the MediaPipelines and call the shutdown  // transport functions. Must be on the STS thread.  for (std::map<int, mozilla::RefPtr<mozilla::MediaPipeline> >::iterator it =           mPipelines.begin(); it != mPipelines.end();       ++it) {    it->second->ShutdownTransport_s();  }}

// callback while UDP packet is sentNS_IMETHODIMP NrSocketIpc::CallListenerSent(const nsACString &type,                                            nsresult result) {  ASSERT_ON_THREAD(main_thread_);  MOZ_ASSERT(type.EqualsLiteral("onsent"));  if (NS_FAILED(result)) {    ReentrantMonitorAutoEnter mon(monitor_);    err_ = true;  }  return NS_OK;}

int NrSocketIpc::getaddr(nr_transport_addr *addrp) {  ASSERT_ON_THREAD(sts_thread_);  ReentrantMonitorAutoEnter mon(monitor_);  if (state_ != NR_CONNECTED) {    return R_INTERNAL;  }  return nr_transport_addr_copy(addrp, &my_addr_);}

voidPeerConnectionMedia::SelfDestruct_m(){  CSFLogDebug(LOGTAG, "%s: ", __FUNCTION__);  ASSERT_ON_THREAD(mMainThread);  mMainThread = nullptr;  // Final self-destruct.  this->Release();}

int NrIceResolver::resolve(nr_resolver_resource *resource,                           int (*cb)(void *cb_arg, nr_transport_addr *addr),                           void *cb_arg,                           void **handle) {  int _status;  MOZ_ASSERT(allocated_resolvers_ > 0);  ASSERT_ON_THREAD(sts_thread_);  RefPtr<PendingResolution> pr;  uint32_t resolve_flags = 0;  OriginAttributes attrs;  if (resource->transport_protocol != IPPROTO_UDP &&      resource->transport_protocol != IPPROTO_TCP) {    MOZ_MTLOG(ML_ERROR, "Only UDP and TCP are supported.");    ABORT(R_NOT_FOUND);  }  pr = new PendingResolution(sts_thread_,                             resource->port? resource->port : 3478,                             resource->transport_protocol ?                             resource->transport_protocol :                             IPPROTO_UDP,                             cb, cb_arg);  switch(resource->address_family) {    case AF_INET:      resolve_flags |= nsIDNSService::RESOLVE_DISABLE_IPV6;      break;    case AF_INET6:      resolve_flags |= nsIDNSService::RESOLVE_DISABLE_IPV4;      break;    default:      ABORT(R_BAD_ARGS);  }  if (NS_FAILED(dns_->AsyncResolveNative(nsAutoCString(resource->domain_name),                                         resolve_flags, pr,                                         sts_thread_, attrs,                                         getter_AddRefs(pr->request_)))) {    MOZ_MTLOG(ML_ERROR, "AsyncResolve failed.");    ABORT(R_NOT_FOUND);  }  // Because the C API offers no "finished" method to release the handle we  // return, we cannot return the request we got from AsyncResolve directly.  //  // Instead, we return an addref'ed reference to PendingResolution itself,  // which in turn holds the request and coordinates between cancel and  // OnLookupComplete to release it only once.  pr.forget(handle);  _status=0;abort:  return _status;}

voidPeerConnectionMedia::SelfDestruct_m(){  CSFLogDebug(logTag, "%s: ", __FUNCTION__);  ASSERT_ON_THREAD(mMainThread);  mLocalSourceStreams.Clear();  mRemoteSourceStreams.Clear();  // Final self-destruct.  this->Release();}