summaryrefslogtreecommitdiffstats
path: root/toolkit/components/glean/ipc
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/glean/ipc')
-rw-r--r--toolkit/components/glean/ipc/FOGIPC.cpp575
-rw-r--r--toolkit/components/glean/ipc/FOGIPC.h102
-rw-r--r--toolkit/components/glean/ipc/Support.cpp76
3 files changed, 753 insertions, 0 deletions
diff --git a/toolkit/components/glean/ipc/FOGIPC.cpp b/toolkit/components/glean/ipc/FOGIPC.cpp
new file mode 100644
index 0000000000..e44cf3e863
--- /dev/null
+++ b/toolkit/components/glean/ipc/FOGIPC.cpp
@@ -0,0 +1,575 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "FOGIPC.h"
+
+#include <limits>
+#include "mozilla/glean/fog_ffi_generated.h"
+#include "mozilla/glean/GleanMetrics.h"
+#include "mozilla/dom/BrowsingContextGroup.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/DocGroup.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/gfx/GPUChild.h"
+#include "mozilla/gfx/GPUParent.h"
+#include "mozilla/gfx/GPUProcessManager.h"
+#include "mozilla/Hal.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/net/SocketProcessChild.h"
+#include "mozilla/net/SocketProcessParent.h"
+#include "mozilla/ProcInfo.h"
+#include "mozilla/RDDChild.h"
+#include "mozilla/RDDParent.h"
+#include "mozilla/RDDProcessManager.h"
+#include "mozilla/ipc/UtilityProcessChild.h"
+#include "mozilla/ipc/UtilityProcessManager.h"
+#include "mozilla/ipc/UtilityProcessParent.h"
+#include "mozilla/ipc/UtilityProcessSandboxing.h"
+#include "mozilla/Unused.h"
+#include "GMPPlatform.h"
+#include "GMPServiceParent.h"
+#include "nsIClassifiedChannel.h"
+#include "nsIXULRuntime.h"
+#include "nsTArray.h"
+#include "nsThreadUtils.h"
+
+using mozilla::dom::ContentParent;
+using mozilla::gfx::GPUChild;
+using mozilla::gfx::GPUProcessManager;
+using mozilla::ipc::ByteBuf;
+using mozilla::ipc::UtilityProcessChild;
+using mozilla::ipc::UtilityProcessManager;
+using mozilla::ipc::UtilityProcessParent;
+using FlushFOGDataPromise = mozilla::dom::ContentParent::FlushFOGDataPromise;
+
+namespace geckoprofiler::markers {
+
+using namespace mozilla;
+
+struct ProcessingTimeMarker {
+ static constexpr Span<const char> MarkerTypeName() {
+ return MakeStringSpan("ProcessingTime");
+ }
+ static void StreamJSONMarkerData(baseprofiler::SpliceableJSONWriter& aWriter,
+ int64_t aDiffMs,
+ const ProfilerString8View& aType,
+ const ProfilerString8View& aTrackerType) {
+ aWriter.IntProperty("time", aDiffMs);
+ aWriter.StringProperty("label", aType);
+ if (aTrackerType.Length() > 0) {
+ aWriter.StringProperty("tracker", aTrackerType);
+ }
+ }
+ static MarkerSchema MarkerTypeDisplay() {
+ using MS = MarkerSchema;
+ MS schema{MS::Location::MarkerChart, MS::Location::MarkerTable};
+ schema.AddKeyLabelFormat("time", "Recorded Time", MS::Format::Milliseconds);
+ schema.AddKeyLabelFormat("tracker", "Tracker Type", MS::Format::String);
+ schema.SetTooltipLabel("{marker.name} - {marker.data.label}");
+ schema.SetTableLabel(
+ "{marker.name} - {marker.data.label}: {marker.data.time}");
+ return schema;
+ }
+};
+
+} // namespace geckoprofiler::markers
+
+namespace mozilla::glean {
+
+// Echoes processtools/metrics.yaml's power.wakeups_per_thread
+enum ProcessType {
+ eParentActive,
+ eParentInactive,
+ eContentForeground,
+ eContentBackground,
+ eGpuProcess,
+ eUnknown,
+};
+
+// This static global is set within RecordPowerMetrics on the main thread,
+// using information only gettable on the main thread, and is read within
+// RecordThreadCpuUse on any thread.
+static Atomic<ProcessType> gThisProcessType(eUnknown);
+
+#ifdef NIGHTLY_BUILD
+// It is fine to call RecordThreadCpuUse during startup before the first
+// RecordPowerMetrics call. In that case the parent process will be recorded
+// as inactive, and other processes will be ignored (content processes start
+// in the 'prealloc' type for which we don't record per-thread CPU use data).
+
+void RecordThreadCpuUse(const nsACString& aThreadName, uint64_t aCpuTimeMs,
+ uint64_t aWakeCount) {
+ ProcessType processType = gThisProcessType;
+
+ if (processType == ProcessType::eUnknown) {
+ if (XRE_IsParentProcess()) {
+ // During startup we might not have gotten a RecordPowerMetrics call.
+ // That's fine. Default to eParentInactive.
+ processType = eParentInactive;
+ } else {
+ // We are not interested in per-thread CPU use data for the current
+ // process type.
+ return;
+ }
+ }
+
+ nsAutoCString threadName(aThreadName);
+ for (size_t i = 0; i < threadName.Length(); ++i) {
+ const char c = threadName.CharAt(i);
+
+ // Valid characters.
+ if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || c == '-' ||
+ c == '_') {
+ continue;
+ }
+
+ // Should only use lower case characters
+ if (c >= 'A' && c <= 'Z') {
+ threadName.SetCharAt(c + ('a' - 'A'), i);
+ continue;
+ }
+
+ // Replace everything else with _
+ threadName.SetCharAt('_', i);
+ }
+
+ if (aCpuTimeMs != 0 &&
+ MOZ_LIKELY(aCpuTimeMs < std::numeric_limits<int32_t>::max())) {
+ switch (processType) {
+ case eParentActive:
+ power_cpu_ms_per_thread::parent_active.Get(threadName)
+ .Add(int32_t(aCpuTimeMs));
+ break;
+ case eParentInactive:
+ power_cpu_ms_per_thread::parent_inactive.Get(threadName)
+ .Add(int32_t(aCpuTimeMs));
+ break;
+ case eContentForeground:
+ power_cpu_ms_per_thread::content_foreground.Get(threadName)
+ .Add(int32_t(aCpuTimeMs));
+ break;
+ case eContentBackground:
+ power_cpu_ms_per_thread::content_background.Get(threadName)
+ .Add(int32_t(aCpuTimeMs));
+ break;
+ case eGpuProcess:
+ power_cpu_ms_per_thread::gpu_process.Get(threadName)
+ .Add(int32_t(aCpuTimeMs));
+ break;
+ case eUnknown:
+ // Nothing to do.
+ break;
+ }
+ }
+
+ if (aWakeCount != 0 &&
+ MOZ_LIKELY(aWakeCount < std::numeric_limits<int32_t>::max())) {
+ switch (processType) {
+ case eParentActive:
+ power_wakeups_per_thread::parent_active.Get(threadName)
+ .Add(int32_t(aWakeCount));
+ break;
+ case eParentInactive:
+ power_wakeups_per_thread::parent_inactive.Get(threadName)
+ .Add(int32_t(aWakeCount));
+ break;
+ case eContentForeground:
+ power_wakeups_per_thread::content_foreground.Get(threadName)
+ .Add(int32_t(aWakeCount));
+ break;
+ case eContentBackground:
+ power_wakeups_per_thread::content_background.Get(threadName)
+ .Add(int32_t(aWakeCount));
+ break;
+ case eGpuProcess:
+ power_wakeups_per_thread::gpu_process.Get(threadName)
+ .Add(int32_t(aWakeCount));
+ break;
+ case eUnknown:
+ // Nothing to do.
+ break;
+ }
+ }
+}
+#endif
+
+void GetTrackerType(nsAutoCString& aTrackerType) {
+ using namespace mozilla::dom;
+ uint32_t trackingFlags =
+ (nsIClassifiedChannel::CLASSIFIED_CRYPTOMINING |
+ nsIClassifiedChannel::CLASSIFIED_FINGERPRINTING |
+ nsIClassifiedChannel::CLASSIFIED_TRACKING |
+ nsIClassifiedChannel::CLASSIFIED_TRACKING_AD |
+ nsIClassifiedChannel::CLASSIFIED_TRACKING_ANALYTICS |
+ nsIClassifiedChannel::CLASSIFIED_TRACKING_SOCIAL);
+ AutoTArray<RefPtr<BrowsingContextGroup>, 5> bcGroups;
+ BrowsingContextGroup::GetAllGroups(bcGroups);
+ for (auto& bcGroup : bcGroups) {
+ AutoTArray<DocGroup*, 5> docGroups;
+ bcGroup->GetDocGroups(docGroups);
+ for (auto* docGroup : docGroups) {
+ for (Document* doc : *docGroup) {
+ nsCOMPtr<nsIClassifiedChannel> classifiedChannel =
+ do_QueryInterface(doc->GetChannel());
+ if (classifiedChannel) {
+ uint32_t classificationFlags =
+ classifiedChannel->GetThirdPartyClassificationFlags();
+ trackingFlags &= classificationFlags;
+ if (!trackingFlags) {
+ return;
+ }
+ }
+ }
+ }
+ }
+
+ // The if-elseif-else chain works because the tracker types listed here are
+ // currently mutually exclusive and should be maintained that way by policy.
+ if (trackingFlags == nsIClassifiedChannel::CLASSIFIED_TRACKING_AD) {
+ aTrackerType = "ad";
+ } else if (trackingFlags ==
+ nsIClassifiedChannel::CLASSIFIED_TRACKING_ANALYTICS) {
+ aTrackerType = "analytics";
+ } else if (trackingFlags ==
+ nsIClassifiedChannel::CLASSIFIED_TRACKING_SOCIAL) {
+ aTrackerType = "social";
+ } else if (trackingFlags == nsIClassifiedChannel::CLASSIFIED_CRYPTOMINING) {
+ aTrackerType = "cryptomining";
+ } else if (trackingFlags == nsIClassifiedChannel::CLASSIFIED_FINGERPRINTING) {
+ aTrackerType = "fingerprinting";
+ } else if (trackingFlags == nsIClassifiedChannel::CLASSIFIED_TRACKING) {
+ // CLASSIFIED_TRACKING means we were not able to identify the type of
+ // classification.
+ aTrackerType = "unknown";
+ }
+}
+
+void RecordPowerMetrics() {
+ static uint64_t previousCpuTime = 0, previousGpuTime = 0;
+
+ uint64_t cpuTime, newCpuTime = 0;
+ if (NS_SUCCEEDED(GetCpuTimeSinceProcessStartInMs(&cpuTime)) &&
+ cpuTime > previousCpuTime) {
+ newCpuTime = cpuTime - previousCpuTime;
+ }
+
+ uint64_t gpuTime, newGpuTime = 0;
+ // Avoid loading gdi32.dll for the Socket process where the GPU is never used.
+ if (!XRE_IsSocketProcess() &&
+ NS_SUCCEEDED(GetGpuTimeSinceProcessStartInMs(&gpuTime)) &&
+ gpuTime > previousGpuTime) {
+ newGpuTime = gpuTime - previousGpuTime;
+ }
+
+ if (!newCpuTime && !newGpuTime) {
+ // Nothing to record.
+ return;
+ }
+
+ // Compute the process type string.
+ nsAutoCString type(XRE_GetProcessTypeString());
+ nsAutoCString trackerType;
+ if (XRE_IsContentProcess()) {
+ auto* cc = dom::ContentChild::GetSingleton();
+ if (cc) {
+ type.Assign(dom::RemoteTypePrefix(cc->GetRemoteType()));
+ if (StringBeginsWith(type, WEB_REMOTE_TYPE)) {
+ type.AssignLiteral("web");
+ switch (cc->GetProcessPriority()) {
+ case hal::PROCESS_PRIORITY_BACKGROUND:
+ type.AppendLiteral(".background");
+ gThisProcessType = ProcessType::eContentBackground;
+ break;
+ case hal::PROCESS_PRIORITY_FOREGROUND:
+ type.AppendLiteral(".foreground");
+ gThisProcessType = ProcessType::eContentForeground;
+ break;
+ case hal::PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE:
+ type.AppendLiteral(".background-perceivable");
+ gThisProcessType = ProcessType::eUnknown;
+ break;
+ default:
+ gThisProcessType = ProcessType::eUnknown;
+ break;
+ }
+ }
+ GetTrackerType(trackerType);
+ } else {
+ gThisProcessType = ProcessType::eUnknown;
+ }
+ } else if (XRE_IsParentProcess()) {
+ if (nsContentUtils::GetUserIsInteracting()) {
+ type.AssignLiteral("parent.active");
+ gThisProcessType = ProcessType::eParentActive;
+ } else {
+ type.AssignLiteral("parent.inactive");
+ gThisProcessType = ProcessType::eParentInactive;
+ }
+ hal::WakeLockInformation info;
+ GetWakeLockInfo(u"video-playing"_ns, &info);
+ if (info.numLocks() != 0 && info.numHidden() < info.numLocks()) {
+ type.AppendLiteral(".playing-video");
+ } else {
+ GetWakeLockInfo(u"audio-playing"_ns, &info);
+ if (info.numLocks()) {
+ type.AppendLiteral(".playing-audio");
+ }
+ }
+ } else if (XRE_IsGPUProcess()) {
+ gThisProcessType = ProcessType::eGpuProcess;
+ } else {
+ gThisProcessType = ProcessType::eUnknown;
+ }
+
+ if (newCpuTime) {
+ // The counters are reset at least once a day. Assuming all cores are used
+ // continuously, an int32 can hold the data for 24.85 cores.
+ // This should be fine for now, but may overflow in the future.
+ // Bug 1751277 tracks a newer, bigger counter.
+ int32_t nNewCpuTime = int32_t(newCpuTime);
+ if (newCpuTime < std::numeric_limits<int32_t>::max()) {
+ power::total_cpu_time_ms.Add(nNewCpuTime);
+ power::cpu_time_per_process_type_ms.Get(type).Add(nNewCpuTime);
+ if (!trackerType.IsEmpty()) {
+ power::cpu_time_per_tracker_type_ms.Get(trackerType).Add(nNewCpuTime);
+ }
+ } else {
+ power::cpu_time_bogus_values.Add(1);
+ }
+ PROFILER_MARKER("Process CPU Time", OTHER, {}, ProcessingTimeMarker,
+ nNewCpuTime, type, trackerType);
+ previousCpuTime += newCpuTime;
+ }
+
+ if (newGpuTime) {
+ int32_t nNewGpuTime = int32_t(newGpuTime);
+ if (newGpuTime < std::numeric_limits<int32_t>::max()) {
+ power::total_gpu_time_ms.Add(nNewGpuTime);
+ power::gpu_time_per_process_type_ms.Get(type).Add(nNewGpuTime);
+ } else {
+ power::gpu_time_bogus_values.Add(1);
+ }
+ PROFILER_MARKER("Process GPU Time", OTHER, {}, ProcessingTimeMarker,
+ nNewGpuTime, type, trackerType);
+ previousGpuTime += newGpuTime;
+ }
+
+ profiler_record_wakeup_count(type);
+}
+
+/**
+ * Flush your data ASAP, either because the parent process is asking you to
+ * or because the process is about to shutdown.
+ *
+ * @param aResolver - The function you need to call with the bincoded,
+ * serialized payload that the Rust impl hands you.
+ */
+void FlushFOGData(std::function<void(ipc::ByteBuf&&)>&& aResolver) {
+ // Record power metrics right before data is sent to the parent.
+ RecordPowerMetrics();
+
+ ByteBuf buf;
+ uint32_t ipcBufferSize = impl::fog_serialize_ipc_buf();
+ bool ok = buf.Allocate(ipcBufferSize);
+ if (!ok) {
+ return;
+ }
+ uint32_t writtenLen = impl::fog_give_ipc_buf(buf.mData, buf.mLen);
+ if (writtenLen != ipcBufferSize) {
+ return;
+ }
+ aResolver(std::move(buf));
+}
+
+/**
+ * Called by FOG on the parent process when it wants to flush all its
+ * children's data.
+ * @param aResolver - The function that'll be called with the results.
+ */
+void FlushAllChildData(
+ std::function<void(nsTArray<ipc::ByteBuf>&&)>&& aResolver) {
+ auto timerId = fog_ipc::flush_durations.Start();
+
+ nsTArray<ContentParent*> parents;
+ ContentParent::GetAll(parents);
+ nsTArray<RefPtr<FlushFOGDataPromise>> promises;
+ for (auto* parent : parents) {
+ promises.EmplaceBack(parent->SendFlushFOGData());
+ }
+
+ if (GPUProcessManager* gpuManager = GPUProcessManager::Get()) {
+ if (GPUChild* gpuChild = gpuManager->GetGPUChild()) {
+ promises.EmplaceBack(gpuChild->SendFlushFOGData());
+ }
+ }
+
+ if (RDDProcessManager* rddManager = RDDProcessManager::Get()) {
+ if (RDDChild* rddChild = rddManager->GetRDDChild()) {
+ promises.EmplaceBack(rddChild->SendFlushFOGData());
+ }
+ }
+
+ if (net::SocketProcessParent* socketParent =
+ net::SocketProcessParent::GetSingleton()) {
+ promises.EmplaceBack(socketParent->SendFlushFOGData());
+ }
+
+ if (RefPtr<mozilla::gmp::GeckoMediaPluginServiceParent> gmps =
+ mozilla::gmp::GeckoMediaPluginServiceParent::GetSingleton()) {
+ // There can be multiple Gecko Media Plugin processes, but iterating
+ // through them requires locking a mutex and the IPCs need to be sent
+ // from a different thread, so it's better to let the
+ // GeckoMediaPluginServiceParent code do it for us.
+ gmps->SendFlushFOGData(promises);
+ }
+
+ if (RefPtr<UtilityProcessManager> utilityManager =
+ UtilityProcessManager::GetIfExists()) {
+ for (RefPtr<UtilityProcessParent>& parent :
+ utilityManager->GetAllProcessesProcessParent()) {
+ promises.EmplaceBack(parent->SendFlushFOGData());
+ }
+ }
+
+ if (promises.Length() == 0) {
+ // No child processes at the moment. Resolve synchronously.
+ fog_ipc::flush_durations.Cancel(std::move(timerId));
+ nsTArray<ipc::ByteBuf> results;
+ aResolver(std::move(results));
+ return;
+ }
+
+ // If fog.ipc.flush_failures ever gets too high:
+ // TODO: Don't throw away resolved data if some of the promises reject.
+ // (not sure how, but it'll mean not using ::All... maybe a custom copy of
+ // AllPromiseHolder? Might be impossible outside MozPromise.h)
+ FlushFOGDataPromise::All(GetCurrentSerialEventTarget(), promises)
+ ->Then(GetCurrentSerialEventTarget(), __func__,
+ [aResolver = std::move(aResolver), timerId](
+ FlushFOGDataPromise::AllPromiseType::ResolveOrRejectValue&&
+ aValue) {
+ fog_ipc::flush_durations.StopAndAccumulate(std::move(timerId));
+ if (aValue.IsResolve()) {
+ aResolver(std::move(aValue.ResolveValue()));
+ } else {
+ fog_ipc::flush_failures.Add(1);
+ nsTArray<ipc::ByteBuf> results;
+ aResolver(std::move(results));
+ }
+ });
+}
+
+/**
+ * A child process has sent you this buf as a treat.
+ * @param buf - a bincoded serialized payload that the Rust impl understands.
+ */
+void FOGData(ipc::ByteBuf&& buf) {
+ JOG::EnsureRuntimeMetricsRegistered();
+ fog_ipc::buffer_sizes.Accumulate(buf.mLen);
+ impl::fog_use_ipc_buf(buf.mData, buf.mLen);
+}
+
+/**
+ * Called by FOG on a child process when it wants to send a buf to the parent.
+ * @param buf - a bincoded serialized payload that the Rust impl understands.
+ */
+void SendFOGData(ipc::ByteBuf&& buf) {
+ switch (XRE_GetProcessType()) {
+ case GeckoProcessType_Content:
+ mozilla::dom::ContentChild::GetSingleton()->SendFOGData(std::move(buf));
+ break;
+ case GeckoProcessType_GMPlugin: {
+ mozilla::gmp::SendFOGData(std::move(buf));
+ } break;
+ case GeckoProcessType_GPU:
+ Unused << mozilla::gfx::GPUParent::GetSingleton()->SendFOGData(
+ std::move(buf));
+ break;
+ case GeckoProcessType_RDD:
+ Unused << mozilla::RDDParent::GetSingleton()->SendFOGData(std::move(buf));
+ break;
+ case GeckoProcessType_Socket:
+ Unused << net::SocketProcessChild::GetSingleton()->SendFOGData(
+ std::move(buf));
+ break;
+ case GeckoProcessType_Utility:
+ Unused << ipc::UtilityProcessChild::GetSingleton()->SendFOGData(
+ std::move(buf));
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unsuppored process type");
+ }
+}
+
+/**
+ * Called on the parent process to ask all child processes for data,
+ * sending it all down into Rust to be used.
+ */
+RefPtr<GenericPromise> FlushAndUseFOGData() {
+ // Record power metrics on the parent before sending requests to child
+ // processes.
+ RecordPowerMetrics();
+
+ RefPtr<GenericPromise::Private> ret = new GenericPromise::Private(__func__);
+ std::function<void(nsTArray<ByteBuf>&&)> resolver =
+ [ret](nsTArray<ByteBuf>&& bufs) {
+ for (ByteBuf& buf : bufs) {
+ FOGData(std::move(buf));
+ }
+ ret->Resolve(true, __func__);
+ };
+ FlushAllChildData(std::move(resolver));
+ return ret;
+}
+
+void TestTriggerMetrics(uint32_t aProcessType,
+ const RefPtr<dom::Promise>& promise) {
+ switch (aProcessType) {
+ case nsIXULRuntime::PROCESS_TYPE_GMPLUGIN: {
+ RefPtr<mozilla::gmp::GeckoMediaPluginServiceParent> gmps(
+ mozilla::gmp::GeckoMediaPluginServiceParent::GetSingleton());
+ gmps->TestTriggerMetrics()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [promise]() { promise->MaybeResolveWithUndefined(); },
+ [promise]() { promise->MaybeRejectWithUndefined(); });
+ } break;
+ case nsIXULRuntime::PROCESS_TYPE_GPU:
+ mozilla::gfx::GPUProcessManager::Get()->TestTriggerMetrics()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [promise]() { promise->MaybeResolveWithUndefined(); },
+ [promise]() { promise->MaybeRejectWithUndefined(); });
+ break;
+ case nsIXULRuntime::PROCESS_TYPE_RDD:
+ RDDProcessManager::Get()->TestTriggerMetrics()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [promise]() { promise->MaybeResolveWithUndefined(); },
+ [promise]() { promise->MaybeRejectWithUndefined(); });
+ break;
+ case nsIXULRuntime::PROCESS_TYPE_SOCKET:
+ Unused << net::SocketProcessParent::GetSingleton()
+ ->SendTestTriggerMetrics()
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [promise]() { promise->MaybeResolveWithUndefined(); },
+ [promise]() { promise->MaybeRejectWithUndefined(); });
+ break;
+ case nsIXULRuntime::PROCESS_TYPE_UTILITY:
+ Unused << ipc::UtilityProcessManager::GetSingleton()
+ ->GetProcessParent(ipc::SandboxingKind::GENERIC_UTILITY)
+ ->SendTestTriggerMetrics()
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [promise]() { promise->MaybeResolveWithUndefined(); },
+ [promise]() { promise->MaybeRejectWithUndefined(); });
+ break;
+ default:
+ promise->MaybeRejectWithUndefined();
+ break;
+ }
+}
+
+} // namespace mozilla::glean
diff --git a/toolkit/components/glean/ipc/FOGIPC.h b/toolkit/components/glean/ipc/FOGIPC.h
new file mode 100644
index 0000000000..3701f71838
--- /dev/null
+++ b/toolkit/components/glean/ipc/FOGIPC.h
@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef FOGIPC_h__
+#define FOGIPC_h__
+
+#include <functional>
+
+#include "mozilla/Maybe.h"
+#include "mozilla/MozPromise.h"
+#include "nsTArrayForwardDeclare.h"
+
+namespace mozilla {
+namespace ipc {
+class ByteBuf;
+} // namespace ipc
+} // namespace mozilla
+
+// This module provides the interface for FOG to communicate between processes.
+
+namespace mozilla {
+namespace glean {
+
+/**
+ * The parent process is asking you to flush your data ASAP.
+ *
+ * @param aResolver - The function you need to call with the bincoded,
+ * serialized payload that the Rust impl hands you.
+ */
+void FlushFOGData(std::function<void(ipc::ByteBuf&&)>&& aResolver);
+
+/**
+ * Called by FOG on the parent process when it wants to flush all its
+ * children's data.
+ * @param aResolver - The function that'll be called with the results.
+ */
+void FlushAllChildData(
+ std::function<void(nsTArray<ipc::ByteBuf>&&)>&& aResolver);
+
+/**
+ * A child process has sent you this buf as a treat.
+ * @param buf - a bincoded serialized payload that the Rust impl understands.
+ */
+void FOGData(ipc::ByteBuf&& buf);
+
+/**
+ * Called by FOG on a child process when it wants to send a buf to the parent.
+ * @param buf - a bincoded serialized payload that the Rust impl understands.
+ */
+void SendFOGData(ipc::ByteBuf&& buf);
+
+/**
+ * Called on the parent process to ask all child processes for data,
+ * sending it all down into Rust to be used.
+ *
+ * @returns a Promise that resolves when the data has made it to the parent.
+ */
+RefPtr<GenericPromise> FlushAndUseFOGData();
+
+/**
+ * ** Test-only Method **
+ *
+ * Trigger GMP, GPU, RDD or Socket process test instrumentation.
+ *
+ * @param processType - one of the PROCESS_TYPE_* constants from nsIXULRuntime.
+ * @param promise - a promise that will be resolved when the data has made it to
+ * the target process.
+ */
+void TestTriggerMetrics(uint32_t processType,
+ const RefPtr<dom::Promise>& promise);
+
+#ifdef NIGHTLY_BUILD
+/**
+ * This function records the CPU activity (CPU time used and wakeup count)
+ * of a specific thread. It is called only by profiler code, either multiple
+ * times in a row when RecordPowerMetrics asks the profiler to record
+ * the wakeup counts of all threads, or once when a thread is unregistered.
+ *
+ * @param aThreadName The name of the thread for which the CPU data is being
+ * recorded.
+ * The name will be converted to lower case, and characters
+ * that are not valid for glean labels will be replaced with
+ * '_'. The resulting name should be part of the
+ * per_thread_labels static list of labels defined in
+ * toolkit/components/processtools/metrics.yaml.
+ * @param aCpuTimeMs CPU time in miliseconds since the last time CPU use data
+ * was recorded for this thread.
+ * @param aWakeCount How many times the thread woke up since the previous time
+ * CPU use data was recorded for this thread.
+ */
+void RecordThreadCpuUse(const nsACString& aThreadName, uint64_t aCpuTimeMs,
+ uint64_t aWakeCount);
+#endif
+
+void RecordPowerMetrics();
+
+} // namespace glean
+} // namespace mozilla
+
+#endif // FOGIPC_h__
diff --git a/toolkit/components/glean/ipc/Support.cpp b/toolkit/components/glean/ipc/Support.cpp
new file mode 100644
index 0000000000..263c370cae
--- /dev/null
+++ b/toolkit/components/glean/ipc/Support.cpp
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This file is for support functions for the Rust IPC module.
+// Some information just isn't available to Rust and must be made available over
+// FFI.
+#include "FOGIPC.h"
+#include "mozilla/AppShutdown.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/glean/GleanMetrics.h"
+#include "mozilla/ipc/ByteBuf.h"
+#include "mozilla/Unused.h"
+#include "nsThreadUtils.h"
+
+using mozilla::AppShutdown;
+using mozilla::RunOnShutdown;
+using mozilla::ShutdownPhase;
+using mozilla::Unused;
+using mozilla::glean::FlushFOGData;
+using mozilla::glean::SendFOGData;
+using mozilla::ipc::ByteBuf;
+
+extern "C" {
+void FOG_RegisterContentChildShutdown() {
+ if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
+ return;
+ }
+
+ // If there is no main thread (too early in startup or too late in shutdown),
+ // there's nothing we can do but log.
+ bool failed =
+ NS_FAILED(NS_DispatchToMainThread(NS_NewRunnableFunction(__func__, [] {
+ // By the time the main thread dispatched this, it may already be too
+ // late.
+ if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownConfirmed)) {
+ return;
+ }
+ RunOnShutdown(
+ [] {
+ FlushFOGData(
+ [](ByteBuf&& aBuf) { SendFOGData(std::move(aBuf)); });
+ },
+ ShutdownPhase::AppShutdownConfirmed);
+ })));
+ if (failed) {
+ NS_WARNING(
+ "Failed to register FOG content child shutdown flush. "
+ "Will lose shutdown data and leak a runnable.");
+ mozilla::glean::fog_ipc::shutdown_registration_failures.Add(1);
+ }
+}
+
+int FOG_GetProcessType() { return XRE_GetProcessType(); }
+
+/**
+ * Called from FOG IPC in Rust when the IPC Payload might be getting full.
+ * We should probably flush before we reach the max IPC message size.
+ */
+void FOG_IPCPayloadFull() {
+ // NS_DispatchToMainThread can leak the runnable (bug 1787589), so let's be
+ // sure not to create it too late in shutdown.
+ // We choose XPCOMShutdown to match gFOG->Shutdown().
+ if (AppShutdown::IsInOrBeyond(ShutdownPhase::XPCOMShutdown)) {
+ return;
+ }
+ // FOG IPC must happen on the main thread until bug 1641989.
+ // If there is no main thread (too early in startup or too late in shutdown),
+ // there's nothing we can do but log.
+ Unused << NS_WARN_IF(NS_FAILED(NS_DispatchToMainThread(
+ NS_NewRunnableFunction("FOG IPC Payload getting full", [] {
+ FlushFOGData([](ByteBuf&& aBuf) { SendFOGData(std::move(aBuf)); });
+ }))));
+}
+}