Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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