uint32_t MsaaIdGenerator::GetContentProcessIDFor(dom::ContentParentId aIPCContentProcessID) { MOZ_ASSERT(XRE_IsParentProcess() && NS_IsMainThread()); if (!sContentParentIdMap) { sContentParentIdMap = new detail::ContentParentIdMap(); ClearOnShutdown(&sContentParentIdMap); } uint32_t value = 0; if (sContentParentIdMap->Get(aIPCContentProcessID, &value)) { return value; } uint32_t index = 0; for (; index < ArrayLength(sContentProcessIdBitmap); ++index) { if (sContentProcessIdBitmap[index] == UINT64_MAX) { continue; } uint32_t bitIndex = CountTrailingZeroes64(~sContentProcessIdBitmap[index]); MOZ_ASSERT(!(sContentProcessIdBitmap[index] & (1ULL << bitIndex))); MOZ_ASSERT(bitIndex != 0 || index != 0); sContentProcessIdBitmap[index] |= (1ULL << bitIndex); value = index * kBitsPerElement + bitIndex; break; } // If we run out of content process IDs, we're in trouble MOZ_RELEASE_ASSERT(index < ArrayLength(sContentProcessIdBitmap)); sContentParentIdMap->Put(aIPCContentProcessID, value); return value; }
void BluetoothGattManager::UnregisterClient(int aClientIf, BluetoothReplyRunnable* aRunnable) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aRunnable); ENSURE_GATT_CLIENT_INTF_IS_READY_VOID(aRunnable); size_t index = sClients->IndexOf(aClientIf, 0 /* Start */, ClientIfComparator()); // Reject the unregister request if the client is not found if (index == sClients->NoIndex) { NS_NAMED_LITERAL_STRING(errorStr, "Unregister GATT client failed"); DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr); return; } nsRefPtr<BluetoothGattClient> client = sClients->ElementAt(index); client->mUnregisterClientRunnable = aRunnable; sBluetoothGattClientInterface->UnregisterClient( aClientIf, new UnregisterClientResultHandler(client)); }
void TelemetryIPCAccumulator::RecordChildEvent(const mozilla::TimeStamp& timestamp, const nsACString& category, const nsACString& method, const nsACString& object, const mozilla::Maybe<nsCString>& value, const nsTArray<mozilla::Telemetry::EventExtraEntry>& extra) { StaticMutexAutoLock locker(gTelemetryIPCAccumulatorMutex); if (!gChildEvents) { gChildEvents = new nsTArray<ChildEventData>(); } if (gChildEvents->Length() >= kWaterMarkDiscardFactor * kEventsArrayHighWaterMark) { gDiscardedData.mDiscardedChildEvents++; return; } if (gChildEvents->Length() == kEventsArrayHighWaterMark) { DispatchIPCTimerFired(); } // Store the event. gChildEvents->AppendElement(ChildEventData{timestamp, nsCString(category), nsCString(method), nsCString(object), value, nsTArray<mozilla::Telemetry::EventExtraEntry>(extra)}); ArmIPCTimer(locker); }
void BluetoothGattManager::Disconnect(const nsAString& aAppUuid, const nsAString& aDeviceAddr, BluetoothReplyRunnable* aRunnable) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aRunnable); ENSURE_GATT_CLIENT_INTF_IS_READY_VOID(aRunnable); size_t index = sClients->IndexOf(aAppUuid, 0 /* Start */, UuidComparator()); // Reject the disconnect request if the client is not found if (index == sClients->NoIndex) { NS_NAMED_LITERAL_STRING(errorStr, "Disconnect failed"); DispatchBluetoothReply(aRunnable, BluetoothValue(), errorStr); return; } nsRefPtr<BluetoothGattClient> client = sClients->ElementAt(index); client->mDisconnectRunnable = aRunnable; sBluetoothGattClientInterface->Disconnect( client->mClientIf, aDeviceAddr, client->mConnId, new DisconnectResultHandler(client)); }
void BluetoothGattManager::Connect(const nsAString& aAppUuid, const nsAString& aDeviceAddr, BluetoothReplyRunnable* aRunnable) { MOZ_ASSERT(NS_IsMainThread()); MOZ_ASSERT(aRunnable); ENSURE_GATT_CLIENT_INTF_IS_READY_VOID(aRunnable); size_t index = sClients->IndexOf(aAppUuid, 0 /* Start */, UuidComparator()); if (index == sClients->NoIndex) { index = sClients->Length(); sClients->AppendElement(new BluetoothGattClient(aAppUuid, aDeviceAddr)); } nsRefPtr<BluetoothGattClient> client = sClients->ElementAt(index); client->mConnectRunnable = aRunnable; if (client->mClientIf > 0) { sBluetoothGattClientInterface->Connect(client->mClientIf, aDeviceAddr, true, // direct connect new ConnectResultHandler(client)); } else { BluetoothUuid uuid; StringToUuid(NS_ConvertUTF16toUTF8(aAppUuid).get(), uuid); // connect will be proceeded after client registered sBluetoothGattClientInterface->RegisterClient( uuid, new RegisterClientResultHandler(client)); } }
// // Notification Handlers // void BluetoothGattManager::RegisterClientNotification(int aStatus, int aClientIf, const BluetoothUuid& aAppUuid) { BT_API2_LOGR("Client Registered, clientIf = %d", aClientIf); MOZ_ASSERT(NS_IsMainThread()); nsString uuid; UuidToString(aAppUuid, uuid); size_t index = sClients->IndexOf(uuid, 0 /* Start */, UuidComparator()); NS_ENSURE_TRUE_VOID(index != sClients->NoIndex); nsRefPtr<BluetoothGattClient> client = sClients->ElementAt(index); BluetoothService* bs = BluetoothService::Get(); NS_ENSURE_TRUE_VOID(bs); if (aStatus) { // operation failed BT_API2_LOGR( "RegisterClient failed, clientIf = %d, status = %d, appUuid = %s", aClientIf, aStatus, NS_ConvertUTF16toUTF8(uuid).get()); // Notify BluetoothGatt for client disconnected BluetoothSignal signal( NS_LITERAL_STRING(GATT_CONNECTION_STATE_CHANGED_ID), uuid, BluetoothValue(false)); // Disconnected bs->DistributeSignal(signal); // Reject the connect request if (client->mConnectRunnable) { NS_NAMED_LITERAL_STRING(errorStr, "Connect failed due to registration failed"); DispatchBluetoothReply(client->mConnectRunnable, BluetoothValue(), errorStr); client->mConnectRunnable = nullptr; } sClients->RemoveElement(client); return; } client->mClientIf = aClientIf; // Notify BluetoothGatt to update the clientIf BluetoothSignal signal( NS_LITERAL_STRING("ClientRegistered"), uuid, BluetoothValue(uint32_t(aClientIf))); bs->DistributeSignal(signal); // Client just registered, proceed remaining connect request. if (client->mConnectRunnable) { sBluetoothGattClientInterface->Connect( aClientIf, client->mDeviceAddr, true /* direct connect */, new ConnectResultHandler(client)); } }
void BluetoothGattManager::ConnectNotification(int aConnId, int aStatus, int aClientIf, const nsAString& aDeviceAddr) { BT_API2_LOGR(); MOZ_ASSERT(NS_IsMainThread()); BluetoothService* bs = BluetoothService::Get(); NS_ENSURE_TRUE_VOID(bs); size_t index = sClients->IndexOf(aClientIf, 0 /* Start */, ClientIfComparator()); NS_ENSURE_TRUE_VOID(index != sClients->NoIndex); nsRefPtr<BluetoothGattClient> client = sClients->ElementAt(index); if (aStatus) { // operation failed BT_API2_LOGR("Connect failed, clientIf = %d, connId = %d, status = %d", aClientIf, aConnId, aStatus); // Notify BluetoothGatt that the client remains disconnected BluetoothSignal signal( NS_LITERAL_STRING(GATT_CONNECTION_STATE_CHANGED_ID), client->mAppUuid, BluetoothValue(false)); // Disconnected bs->DistributeSignal(signal); // Reject the connect request if (client->mConnectRunnable) { NS_NAMED_LITERAL_STRING(errorStr, "Connect failed"); DispatchBluetoothReply(client->mConnectRunnable, BluetoothValue(), errorStr); client->mConnectRunnable = nullptr; } return; } client->mConnId = aConnId; // Notify BluetoothGatt for client connected BluetoothSignal signal( NS_LITERAL_STRING(GATT_CONNECTION_STATE_CHANGED_ID), client->mAppUuid, BluetoothValue(true)); // Connected bs->DistributeSignal(signal); // Resolve the connect request if (client->mConnectRunnable) { DispatchBluetoothReply(client->mConnectRunnable, BluetoothValue(true), EmptyString()); client->mConnectRunnable = nullptr; } }
BrowsingContext::~BrowsingContext() { MOZ_DIAGNOSTIC_ASSERT(!mParent || !mParent->mChildren.Contains(this)); MOZ_DIAGNOSTIC_ASSERT(!mGroup || !mGroup->Toplevels().Contains(this)); MOZ_DIAGNOSTIC_ASSERT(!sCachedBrowsingContexts || !sCachedBrowsingContexts->has(Id())); if (sBrowsingContexts) { sBrowsingContexts->remove(Id()); } }
NS_IMETHOD Run() override { if (!sPoller) { return NS_OK; } if (sPoller->OpenSocket()) { return NS_OK; } sPoller->GetIOLoop()->PostDelayedTask(MakeAndAddRef<UeventInitTask>(), 1000); return NS_OK; }
/* static */ IOInterposer* IOInterposer::GetInstance() { if (!sSingleton) { // We can't actually use this assertion because we initialize this code // before XPCOM is initialized, so NS_IsMainThread() always returns false. // MOZ_ASSERT(NS_IsMainThread()); sSingleton = new IOInterposer(); sSingleton->Init(); } return sSingleton.get(); }
static void ChromeHangAnnotatorCallout(ChromeHangAnnotations& aAnnotations) { gMonitor->AssertCurrentThreadOwns(); MOZ_ASSERT(gAnnotators); if (!gAnnotators) { return; } for (std::set<Annotator*>::iterator i = gAnnotators->begin(), e = gAnnotators->end(); i != e; ++i) { (*i)->AnnotateHang(aAnnotations); } }
void BrowsingContext::Detach(bool aFromIPC) { MOZ_LOG(GetLog(), LogLevel::Debug, ("%s: Detaching 0x%08" PRIx64 " from 0x%08" PRIx64, XRE_IsParentProcess() ? "Parent" : "Child", Id(), mParent ? mParent->Id() : 0)); RefPtr<BrowsingContext> kungFuDeathGrip(this); BrowsingContextMap<RefPtr>::Ptr p; if (sCachedBrowsingContexts && (p = sCachedBrowsingContexts->lookup(Id()))) { MOZ_DIAGNOSTIC_ASSERT(!mParent || !mParent->mChildren.Contains(this)); MOZ_DIAGNOSTIC_ASSERT(!mGroup || !mGroup->Toplevels().Contains(this)); sCachedBrowsingContexts->remove(p); } else { Children* children = nullptr; if (mParent) { children = &mParent->mChildren; } else if (mGroup) { children = &mGroup->Toplevels(); } if (children) { // TODO(farre): This assert looks extremely fishy, I know, but // what we're actually saying is this: if we're detaching, but our // parent doesn't have any children, it is because we're being // detached by the cycle collector destroying docshells out of // order. MOZ_DIAGNOSTIC_ASSERT(children->IsEmpty() || children->Contains(this)); children->RemoveElement(this); } } if (mGroup) { mGroup->Unregister(this); } // As our nsDocShell is going away, this should implicitly mark us as closed. // We directly set our member, rather than using a transaction as we're going // to send a `Detach` message to other processes either way. mClosed = true; if (!aFromIPC && XRE_IsContentProcess()) { auto cc = ContentChild::GetSingleton(); MOZ_DIAGNOSTIC_ASSERT(cc); cc->SendDetachBrowsingContext(this, false /* aMoveToBFCache */); } }
void MsaaIdGenerator::ReleaseContentProcessIDFor(dom::ContentParentId aIPCContentProcessID) { MOZ_ASSERT(XRE_IsParentProcess() && NS_IsMainThread()); if (!sContentParentIdMap) { // Since Content IDs are generated lazily, ContentParent might attempt // to release an ID that was never allocated to begin with. return; } Maybe<uint32_t> mapping = sContentParentIdMap->GetAndRemove(aIPCContentProcessID); if (!mapping) { // Since Content IDs are generated lazily, ContentParent might attempt // to release an ID that was never allocated to begin with. return; } uint32_t index = mapping.ref() / kBitsPerElement; MOZ_ASSERT(index < ArrayLength(sContentProcessIdBitmap)); uint64_t mask = 1ULL << (mapping.ref() % kBitsPerElement); MOZ_ASSERT(sContentProcessIdBitmap[index] & mask); sContentProcessIdBitmap[index] &= ~mask; }
void RegisterSystemTimeChangeObserver(SystemTimeObserver *aObserver) { AssertMainThread(); InitializeSystemTimeChangeObserver(); sSystemTimeObserver->AddObserver(aObserver); }
/* static */ already_AddRefed<BrowsingContext> BrowsingContext::Get(uint64_t aId) { if (BrowsingContextMap<WeakPtr>::Ptr abc = sBrowsingContexts->lookup(aId)) { return do_AddRef(abc->value().get()); } return nullptr; }
/* static */ void AudioNotificationReceiver::Unregister( DeviceChangeListener* aDeviceChangeListener) { MOZ_ASSERT(XRE_IsContentProcess()); StaticMutexAutoLock lock(sMutex); MOZ_ASSERT(!sSubscribers->IsEmpty(), "No subscriber."); sSubscribers->RemoveElement(aDeviceChangeListener); if (sSubscribers->IsEmpty()) { // Clear the static pointer here to prevent memory leak. sSubscribers = nullptr; } ANR_LOG("The DeviceChangeListener: %p is unregistered successfully.", aDeviceChangeListener); }
void OnError(BluetoothStatus aStatus) override { BT_WARNING("BluetoothGattClientInterface::RegisterClient failed: %d", (int)aStatus); BluetoothService* bs = BluetoothService::Get(); NS_ENSURE_TRUE_VOID(bs); // Notify BluetoothGatt for client disconnected BluetoothSignal signal( NS_LITERAL_STRING(GATT_CONNECTION_STATE_CHANGED_ID), mClient->mAppUuid, BluetoothValue(false)); // Disconnected bs->DistributeSignal(signal); // Reject the connect request if (mClient->mConnectRunnable) { NS_NAMED_LITERAL_STRING(errorStr, "Register GATT client failed"); DispatchBluetoothReply(mClient->mConnectRunnable, BluetoothValue(), errorStr); mClient->mConnectRunnable = nullptr; } sClients->RemoveElement(mClient); }
bool StopDBus() { MOZ_ASSERT(!NS_IsMainThread()); NS_ENSURE_TRUE(gDBusServiceThread, true); if (gDBusThread) { static const char data = DBUS_EVENT_LOOP_EXIT; ssize_t wret = TEMP_FAILURE_RETRY(write(gDBusThread->mControlFdW.get(), &data, sizeof(data))); NS_ENSURE_TRUE(wret == 1, false); } #ifdef DEBUG LOG("DBus Thread Joining\n"); #endif if (NS_FAILED(gDBusServiceThread->Shutdown())) { NS_WARNING("DBus thread shutdown failed!"); } gDBusServiceThread = nullptr; #ifdef DEBUG LOG("DBus Thread Joined\n"); #endif if (gDBusThread) { gDBusThread->CleanUp(); gDBusThread = nullptr; } return true; }
float Axis::ApplyFlingCurveToVelocity(float aVelocity) const { float newVelocity = aVelocity; if (gfxPrefs::APZMaxVelocity() > 0.0f) { bool velocityIsNegative = (newVelocity < 0); newVelocity = fabs(newVelocity); float maxVelocity = ToLocalVelocity(gfxPrefs::APZMaxVelocity()); newVelocity = std::min(newVelocity, maxVelocity); if (gfxPrefs::APZCurveThreshold() > 0.0f && gfxPrefs::APZCurveThreshold() < gfxPrefs::APZMaxVelocity()) { float curveThreshold = ToLocalVelocity(gfxPrefs::APZCurveThreshold()); if (newVelocity > curveThreshold) { // here, 0 < curveThreshold < newVelocity <= maxVelocity, so we apply the curve float scale = maxVelocity - curveThreshold; float funcInput = (newVelocity - curveThreshold) / scale; float funcOutput = gVelocityCurveFunction->GetValue(funcInput, ComputedTimingFunction::BeforeFlag::Unset); float curvedVelocity = (funcOutput * scale) + curveThreshold; AXIS_LOG("%p|%s curving up velocity from %f to %f\n", mAsyncPanZoomController, Name(), newVelocity, curvedVelocity); newVelocity = curvedVelocity; } } if (velocityIsNegative) { newVelocity = -newVelocity; } } return newVelocity; }
bool AndroidFlingPhysics::SampleImpl(const TimeDuration& aDelta, float* aOutVelocity) { mDurationSoFar += aDelta; if (mDurationSoFar >= mTargetDuration) { return false; } const float timeRatio = mDurationSoFar.ToSeconds() / mTargetDuration.ToSeconds(); float distanceCoef = 1.0f; float velocityCoef = 0.0f; gSplineConstants->CalculateCoefficients(timeRatio, &distanceCoef, &velocityCoef); // The caller expects the velocity in pixels per _millisecond_. *aOutVelocity = velocityCoef * mTargetDistance / mTargetDuration.ToMilliseconds(); mCurrentPos = mTargetPos * distanceCoef; ParentLayerPoint remainder = mTargetPos - mCurrentPos; const float threshold = GetThresholdForFlingEnd(); if (fabsf(remainder.x) < threshold && fabsf(remainder.y) < threshold) { return false; } return true; }
LogModule* LogModule::Get(const char* aName) { // This is just a pass through to the LogModuleManager so // that the LogModuleManager implementation can be kept internal. MOZ_ASSERT(sLogModuleManager != nullptr); return sLogModuleManager->CreateOrGetModule(aName); }
void LogModule::Printv(LogLevel aLevel, const char* aFmt, va_list aArgs) const { MOZ_ASSERT(sLogModuleManager != nullptr); // Forward to LogModule manager w/ level and name sLogModuleManager->Print(Name(), aLevel, aFmt, aArgs); }
static void InitializeUevent() { MOZ_ASSERT(!sPoller); sPoller = new NetlinkPoller(); sPoller->GetIOLoop()->PostTask(MakeAndAddRef<UeventInitTask>()); ShutdownNetlinkPoller::MaybeInit(); }
void Axis::UpdateWithTouchAtDevicePoint(ParentLayerCoord aPos, ParentLayerCoord aAdditionalDelta, uint32_t aTimestampMs) { // mVelocityQueue is controller-thread only APZThreadUtils::AssertOnControllerThread(); if (aTimestampMs <= mVelocitySampleTimeMs + MIN_VELOCITY_SAMPLE_TIME_MS) { // See also the comment on MIN_VELOCITY_SAMPLE_TIME_MS. // We still update mPos so that the positioning is correct (and we don't run // into problems like bug 1042734) but the velocity will remain where it was. // In particular we don't update either mVelocitySampleTimeMs or // mVelocitySamplePos so that eventually when we do get an event with the // required time delta we use the corresponding distance delta as well. AXIS_LOG("%p|%s skipping velocity computation for small time delta %dms\n", mAsyncPanZoomController, Name(), (aTimestampMs - mVelocitySampleTimeMs)); mPos = aPos; return; } float newVelocity = mAxisLocked ? 0.0f : (float)(mVelocitySamplePos - aPos + aAdditionalDelta) / (float)(aTimestampMs - mVelocitySampleTimeMs); if (gfxPrefs::APZMaxVelocity() > 0.0f) { bool velocityIsNegative = (newVelocity < 0); newVelocity = fabs(newVelocity); float maxVelocity = ToLocalVelocity(gfxPrefs::APZMaxVelocity()); newVelocity = std::min(newVelocity, maxVelocity); if (gfxPrefs::APZCurveThreshold() > 0.0f && gfxPrefs::APZCurveThreshold() < gfxPrefs::APZMaxVelocity()) { float curveThreshold = ToLocalVelocity(gfxPrefs::APZCurveThreshold()); if (newVelocity > curveThreshold) { // here, 0 < curveThreshold < newVelocity <= maxVelocity, so we apply the curve float scale = maxVelocity - curveThreshold; float funcInput = (newVelocity - curveThreshold) / scale; float funcOutput = gVelocityCurveFunction->GetValue(funcInput); float curvedVelocity = (funcOutput * scale) + curveThreshold; AXIS_LOG("%p|%s curving up velocity from %f to %f\n", mAsyncPanZoomController, Name(), newVelocity, curvedVelocity); newVelocity = curvedVelocity; } } if (velocityIsNegative) { newVelocity = -newVelocity; } } AXIS_LOG("%p|%s updating velocity to %f with touch\n", mAsyncPanZoomController, Name(), newVelocity); mVelocity = newVelocity; mPos = aPos; mVelocitySampleTimeMs = aTimestampMs; mVelocitySamplePos = aPos; // Limit queue size pased on pref mVelocityQueue.AppendElement(std::make_pair(aTimestampMs, mVelocity)); if (mVelocityQueue.Length() > gfxPrefs::APZMaxVelocityQueueSize()) { mVelocityQueue.RemoveElementAt(0); } }
void TelemetryIPCAccumulator::AccumulateChildKeyedHistogram(mozilla::Telemetry::HistogramID aId, const nsCString& aKey, uint32_t aSample) { StaticMutexAutoLock locker(gTelemetryIPCAccumulatorMutex); if (!gKeyedHistogramAccumulations) { gKeyedHistogramAccumulations = new nsTArray<KeyedHistogramAccumulation>(); } if (gKeyedHistogramAccumulations->Length() >= kWaterMarkDiscardFactor * kHistogramAccumulationsArrayHighWaterMark) { gDiscardedData.mDiscardedKeyedHistogramAccumulations++; return; } if (gKeyedHistogramAccumulations->Length() == kHistogramAccumulationsArrayHighWaterMark) { DispatchIPCTimerFired(); } gKeyedHistogramAccumulations->AppendElement(KeyedHistogramAccumulation{aId, aSample, aKey}); ArmIPCTimer(locker); }
void UnregisterUeventListener(IUeventObserver *aObserver) { MOZ_ASSERT(MessageLoop::current() == XRE_GetIOMessageLoop()); if (sShutdown) { return; } sPoller->UnregisterObserver(aObserver); }
void IToplevelProtocol::GetOpenedActorsLocked(nsTArray<IToplevelProtocol*>& aActors) { gProtocolMutex->AssertCurrentThreadOwns(); for (IToplevelProtocol* actor = mOpenActors.getFirst(); actor; actor = actor->getNext()) { aActors.AppendElement(actor); } }
void BrowsingContext::Attach(bool aFromIPC) { MOZ_LOG(GetLog(), LogLevel::Debug, ("%s: %s 0x%08" PRIx64 " to 0x%08" PRIx64, XRE_IsParentProcess() ? "Parent" : "Child", sCachedBrowsingContexts->has(Id()) ? "Re-connecting" : "Connecting", Id(), mParent ? mParent->Id() : 0)); sCachedBrowsingContexts->remove(Id()); auto* children = mParent ? &mParent->mChildren : &mGroup->Toplevels(); MOZ_DIAGNOSTIC_ASSERT(!children->Contains(this)); children->AppendElement(this); // Send attach to our parent if we need to. if (!aFromIPC && XRE_IsContentProcess()) { ContentChild::GetSingleton()->SendAttachBrowsingContext( GetIPCInitializer()); } }
void UnregisterAnnotator(Annotator& aAnnotator) { #ifdef REPORT_CHROME_HANGS if (GoannaProcessType_Default != XRE_GetProcessType()) { return; } MonitorAutoLock lock(*gMonitor); MOZ_ASSERT(gAnnotators); gAnnotators->erase(&aAnnotator); #endif }
void CrossProcessCompositorBridgeParent::DidComposite( uint64_t aId, TimeStamp& aCompositeStart, TimeStamp& aCompositeEnd) { sIndirectLayerTreesLock->AssertCurrentThreadOwns(); if (LayerTransactionParent *layerTree = sIndirectLayerTrees[aId].mLayerTree) { Unused << SendDidComposite(aId, layerTree->GetPendingTransactionId(), aCompositeStart, aCompositeEnd); layerTree->SetPendingTransactionId(0); } }