Adding upstream version 124.0.1.upstream/124.0.1

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

12 files changed, 2180 insertions, 0 deletions

diff --git a/toolkit/components/telemetry/other/CombinedStacks.cpp b/toolkit/components/telemetry/other/CombinedStacks.cpp
new file mode 100644
index 0000000000..61248f9b40
--- /dev/null
+++ b/toolkit/components/telemetry/other/CombinedStacks.cpp
@@ -0,0 +1,257 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "CombinedStacks.h"
+
+#include "jsapi.h"
+#include "js/Array.h"               // JS::NewArrayObject
+#include "js/PropertyAndElement.h"  // JS_DefineElement, JS_DefineProperty
+#include "js/String.h"
+
+namespace mozilla::Telemetry {
+
+// The maximum number of chrome hangs stacks that we're keeping.
+const size_t kMaxChromeStacksKept = 50;
+
+CombinedStacks::CombinedStacks() : CombinedStacks(kMaxChromeStacksKept) {}
+
+CombinedStacks::CombinedStacks(size_t aMaxStacksCount)
+    : mNextIndex(0), mMaxStacksCount(aMaxStacksCount) {}
+
+size_t CombinedStacks::GetMaxStacksCount() const { return mMaxStacksCount; }
+size_t CombinedStacks::GetModuleCount() const { return mModules.size(); }
+
+const Telemetry::ProcessedStack::Module& CombinedStacks::GetModule(
+    unsigned aIndex) const {
+  return mModules[aIndex];
+}
+
+void CombinedStacks::AddFrame(
+    size_t aStackIndex, const ProcessedStack::Frame& aFrame,
+    const std::function<const ProcessedStack::Module&(int)>& aModuleGetter) {
+  uint16_t modIndex;
+  if (aFrame.mModIndex == std::numeric_limits<uint16_t>::max()) {
+    modIndex = aFrame.mModIndex;
+  } else {
+    const ProcessedStack::Module& module = aModuleGetter(aFrame.mModIndex);
+    auto modIterator = std::find(mModules.begin(), mModules.end(), module);
+    if (modIterator == mModules.end()) {
+      mModules.push_back(module);
+      modIndex = mModules.size() - 1;
+    } else {
+      modIndex = modIterator - mModules.begin();
+    }
+  }
+  mStacks[aStackIndex].push_back(
+      ProcessedStack::Frame{aFrame.mOffset, modIndex});
+}
+
+size_t CombinedStacks::AddStack(const Telemetry::ProcessedStack& aStack) {
+  size_t index = mNextIndex;
+  // Advance the indices of the circular queue holding the stacks.
+  mNextIndex = (mNextIndex + 1) % mMaxStacksCount;
+  // Grow the vector up to the maximum size, if needed.
+  if (mStacks.size() < mMaxStacksCount) {
+    mStacks.resize(mStacks.size() + 1);
+  }
+
+  // Clear the old stack before set.
+  mStacks[index].clear();
+
+  size_t stackSize = aStack.GetStackSize();
+  for (size_t i = 0; i < stackSize; ++i) {
+    // Need to specify a return type in the following lambda,
+    // otherwise it's incorrectly deduced to be a non-reference type.
+    AddFrame(index, aStack.GetFrame(i),
+             [&aStack](int aIdx) -> const ProcessedStack::Module& {
+               return aStack.GetModule(aIdx);
+             });
+  }
+  return index;
+}
+
+void CombinedStacks::AddStacks(const CombinedStacks& aStacks) {
+  mStacks.resize(
+      std::min(mStacks.size() + aStacks.GetStackCount(), mMaxStacksCount));
+
+  for (const auto& stack : aStacks.mStacks) {
+    size_t index = mNextIndex;
+    // Advance the indices of the circular queue holding the stacks.
+    mNextIndex = (mNextIndex + 1) % mMaxStacksCount;
+
+    // Clear the old stack before set.
+    mStacks[index].clear();
+
+    for (const auto& frame : stack) {
+      // Need to specify a return type in the following lambda,
+      // otherwise it's incorrectly deduced to be a non-reference type.
+      AddFrame(index, frame,
+               [&aStacks](int aIdx) -> const ProcessedStack::Module& {
+                 return aStacks.mModules[aIdx];
+               });
+    }
+  }
+}
+
+const CombinedStacks::Stack& CombinedStacks::GetStack(unsigned aIndex) const {
+  return mStacks[aIndex];
+}
+
+size_t CombinedStacks::GetStackCount() const { return mStacks.size(); }
+
+size_t CombinedStacks::SizeOfExcludingThis() const {
+  // This is a crude approximation. We would like to do something like
+  // aMallocSizeOf(&mModules[0]), but on linux aMallocSizeOf will call
+  // malloc_usable_size which is only safe on the pointers returned by malloc.
+  // While it works on current libstdc++, it is better to be safe and not assume
+  // that &vec[0] points to one. We could use a custom allocator, but
+  // it doesn't seem worth it.
+  size_t n = 0;
+  n += mModules.capacity() * sizeof(Telemetry::ProcessedStack::Module);
+  n += mStacks.capacity() * sizeof(Stack);
+  for (const auto& s : mStacks) {
+    n += s.capacity() * sizeof(Telemetry::ProcessedStack::Frame);
+  }
+  return n;
+}
+
+void CombinedStacks::RemoveStack(unsigned aIndex) {
+  MOZ_ASSERT(aIndex < mStacks.size());
+
+  mStacks.erase(mStacks.begin() + aIndex);
+
+  if (aIndex < mNextIndex) {
+    if (mNextIndex == 0) {
+      mNextIndex = mStacks.size();
+    } else {
+      mNextIndex--;
+    }
+  }
+
+  if (mNextIndex > mStacks.size()) {
+    mNextIndex = mStacks.size();
+  }
+}
+
+void CombinedStacks::Swap(CombinedStacks& aOther) {
+  mModules.swap(aOther.mModules);
+  mStacks.swap(aOther.mStacks);
+
+  size_t nextIndex = aOther.mNextIndex;
+  aOther.mNextIndex = mNextIndex;
+  mNextIndex = nextIndex;
+
+  size_t maxStacksCount = aOther.mMaxStacksCount;
+  aOther.mMaxStacksCount = mMaxStacksCount;
+  mMaxStacksCount = maxStacksCount;
+}
+
+void CombinedStacks::Clear() {
+  mNextIndex = 0;
+  mStacks.clear();
+  mModules.clear();
+}
+
+JSObject* CreateJSStackObject(JSContext* cx, const CombinedStacks& stacks) {
+  JS::Rooted<JSObject*> ret(cx, JS_NewPlainObject(cx));
+  if (!ret) {
+    return nullptr;
+  }
+
+  JS::Rooted<JSObject*> moduleArray(cx, JS::NewArrayObject(cx, 0));
+  if (!moduleArray) {
+    return nullptr;
+  }
+  bool ok =
+      JS_DefineProperty(cx, ret, "memoryMap", moduleArray, JSPROP_ENUMERATE);
+  if (!ok) {
+    return nullptr;
+  }
+
+  const size_t moduleCount = stacks.GetModuleCount();
+  for (size_t moduleIndex = 0; moduleIndex < moduleCount; ++moduleIndex) {
+    // Current module
+    const Telemetry::ProcessedStack::Module& module =
+        stacks.GetModule(moduleIndex);
+
+    JS::Rooted<JSObject*> moduleInfoArray(cx, JS::NewArrayObject(cx, 0));
+    if (!moduleInfoArray) {
+      return nullptr;
+    }
+    if (!JS_DefineElement(cx, moduleArray, moduleIndex, moduleInfoArray,
+                          JSPROP_ENUMERATE)) {
+      return nullptr;
+    }
+
+    unsigned index = 0;
+
+    // Module name
+    JS::Rooted<JSString*> str(cx, JS_NewUCStringCopyZ(cx, module.mName.get()));
+    if (!str || !JS_DefineElement(cx, moduleInfoArray, index++, str,
+                                  JSPROP_ENUMERATE)) {
+      return nullptr;
+    }
+
+    // Module breakpad identifier
+    JS::Rooted<JSString*> id(cx,
+                             JS_NewStringCopyZ(cx, module.mBreakpadId.get()));
+    if (!id ||
+        !JS_DefineElement(cx, moduleInfoArray, index, id, JSPROP_ENUMERATE)) {
+      return nullptr;
+    }
+  }
+
+  JS::Rooted<JSObject*> reportArray(cx, JS::NewArrayObject(cx, 0));
+  if (!reportArray) {
+    return nullptr;
+  }
+  ok = JS_DefineProperty(cx, ret, "stacks", reportArray, JSPROP_ENUMERATE);
+  if (!ok) {
+    return nullptr;
+  }
+
+  const size_t length = stacks.GetStackCount();
+  for (size_t i = 0; i < length; ++i) {
+    // Represent call stack PCs as (module index, offset) pairs.
+    JS::Rooted<JSObject*> pcArray(cx, JS::NewArrayObject(cx, 0));
+    if (!pcArray) {
+      return nullptr;
+    }
+
+    if (!JS_DefineElement(cx, reportArray, i, pcArray, JSPROP_ENUMERATE)) {
+      return nullptr;
+    }
+
+    const CombinedStacks::Stack& stack = stacks.GetStack(i);
+    const uint32_t pcCount = stack.size();
+    for (size_t pcIndex = 0; pcIndex < pcCount; ++pcIndex) {
+      const Telemetry::ProcessedStack::Frame& frame = stack[pcIndex];
+      JS::Rooted<JSObject*> framePair(cx, JS::NewArrayObject(cx, 0));
+      if (!framePair) {
+        return nullptr;
+      }
+      int modIndex = (std::numeric_limits<uint16_t>::max() == frame.mModIndex)
+                         ? -1
+                         : frame.mModIndex;
+      if (!JS_DefineElement(cx, framePair, 0, modIndex, JSPROP_ENUMERATE)) {
+        return nullptr;
+      }
+      if (!JS_DefineElement(cx, framePair, 1,
+                            static_cast<double>(frame.mOffset),
+                            JSPROP_ENUMERATE)) {
+        return nullptr;
+      }
+      if (!JS_DefineElement(cx, pcArray, pcIndex, framePair,
+                            JSPROP_ENUMERATE)) {
+        return nullptr;
+      }
+    }
+  }
+
+  return ret;
+}
+
+}  // namespace mozilla::Telemetry
diff --git a/toolkit/components/telemetry/other/CombinedStacks.h b/toolkit/components/telemetry/other/CombinedStacks.h
new file mode 100644
index 0000000000..6bd46823db
--- /dev/null
+++ b/toolkit/components/telemetry/other/CombinedStacks.h
@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 8; 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 CombinedStacks_h__
+#define CombinedStacks_h__
+
+#include <vector>
+
+#include "ipc/IPCMessageUtils.h"
+#include "ProcessedStack.h"
+
+class JSObject;
+struct JSContext;
+
+namespace mozilla {
+namespace Telemetry {
+
+/**
+ * This class is conceptually a list of ProcessedStack objects, but it
+ * represents them more efficiently by keeping a single global list of modules.
+ */
+class CombinedStacks {
+ public:
+  explicit CombinedStacks();
+  explicit CombinedStacks(size_t aMaxStacksCount);
+
+  CombinedStacks(CombinedStacks&&) = default;
+  CombinedStacks& operator=(CombinedStacks&&) = default;
+
+  void Swap(CombinedStacks& aOther);
+
+  typedef std::vector<Telemetry::ProcessedStack::Frame> Stack;
+  const Telemetry::ProcessedStack::Module& GetModule(unsigned aIndex) const;
+  size_t GetModuleCount() const;
+  const Stack& GetStack(unsigned aIndex) const;
+  size_t AddStack(const Telemetry::ProcessedStack& aStack);
+  void AddStacks(const CombinedStacks& aStacks);
+  size_t GetStackCount() const;
+  size_t SizeOfExcludingThis() const;
+  void RemoveStack(unsigned aIndex);
+  size_t GetMaxStacksCount() const;
+
+  /** Clears the contents of vectors and resets the index. */
+  void Clear();
+
+ private:
+  std::vector<Telemetry::ProcessedStack::Module> mModules;
+  // A circular buffer to hold the stacks.
+  std::vector<Stack> mStacks;
+  // The index of the next buffer element to write to in mStacks.
+  size_t mNextIndex;
+  // The maximum number of stacks to keep in the CombinedStacks object.
+  size_t mMaxStacksCount;
+
+  void AddFrame(
+      size_t aStackIndex, const ProcessedStack::Frame& aFrame,
+      const std::function<const ProcessedStack::Module&(int)>& aModuleGetter);
+
+  friend struct ::IPC::ParamTraits<CombinedStacks>;
+};
+
+/**
+ * Creates a JSON representation of given combined stacks object.
+ */
+JSObject* CreateJSStackObject(JSContext* cx, const CombinedStacks& stacks);
+
+}  // namespace Telemetry
+}  // namespace mozilla
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::Telemetry::CombinedStacks> {
+  typedef mozilla::Telemetry::CombinedStacks paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mModules);
+    WriteParam(aWriter, aParam.mStacks);
+    WriteParam(aWriter, aParam.mNextIndex);
+    WriteParam(aWriter, aParam.mMaxStacksCount);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->mModules)) {
+      return false;
+    }
+
+    if (!ReadParam(aReader, &aResult->mStacks)) {
+      return false;
+    }
+
+    if (!ReadParam(aReader, &aResult->mNextIndex)) {
+      return false;
+    }
+
+    if (!ReadParam(aReader, &aResult->mMaxStacksCount)) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+}  // namespace IPC
+
+#endif  // CombinedStacks_h__
diff --git a/toolkit/components/telemetry/other/ProcessedStack.cpp b/toolkit/components/telemetry/other/ProcessedStack.cpp
new file mode 100644
index 0000000000..ce62826a05
--- /dev/null
+++ b/toolkit/components/telemetry/other/ProcessedStack.cpp
@@ -0,0 +1,188 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "ProcessedStack.h"
+
+namespace {
+
+struct StackFrame {
+  uintptr_t mPC;    // The program counter at this position in the call stack.
+  uint16_t mIndex;  // The number of this frame in the call stack.
+  uint16_t mModIndex;  // The index of module that has this program counter.
+};
+
+#ifdef MOZ_GECKO_PROFILER
+static bool CompareByPC(const StackFrame& a, const StackFrame& b) {
+  return a.mPC < b.mPC;
+}
+
+static bool CompareByIndex(const StackFrame& a, const StackFrame& b) {
+  return a.mIndex < b.mIndex;
+}
+#endif
+
+}  // namespace
+
+namespace mozilla::Telemetry {
+
+const size_t kMaxChromeStackDepth = 50;
+
+ProcessedStack::ProcessedStack() = default;
+
+size_t ProcessedStack::GetStackSize() const { return mStack.size(); }
+
+size_t ProcessedStack::GetNumModules() const { return mModules.size(); }
+
+bool ProcessedStack::Module::operator==(const Module& aOther) const {
+  return mName == aOther.mName && mBreakpadId == aOther.mBreakpadId;
+}
+
+const ProcessedStack::Frame& ProcessedStack::GetFrame(unsigned aIndex) const {
+  MOZ_ASSERT(aIndex < mStack.size());
+  return mStack[aIndex];
+}
+
+void ProcessedStack::AddFrame(const Frame& aFrame) { mStack.push_back(aFrame); }
+
+const ProcessedStack::Module& ProcessedStack::GetModule(unsigned aIndex) const {
+  MOZ_ASSERT(aIndex < mModules.size());
+  return mModules[aIndex];
+}
+
+void ProcessedStack::AddModule(const Module& aModule) {
+  mModules.push_back(aModule);
+}
+
+void ProcessedStack::Clear() {
+  mModules.clear();
+  mStack.clear();
+}
+
+ProcessedStack GetStackAndModules(const std::vector<uintptr_t>& aPCs) {
+  return BatchProcessedStackGenerator().GetStackAndModules(aPCs);
+}
+
+BatchProcessedStackGenerator::BatchProcessedStackGenerator()
+#ifdef MOZ_GECKO_PROFILER
+    : mSortedRawModules(SharedLibraryInfo::GetInfoForSelf())
+#endif
+{
+#ifdef MOZ_GECKO_PROFILER
+  mSortedRawModules.SortByAddress();
+#endif
+}
+
+#ifndef MOZ_GECKO_PROFILER
+static ProcessedStack GetStackAndModulesInternal(
+    std::vector<StackFrame>& aRawStack) {
+#else
+static ProcessedStack GetStackAndModulesInternal(
+    std::vector<StackFrame>& aRawStack, SharedLibraryInfo& aSortedRawModules) {
+  SharedLibraryInfo rawModules(aSortedRawModules);
+  // Remove all modules not referenced by a PC on the stack
+  std::sort(aRawStack.begin(), aRawStack.end(), CompareByPC);
+
+  size_t moduleIndex = 0;
+  size_t stackIndex = 0;
+  size_t stackSize = aRawStack.size();
+
+  while (moduleIndex < rawModules.GetSize()) {
+    const SharedLibrary& module = rawModules.GetEntry(moduleIndex);
+    uintptr_t moduleStart = module.GetStart();
+    uintptr_t moduleEnd = module.GetEnd() - 1;
+    // the interval is [moduleStart, moduleEnd)
+
+    bool moduleReferenced = false;
+    for (; stackIndex < stackSize; ++stackIndex) {
+      uintptr_t pc = aRawStack[stackIndex].mPC;
+      if (pc >= moduleEnd) break;
+
+      if (pc >= moduleStart) {
+        // If the current PC is within the current module, mark
+        // module as used
+        moduleReferenced = true;
+        aRawStack[stackIndex].mPC -= moduleStart;
+        aRawStack[stackIndex].mModIndex = moduleIndex;
+      } else {
+        // PC does not belong to any module. It is probably from
+        // the JIT. Use a fixed mPC so that we don't get different
+        // stacks on different runs.
+        aRawStack[stackIndex].mPC = std::numeric_limits<uintptr_t>::max();
+      }
+    }
+
+    if (moduleReferenced) {
+      ++moduleIndex;
+    } else {
+      // Remove module if no PCs within its address range
+      rawModules.RemoveEntries(moduleIndex, moduleIndex + 1);
+    }
+  }
+
+  for (; stackIndex < stackSize; ++stackIndex) {
+    // These PCs are past the last module.
+    aRawStack[stackIndex].mPC = std::numeric_limits<uintptr_t>::max();
+  }
+
+  std::sort(aRawStack.begin(), aRawStack.end(), CompareByIndex);
+#endif
+
+  // Copy the information to the return value.
+  ProcessedStack Ret;
+  for (auto& rawFrame : aRawStack) {
+    mozilla::Telemetry::ProcessedStack::Frame frame = {rawFrame.mPC,
+                                                       rawFrame.mModIndex};
+    Ret.AddFrame(frame);
+  }
+
+#ifdef MOZ_GECKO_PROFILER
+  for (unsigned i = 0, n = rawModules.GetSize(); i != n; ++i) {
+    const SharedLibrary& info = rawModules.GetEntry(i);
+    mozilla::Telemetry::ProcessedStack::Module module = {info.GetDebugName(),
+                                                         info.GetBreakpadId()};
+    Ret.AddModule(module);
+  }
+#endif
+
+  return Ret;
+}
+
+ProcessedStack BatchProcessedStackGenerator::GetStackAndModules(
+    const std::vector<uintptr_t>& aPCs) {
+  std::vector<StackFrame> rawStack;
+  auto stackEnd = aPCs.begin() + std::min(aPCs.size(), kMaxChromeStackDepth);
+  for (auto i = aPCs.begin(); i != stackEnd; ++i) {
+    uintptr_t aPC = *i;
+    StackFrame Frame = {aPC, static_cast<uint16_t>(rawStack.size()),
+                        std::numeric_limits<uint16_t>::max()};
+    rawStack.push_back(Frame);
+  }
+
+#if defined(MOZ_GECKO_PROFILER)
+  return GetStackAndModulesInternal(rawStack, mSortedRawModules);
+#else
+  return GetStackAndModulesInternal(rawStack);
+#endif
+}
+
+ProcessedStack BatchProcessedStackGenerator::GetStackAndModules(
+    const uintptr_t* aBegin, const uintptr_t* aEnd) {
+  std::vector<StackFrame> rawStack;
+  for (auto i = aBegin; i != aEnd; ++i) {
+    uintptr_t aPC = *i;
+    StackFrame Frame = {aPC, static_cast<uint16_t>(rawStack.size()),
+                        std::numeric_limits<uint16_t>::max()};
+    rawStack.push_back(Frame);
+  }
+
+#if defined(MOZ_GECKO_PROFILER)
+  return GetStackAndModulesInternal(rawStack, mSortedRawModules);
+#else
+  return GetStackAndModulesInternal(rawStack);
+#endif
+}
+
+}  // namespace mozilla::Telemetry
diff --git a/toolkit/components/telemetry/other/ProcessedStack.h b/toolkit/components/telemetry/other/ProcessedStack.h
new file mode 100644
index 0000000000..375cab37a7
--- /dev/null
+++ b/toolkit/components/telemetry/other/ProcessedStack.h
@@ -0,0 +1,135 @@
+/* -*- 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 ProcessedStack_h__
+#define ProcessedStack_h__
+
+#include <vector>
+
+#include "ipc/IPCMessageUtils.h"
+#include "ipc/IPCMessageUtilsSpecializations.h"
+#include "mozilla/ipc/MessageChannel.h"
+#include "mozilla/Vector.h"
+#include "nsStringFwd.h"
+#include "shared-libraries.h"
+
+namespace mozilla {
+namespace Telemetry {
+
+// This class represents a stack trace and the modules referenced in that trace.
+// It is designed to be easy to read and write to disk or network and doesn't
+// include any logic on how to collect or read the information it stores.
+class ProcessedStack {
+ public:
+  ProcessedStack();
+  size_t GetStackSize() const;
+  size_t GetNumModules() const;
+
+  struct Frame {
+    // The offset of this program counter in its module or an absolute pc.
+    uintptr_t mOffset;
+    // The index to pass to GetModule to get the module this program counter
+    // was in.
+    uint16_t mModIndex;
+  };
+  struct Module {
+    // The file name, /foo/bar/libxul.so for example.
+    // It can contain unicode characters.
+    nsString mName;
+    nsCString mBreakpadId;
+
+    bool operator==(const Module& other) const;
+  };
+
+  const Frame& GetFrame(unsigned aIndex) const;
+  void AddFrame(const Frame& aFrame);
+  const Module& GetModule(unsigned aIndex) const;
+  void AddModule(const Module& aFrame);
+
+  void Clear();
+
+ private:
+  std::vector<Module> mModules;
+  std::vector<Frame> mStack;
+};
+
+// Get the current list of loaded modules, filter and pair it to the provided
+// stack. We let the caller collect the stack since different callers have
+// different needs (current thread X main thread, stopping the thread, etc).
+ProcessedStack GetStackAndModules(const std::vector<uintptr_t>& aPCs);
+
+// This class optimizes repeated calls to GetStackAndModules.
+class BatchProcessedStackGenerator {
+ public:
+  BatchProcessedStackGenerator();
+  ProcessedStack GetStackAndModules(const std::vector<uintptr_t>& aPCs);
+
+  template <typename AllocatorPolicy>
+  ProcessedStack GetStackAndModules(
+      const Vector<void*, 0, AllocatorPolicy>& aPCs) {
+    return GetStackAndModules(reinterpret_cast<const uintptr_t*>(aPCs.begin()),
+                              reinterpret_cast<const uintptr_t*>(aPCs.end()));
+  }
+
+ private:
+  ProcessedStack GetStackAndModules(const uintptr_t* aBegin,
+                                    const uintptr_t* aEnd);
+#if defined(MOZ_GECKO_PROFILER)
+  SharedLibraryInfo mSortedRawModules;
+#endif
+};
+
+}  // namespace Telemetry
+}  // namespace mozilla
+
+namespace IPC {
+
+template <>
+struct ParamTraits<mozilla::Telemetry::ProcessedStack::Module> {
+  typedef mozilla::Telemetry::ProcessedStack::Module paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mName);
+    WriteParam(aWriter, aParam.mBreakpadId);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->mName)) {
+      return false;
+    }
+
+    if (!ReadParam(aReader, &aResult->mBreakpadId)) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+template <>
+struct ParamTraits<mozilla::Telemetry::ProcessedStack::Frame> {
+  typedef mozilla::Telemetry::ProcessedStack::Frame paramType;
+
+  static void Write(MessageWriter* aWriter, const paramType& aParam) {
+    WriteParam(aWriter, aParam.mOffset);
+    WriteParam(aWriter, aParam.mModIndex);
+  }
+
+  static bool Read(MessageReader* aReader, paramType* aResult) {
+    if (!ReadParam(aReader, &aResult->mOffset)) {
+      return false;
+    }
+
+    if (!ReadParam(aReader, &aResult->mModIndex)) {
+      return false;
+    }
+
+    return true;
+  }
+};
+
+}  // namespace IPC
+
+#endif  // ProcessedStack_h__
diff --git a/toolkit/components/telemetry/other/TelemetryIOInterposeObserver.cpp b/toolkit/components/telemetry/other/TelemetryIOInterposeObserver.cpp
new file mode 100644
index 0000000000..c0792bb48c
--- /dev/null
+++ b/toolkit/components/telemetry/other/TelemetryIOInterposeObserver.cpp
@@ -0,0 +1,182 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "TelemetryIOInterposeObserver.h"
+#include "core/TelemetryCommon.h"
+#include "js/Array.h"               // JS::NewArrayObject
+#include "js/PropertyAndElement.h"  // JS_DefineUCProperty
+#include "js/PropertyDescriptor.h"  // JSPROP_ENUMERATE, JSPROP_READONLY
+#include "js/ValueArray.h"
+#include "nsIFile.h"
+
+namespace mozilla::Telemetry {
+
+TelemetryIOInterposeObserver::TelemetryIOInterposeObserver(nsIFile* aXreDir)
+    : mCurStage(STAGE_STARTUP) {
+  nsAutoString xreDirPath;
+  nsresult rv = aXreDir->GetPath(xreDirPath);
+  if (NS_SUCCEEDED(rv)) {
+    AddPath(xreDirPath, u"{xre}"_ns);
+  }
+}
+
+void TelemetryIOInterposeObserver::AddPath(const nsAString& aPath,
+                                           const nsAString& aSubstName) {
+  mSafeDirs.AppendElement(SafeDir(aPath, aSubstName));
+}
+
+// Threshold for reporting slow main-thread I/O (50 milliseconds).
+const TimeDuration kTelemetryReportThreshold =
+    TimeDuration::FromMilliseconds(50);
+
+void TelemetryIOInterposeObserver::Observe(Observation& aOb) {
+  // We only report main-thread I/O
+  if (!IsMainThread()) {
+    return;
+  }
+
+  if (aOb.ObservedOperation() == OpNextStage) {
+    mCurStage = NextStage(mCurStage);
+    MOZ_ASSERT(mCurStage < NUM_STAGES);
+    return;
+  }
+
+  if (aOb.Duration() < kTelemetryReportThreshold) {
+    return;
+  }
+
+  // Get the filename
+  nsAutoString filename;
+  aOb.Filename(filename);
+
+  // Discard observations without filename
+  if (filename.IsEmpty()) {
+    return;
+  }
+
+#if defined(XP_WIN)
+  auto comparator = nsCaseInsensitiveStringComparator;
+#else
+  auto comparator = nsTDefaultStringComparator<char16_t>;
+#endif
+  nsAutoString processedName;
+  uint32_t safeDirsLen = mSafeDirs.Length();
+  for (uint32_t i = 0; i < safeDirsLen; ++i) {
+    if (StringBeginsWith(filename, mSafeDirs[i].mPath, comparator)) {
+      processedName = mSafeDirs[i].mSubstName;
+      processedName += Substring(filename, mSafeDirs[i].mPath.Length());
+      break;
+    }
+  }
+
+  if (processedName.IsEmpty()) {
+    return;
+  }
+
+  // Create a new entry or retrieve the existing one
+  FileIOEntryType* entry = mFileStats.PutEntry(processedName);
+  if (entry) {
+    FileStats& stats = entry->GetModifiableData()->mStats[mCurStage];
+    // Update the statistics
+    stats.totalTime += (double)aOb.Duration().ToMilliseconds();
+    switch (aOb.ObservedOperation()) {
+      case OpCreateOrOpen:
+        stats.creates++;
+        break;
+      case OpRead:
+        stats.reads++;
+        break;
+      case OpWrite:
+        stats.writes++;
+        break;
+      case OpFSync:
+        stats.fsyncs++;
+        break;
+      case OpStat:
+        stats.stats++;
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+bool TelemetryIOInterposeObserver::ReflectFileStats(FileIOEntryType* entry,
+                                                    JSContext* cx,
+                                                    JS::Handle<JSObject*> obj) {
+  JS::RootedValueArray<NUM_STAGES> stages(cx);
+
+  FileStatsByStage& statsByStage = *entry->GetModifiableData();
+  for (int s = STAGE_STARTUP; s < NUM_STAGES; ++s) {
+    FileStats& fileStats = statsByStage.mStats[s];
+
+    if (fileStats.totalTime == 0 && fileStats.creates == 0 &&
+        fileStats.reads == 0 && fileStats.writes == 0 &&
+        fileStats.fsyncs == 0 && fileStats.stats == 0) {
+      // Don't add an array that contains no information
+      stages[s].setNull();
+      continue;
+    }
+
+    // Array we want to report
+    JS::RootedValueArray<6> stats(cx);
+    stats[0].setNumber(fileStats.totalTime);
+    stats[1].setNumber(fileStats.creates);
+    stats[2].setNumber(fileStats.reads);
+    stats[3].setNumber(fileStats.writes);
+    stats[4].setNumber(fileStats.fsyncs);
+    stats[5].setNumber(fileStats.stats);
+
+    // Create jsStats as array of elements above
+    JS::Rooted<JSObject*> jsStats(cx, JS::NewArrayObject(cx, stats));
+    if (!jsStats) {
+      continue;
+    }
+
+    stages[s].setObject(*jsStats);
+  }
+
+  JS::Rooted<JSObject*> jsEntry(cx, JS::NewArrayObject(cx, stages));
+  if (!jsEntry) {
+    return false;
+  }
+
+  // Add jsEntry to top-level dictionary
+  const nsAString& key = entry->GetKey();
+  return JS_DefineUCProperty(cx, obj, key.Data(), key.Length(), jsEntry,
+                             JSPROP_ENUMERATE | JSPROP_READONLY);
+}
+
+bool TelemetryIOInterposeObserver::ReflectIntoJS(
+    JSContext* cx, JS::Handle<JSObject*> rootObj) {
+  return mFileStats.ReflectIntoJS(ReflectFileStats, cx, rootObj);
+}
+
+/**
+ * Get size of hash table with file stats
+ */
+
+size_t TelemetryIOInterposeObserver::SizeOfIncludingThis(
+    mozilla::MallocSizeOf aMallocSizeOf) const {
+  return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+size_t TelemetryIOInterposeObserver::SizeOfExcludingThis(
+    mozilla::MallocSizeOf aMallocSizeOf) const {
+  size_t size = 0;
+  size += mFileStats.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  for (auto iter = mFileStats.ConstIter(); !iter.Done(); iter.Next()) {
+    size += iter.Get()->GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+  }
+  size += mSafeDirs.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  uint32_t safeDirsLen = mSafeDirs.Length();
+  for (uint32_t i = 0; i < safeDirsLen; ++i) {
+    size += mSafeDirs[i].SizeOfExcludingThis(aMallocSizeOf);
+  }
+  return size;
+}
+
+}  // namespace mozilla::Telemetry
diff --git a/toolkit/components/telemetry/other/TelemetryIOInterposeObserver.h b/toolkit/components/telemetry/other/TelemetryIOInterposeObserver.h
new file mode 100644
index 0000000000..54e3caf9b4
--- /dev/null
+++ b/toolkit/components/telemetry/other/TelemetryIOInterposeObserver.h
@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+/**
+ * IOInterposeObserver recording statistics of main-thread I/O during execution,
+ * aimed at consumption by TelemetryImpl
+ */
+
+#ifndef TelemetryIOInterposeObserver_h__
+#define TelemetryIOInterposeObserver_h__
+
+#include "core/TelemetryCommon.h"
+#include "js/RootingAPI.h"
+#include "js/TypeDecls.h"
+#include "mozilla/IOInterposer.h"
+#include "nsBaseHashtable.h"
+#include "nsHashKeys.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace Telemetry {
+
+class TelemetryIOInterposeObserver : public IOInterposeObserver {
+  /** File-level statistics structure */
+  struct FileStats {
+    FileStats()
+        : creates(0), reads(0), writes(0), fsyncs(0), stats(0), totalTime(0) {}
+    uint32_t creates; /** Number of create/open operations */
+    uint32_t reads;   /** Number of read operations */
+    uint32_t writes;  /** Number of write operations */
+    uint32_t fsyncs;  /** Number of fsync operations */
+    uint32_t stats;   /** Number of stat operations */
+    double totalTime; /** Accumulated duration of all operations */
+  };
+
+  struct SafeDir {
+    SafeDir(const nsAString& aPath, const nsAString& aSubstName)
+        : mPath(aPath), mSubstName(aSubstName) {}
+    size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+      return mPath.SizeOfExcludingThisIfUnshared(aMallocSizeOf) +
+             mSubstName.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+    }
+    nsString mPath;      /** Path to the directory */
+    nsString mSubstName; /** Name to substitute with */
+  };
+
+ public:
+  explicit TelemetryIOInterposeObserver(nsIFile* aXreDir);
+
+  /**
+   * An implementation of Observe that records statistics of all
+   * file IO operations.
+   */
+  void Observe(Observation& aOb) override;
+
+  /**
+   * Reflect recorded file IO statistics into Javascript
+   */
+  bool ReflectIntoJS(JSContext* cx, JS::Handle<JSObject*> rootObj);
+
+  /**
+   * Adds a path for inclusion in main thread I/O report.
+   * @param aPath Directory path
+   * @param aSubstName Name to substitute for aPath for privacy reasons
+   */
+  void AddPath(const nsAString& aPath, const nsAString& aSubstName);
+
+  /**
+   * Get size of hash table with file stats
+   */
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ private:
+  enum Stage { STAGE_STARTUP = 0, STAGE_NORMAL, STAGE_SHUTDOWN, NUM_STAGES };
+  static inline Stage NextStage(Stage aStage) {
+    switch (aStage) {
+      case STAGE_STARTUP:
+        return STAGE_NORMAL;
+      case STAGE_NORMAL:
+        return STAGE_SHUTDOWN;
+      case STAGE_SHUTDOWN:
+        return STAGE_SHUTDOWN;
+      default:
+        return NUM_STAGES;
+    }
+  }
+
+  struct FileStatsByStage {
+    FileStats mStats[NUM_STAGES];
+  };
+  typedef nsBaseHashtableET<nsStringHashKey, FileStatsByStage> FileIOEntryType;
+
+  // Statistics for each filename
+  Common::AutoHashtable<FileIOEntryType> mFileStats;
+  // Container for allowed directories
+  nsTArray<SafeDir> mSafeDirs;
+  Stage mCurStage;
+
+  /**
+   * Reflect a FileIOEntryType object to a Javascript property on obj with
+   * filename as key containing array:
+   * [totalTime, creates, reads, writes, fsyncs, stats]
+   */
+  static bool ReflectFileStats(FileIOEntryType* entry, JSContext* cx,
+                               JS::Handle<JSObject*> obj);
+};
+
+}  // namespace Telemetry
+}  // namespace mozilla
+
+#endif  // TelemetryIOInterposeObserver_h__
diff --git a/toolkit/components/telemetry/other/UntrustedModules.cpp b/toolkit/components/telemetry/other/UntrustedModules.cpp
new file mode 100644
index 0000000000..7a80cd9c8d
--- /dev/null
+++ b/toolkit/components/telemetry/other/UntrustedModules.cpp
@@ -0,0 +1,305 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "UntrustedModules.h"
+
+#include "GMPServiceParent.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/net/SocketProcessParent.h"
+#include "mozilla/ipc/UtilityProcessParent.h"
+#include "mozilla/ipc/UtilityProcessManager.h"
+#include "mozilla/RDDChild.h"
+#include "mozilla/RDDProcessManager.h"
+#include "mozilla/WinDllServices.h"
+#include "nsISupportsImpl.h"
+#include "nsProxyRelease.h"
+#include "nsXULAppAPI.h"
+#include "UntrustedModulesDataSerializer.h"
+
+namespace mozilla {
+namespace Telemetry {
+
+static const uint32_t kMaxModulesArrayLen = 100;
+
+using UntrustedModulesIpcPromise =
+    MozPromise<Maybe<UntrustedModulesData>, ipc::ResponseRejectReason, true>;
+
+using MultiGetUntrustedModulesPromise =
+    MozPromise<bool /*aIgnored*/, nsresult, true>;
+
+class MOZ_HEAP_CLASS MultiGetUntrustedModulesData final {
+ public:
+  /**
+   * @param aFlags [in] Combinations of the flags defined under nsITelemetry.
+   *               (See "Flags for getUntrustedModuleLoadEvents"
+   *                in nsITelemetry.idl)
+   */
+  explicit MultiGetUntrustedModulesData(uint32_t aFlags)
+      : mFlags(aFlags),
+        mBackupSvc(UntrustedModulesBackupService::Get()),
+        mPromise(new MultiGetUntrustedModulesPromise::Private(__func__)),
+        mNumPending(0) {}
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MultiGetUntrustedModulesData)
+
+  RefPtr<MultiGetUntrustedModulesPromise> GetUntrustedModuleLoadEvents();
+  void Serialize(RefPtr<dom::Promise>&& aPromise);
+
+  MultiGetUntrustedModulesData(const MultiGetUntrustedModulesData&) = delete;
+  MultiGetUntrustedModulesData(MultiGetUntrustedModulesData&&) = delete;
+  MultiGetUntrustedModulesData& operator=(const MultiGetUntrustedModulesData&) =
+      delete;
+  MultiGetUntrustedModulesData& operator=(MultiGetUntrustedModulesData&&) =
+      delete;
+
+ private:
+  ~MultiGetUntrustedModulesData() = default;
+
+  void AddPending(RefPtr<UntrustedModulesPromise>&& aNewPending) {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    ++mNumPending;
+
+    RefPtr<MultiGetUntrustedModulesData> self(this);
+    aNewPending->Then(
+        GetMainThreadSerialEventTarget(), __func__,
+        [self](Maybe<UntrustedModulesData>&& aResult) {
+          self->OnCompletion(std::move(aResult));
+        },
+        [self](nsresult aReason) { self->OnCompletion(); });
+  }
+
+  void AddPending(RefPtr<UntrustedModulesIpcPromise>&& aNewPending) {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    ++mNumPending;
+
+    RefPtr<MultiGetUntrustedModulesData> self(this);
+    aNewPending->Then(
+        GetMainThreadSerialEventTarget(), __func__,
+        [self](Maybe<UntrustedModulesData>&& aResult) {
+          self->OnCompletion(std::move(aResult));
+        },
+        [self](ipc::ResponseRejectReason&& aReason) { self->OnCompletion(); });
+  }
+
+  void OnCompletion() {
+    MOZ_ASSERT(NS_IsMainThread() && mNumPending > 0);
+
+    --mNumPending;
+    if (mNumPending) {
+      return;
+    }
+
+    mPromise->Resolve(true, __func__);
+  }
+
+  void OnCompletion(Maybe<UntrustedModulesData>&& aResult) {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    if (aResult.isSome()) {
+      mBackupSvc->Backup(std::move(aResult.ref()));
+    }
+
+    OnCompletion();
+  }
+
+ private:
+  // Combinations of the flags defined under nsITelemetry.
+  // (See "Flags for getUntrustedModuleLoadEvents" in nsITelemetry.idl)
+  uint32_t mFlags;
+
+  RefPtr<UntrustedModulesBackupService> mBackupSvc;
+  RefPtr<MultiGetUntrustedModulesPromise::Private> mPromise;
+  size_t mNumPending;
+};
+
+RefPtr<MultiGetUntrustedModulesPromise>
+MultiGetUntrustedModulesData::GetUntrustedModuleLoadEvents() {
+  MOZ_ASSERT(XRE_IsParentProcess() && NS_IsMainThread());
+
+  // Parent process
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  AddPending(dllSvc->GetUntrustedModulesData());
+
+  // Child processes
+  nsTArray<dom::ContentParent*> contentParents;
+  dom::ContentParent::GetAll(contentParents);
+  for (auto&& contentParent : contentParents) {
+    AddPending(contentParent->SendGetUntrustedModulesData());
+  }
+
+  if (auto* socketActor = net::SocketProcessParent::GetSingleton()) {
+    AddPending(socketActor->SendGetUntrustedModulesData());
+  }
+
+  if (RDDProcessManager* rddMgr = RDDProcessManager::Get()) {
+    if (RDDChild* rddChild = rddMgr->GetRDDChild()) {
+      AddPending(rddChild->SendGetUntrustedModulesData());
+    }
+  }
+
+  if (RefPtr<ipc::UtilityProcessManager> utilityManager =
+          ipc::UtilityProcessManager::GetIfExists()) {
+    for (RefPtr<ipc::UtilityProcessParent>& parent :
+         utilityManager->GetAllProcessesProcessParent()) {
+      AddPending(parent->SendGetUntrustedModulesData());
+    }
+  }
+
+  if (RefPtr<gmp::GeckoMediaPluginServiceParent> gmps =
+          gmp::GeckoMediaPluginServiceParent::GetSingleton()) {
+    nsTArray<RefPtr<
+        gmp::GeckoMediaPluginServiceParent::GetUntrustedModulesDataPromise>>
+        promises;
+    gmps->SendGetUntrustedModulesData(promises);
+    for (auto& promise : promises) {
+      AddPending(std::move(promise));
+    }
+  }
+
+  return mPromise;
+}
+
+void MultiGetUntrustedModulesData::Serialize(RefPtr<dom::Promise>&& aPromise) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  dom::AutoJSAPI jsapi;
+  if (NS_WARN_IF(!jsapi.Init(aPromise->GetGlobalObject()))) {
+    aPromise->MaybeReject(NS_ERROR_FAILURE);
+    return;
+  }
+
+  JSContext* cx = jsapi.cx();
+  UntrustedModulesDataSerializer serializer(cx, kMaxModulesArrayLen, mFlags);
+  if (!serializer) {
+    aPromise->MaybeReject(NS_ERROR_FAILURE);
+    return;
+  }
+
+  nsresult rv;
+  if (mFlags & nsITelemetry::INCLUDE_OLD_LOADEVENTS) {
+    // When INCLUDE_OLD_LOADEVENTS is set, we need to return instances
+    // from both "Staging" and "Settled" backup.
+    if (mFlags & nsITelemetry::KEEP_LOADEVENTS_NEW) {
+      // When INCLUDE_OLD_LOADEVENTS and KEEP_LOADEVENTS_NEW are set, we need to
+      // return a JS object consisting of all instances from both "Staging" and
+      // "Settled" backups, keeping instances in those backups as is.
+      if (mFlags & nsITelemetry::EXCLUDE_STACKINFO_FROM_LOADEVENTS) {
+        // Without the stack info, we can add multiple UntrustedModulesData to
+        // the serializer directly.
+        rv = serializer.Add(mBackupSvc->Staging());
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          aPromise->MaybeReject(rv);
+          return;
+        }
+        rv = serializer.Add(mBackupSvc->Settled());
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          aPromise->MaybeReject(rv);
+          return;
+        }
+      } else {
+        // Currently we don't have a method to merge UntrustedModulesData into
+        // a serialized JS object because merging CombinedStack will be tricky.
+        // Thus we return an error on this flag combination.
+        aPromise->MaybeReject(NS_ERROR_INVALID_ARG);
+        return;
+      }
+    } else {
+      // When KEEP_LOADEVENTS_NEW is not set, we can move data from "Staging"
+      // to "Settled" first, then add "Settled" to the serializer.
+      mBackupSvc->SettleAllStagingData();
+
+      const UntrustedModulesBackupData& settledRef = mBackupSvc->Settled();
+      if (settledRef.IsEmpty()) {
+        aPromise->MaybeReject(NS_ERROR_NOT_AVAILABLE);
+        return;
+      }
+
+      rv = serializer.Add(settledRef);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        aPromise->MaybeReject(rv);
+        return;
+      }
+    }
+  } else {
+    // When INCLUDE_OLD_LOADEVENTS is not set, we serialize only the "Staging"
+    // into a JS object.
+    const UntrustedModulesBackupData& stagingRef = mBackupSvc->Staging();
+
+    if (stagingRef.IsEmpty()) {
+      aPromise->MaybeReject(NS_ERROR_NOT_AVAILABLE);
+      return;
+    }
+
+    rv = serializer.Add(stagingRef);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      aPromise->MaybeReject(rv);
+      return;
+    }
+
+    // When KEEP_LOADEVENTS_NEW is not set, we move all "Staging" instances
+    // to the "Settled".
+    if (!(mFlags & nsITelemetry::KEEP_LOADEVENTS_NEW)) {
+      mBackupSvc->SettleAllStagingData();
+    }
+  }
+
+#if defined(XP_WIN)
+  RefPtr<DllServices> dllSvc(DllServices::Get());
+  nt::SharedSection* sharedSection = dllSvc->GetSharedSection();
+  if (sharedSection) {
+    auto dynamicBlocklist = sharedSection->GetDynamicBlocklist();
+
+    nsTArray<nsDependentSubstring> blockedModules;
+    for (const auto& blockedEntry : dynamicBlocklist) {
+      if (!blockedEntry.IsValidDynamicBlocklistEntry()) {
+        break;
+      }
+      blockedModules.AppendElement(
+          nsDependentSubstring(blockedEntry.mName.Buffer,
+                               blockedEntry.mName.Length / sizeof(wchar_t)));
+    }
+    rv = serializer.AddBlockedModules(blockedModules);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      aPromise->MaybeReject(rv);
+      return;
+    }
+  }
+#endif
+
+  JS::Rooted<JS::Value> jsval(cx);
+  serializer.GetObject(&jsval);
+  aPromise->MaybeResolve(jsval);
+}
+
+nsresult GetUntrustedModuleLoadEvents(uint32_t aFlags, JSContext* cx,
+                                      dom::Promise** aPromise) {
+  // Create a promise using global context.
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(cx);
+  if (NS_WARN_IF(!global)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  ErrorResult result;
+  RefPtr<dom::Promise> promise(dom::Promise::Create(global, result));
+  if (NS_WARN_IF(result.Failed())) {
+    return result.StealNSResult();
+  }
+
+  auto multi = MakeRefPtr<MultiGetUntrustedModulesData>(aFlags);
+  multi->GetUntrustedModuleLoadEvents()->Then(
+      GetMainThreadSerialEventTarget(), __func__,
+      [promise, multi](bool) mutable { multi->Serialize(std::move(promise)); },
+      [promise](nsresult aRv) { promise->MaybeReject(aRv); });
+
+  promise.forget(aPromise);
+  return NS_OK;
+}
+
+}  // namespace Telemetry
+}  // namespace mozilla
diff --git a/toolkit/components/telemetry/other/UntrustedModules.h b/toolkit/components/telemetry/other/UntrustedModules.h
new file mode 100644
index 0000000000..3bb53c1f9a
--- /dev/null
+++ b/toolkit/components/telemetry/other/UntrustedModules.h
@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 telemetry_UntrustedModules_h__
+#define telemetry_UntrustedModules_h__
+
+#include "jsapi.h"
+#include "mozilla/dom/Promise.h"
+
+namespace mozilla {
+namespace Telemetry {
+
+/**
+ * This function returns a promise that asynchronously processes and gathers
+ * untrusted module data. The promise is either resolved with the JS object
+ * ping payload, or is rejected upon failure.
+ *
+ * @param aFlags [in] Combinations of the flags defined under nsITelemetry.
+ *               (See "Flags for getUntrustedModuleLoadEvents"
+ *                in nsITelemetry.idl)
+ */
+nsresult GetUntrustedModuleLoadEvents(uint32_t aFlags, JSContext* cx,
+                                      dom::Promise** aPromise);
+
+}  // namespace Telemetry
+}  // namespace mozilla
+
+#endif  // telemetry_UntrustedModules_h__
diff --git a/toolkit/components/telemetry/other/UntrustedModulesBackupService.cpp b/toolkit/components/telemetry/other/UntrustedModulesBackupService.cpp
new file mode 100644
index 0000000000..1cbe35e8c0
--- /dev/null
+++ b/toolkit/components/telemetry/other/UntrustedModulesBackupService.cpp
@@ -0,0 +1,95 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+#include "UntrustedModulesBackupService.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/HashFunctions.h"
+#include "mozilla/SchedulerGroup.h"
+#include "mozilla/StaticLocalPtr.h"
+
+namespace mozilla {
+
+ProcessHashKey::ProcessHashKey(GeckoProcessType aType, DWORD aPid)
+    : mType(aType), mPid(aPid) {}
+
+bool ProcessHashKey::operator==(const ProcessHashKey& aOther) const {
+  return mPid == aOther.mPid && mType == aOther.mType;
+}
+
+PLDHashNumber ProcessHashKey::Hash() const { return HashGeneric(mPid, mType); }
+
+void UntrustedModulesBackupData::Add(UntrustedModulesData&& aData) {
+  WithEntryHandle(
+      ProcessHashKey(aData.mProcessType, aData.mPid), [&](auto&& p) {
+        if (p) {
+          p.Data()->mData.Merge(std::move(aData));
+        } else {
+          p.Insert(MakeRefPtr<UntrustedModulesDataContainer>(std::move(aData)));
+        }
+      });
+}
+
+void UntrustedModulesBackupData::AddWithoutStacks(
+    UntrustedModulesData&& aData) {
+  WithEntryHandle(
+      ProcessHashKey(aData.mProcessType, aData.mPid), [&](auto&& p) {
+        if (p) {
+          p.Data()->mData.MergeWithoutStacks(std::move(aData));
+        } else {
+          aData.Truncate(true);
+          p.Insert(MakeRefPtr<UntrustedModulesDataContainer>(std::move(aData)));
+        }
+      });
+}
+
+/* static */
+UntrustedModulesBackupService* UntrustedModulesBackupService::Get() {
+  if (!XRE_IsParentProcess()) {
+    return nullptr;
+  }
+
+  static StaticLocalRefPtr<UntrustedModulesBackupService> sInstance(
+      []() -> already_AddRefed<UntrustedModulesBackupService> {
+        RefPtr<UntrustedModulesBackupService> instance(
+            new UntrustedModulesBackupService());
+
+        auto setClearOnShutdown = [ptr = &sInstance]() -> void {
+          ClearOnShutdown(ptr);
+        };
+
+        if (NS_IsMainThread()) {
+          setClearOnShutdown();
+          return instance.forget();
+        }
+
+        SchedulerGroup::Dispatch(NS_NewRunnableFunction(
+            "mozilla::UntrustedModulesBackupService::Get",
+            std::move(setClearOnShutdown)));
+
+        return instance.forget();
+      }());
+
+  return sInstance;
+}
+
+void UntrustedModulesBackupService::Backup(UntrustedModulesData&& aData) {
+  mStaging.Add(std::move(aData));
+}
+
+void UntrustedModulesBackupService::SettleAllStagingData() {
+  UntrustedModulesBackupData staging;
+  staging.SwapElements(mStaging);
+
+  for (auto&& iter = staging.Iter(); !iter.Done(); iter.Next()) {
+    if (!iter.Data()) {
+      continue;
+    }
+    mSettled.AddWithoutStacks(std::move(iter.Data()->mData));
+  }
+}
+
+}  // namespace mozilla
diff --git a/toolkit/components/telemetry/other/UntrustedModulesBackupService.h b/toolkit/components/telemetry/other/UntrustedModulesBackupService.h
new file mode 100644
index 0000000000..36e4cc7b1c
--- /dev/null
+++ b/toolkit/components/telemetry/other/UntrustedModulesBackupService.h
@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_UntrustedModulesBackupService_h
+#define mozilla_UntrustedModulesBackupService_h
+
+#include "mozilla/UntrustedModulesData.h"
+#include "nsRefPtrHashtable.h"
+
+namespace mozilla {
+
+struct ProcessHashKey {
+  GeckoProcessType mType;
+  DWORD mPid;
+  ProcessHashKey(GeckoProcessType aType, DWORD aPid);
+  bool operator==(const ProcessHashKey& aOther) const;
+  PLDHashNumber Hash() const;
+};
+
+// UntrustedModulesData should not be refcounted as it's exchanged via IPC.
+// Instead, we define this container class owning UntrustedModulesData along
+// with a refcount.
+class MOZ_HEAP_CLASS UntrustedModulesDataContainer final {
+  ~UntrustedModulesDataContainer() = default;
+
+ public:
+  UntrustedModulesData mData;
+
+  explicit UntrustedModulesDataContainer(UntrustedModulesData&& aData)
+      : mData(std::move(aData)) {}
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(UntrustedModulesDataContainer)
+};
+
+class UntrustedModulesBackupData
+    : public nsRefPtrHashtable<nsGenericHashKey<ProcessHashKey>,
+                               UntrustedModulesDataContainer> {
+ public:
+  void Add(UntrustedModulesData&& aData);
+  void AddWithoutStacks(UntrustedModulesData&& aData);
+};
+
+class MOZ_HEAP_CLASS UntrustedModulesBackupService final {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(UntrustedModulesBackupService)
+
+  static UntrustedModulesBackupService* Get();
+
+  // Back up data to mStaging
+  void Backup(UntrustedModulesData&& aData);
+
+  void SettleAllStagingData();
+
+  const UntrustedModulesBackupData& Staging() const { return mStaging; }
+  const UntrustedModulesBackupData& Settled() const { return mSettled; }
+
+ private:
+  // Data not yet submitted as telemetry
+  UntrustedModulesBackupData mStaging;
+
+  // Data already submitted as telemetry
+  // (This does not have stack information)
+  UntrustedModulesBackupData mSettled;
+
+  ~UntrustedModulesBackupService() = default;
+};
+
+}  // namespace mozilla
+
+#endif  // mozilla_UntrustedModulesBackupService_h
diff --git a/toolkit/components/telemetry/other/UntrustedModulesDataSerializer.cpp b/toolkit/components/telemetry/other/UntrustedModulesDataSerializer.cpp
new file mode 100644
index 0000000000..f352485e2b
--- /dev/null
+++ b/toolkit/components/telemetry/other/UntrustedModulesDataSerializer.cpp
@@ -0,0 +1,606 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 "UntrustedModulesDataSerializer.h"
+
+#include "core/TelemetryCommon.h"
+#include "js/Array.h"               // JS::NewArrayObject
+#include "js/PropertyAndElement.h"  // JS_DefineElement, JS_DefineProperty, JS_GetProperty
+#include "jsapi.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "nsITelemetry.h"
+#include "nsUnicharUtils.h"
+#include "nsXULAppAPI.h"
+#include "shared-libraries.h"
+
+namespace mozilla {
+namespace Telemetry {
+
+static const uint32_t kThirdPartyModulesPingVersion = 1;
+
+/**
+ * Limits the length of a string by removing the middle of the string, replacing
+ * with ellipsis.
+ * e.g. LimitStringLength("hello world", 6) would result in "he...d"
+ *
+ * @param  aStr            [in,out] The string to transform
+ * @param  aMaxFieldLength [in] The maximum length of the resulting string.
+ */
+static void LimitStringLength(nsAString& aStr, size_t aMaxFieldLength) {
+  if (aStr.Length() <= aMaxFieldLength) {
+    return;
+  }
+
+  constexpr auto kEllipsis = u"..."_ns;
+
+  if (aMaxFieldLength <= (kEllipsis.Length() + 3)) {
+    // An ellipsis is useless in this case, as it would obscure the string to
+    // the point that we cannot even determine the string's contents. We might
+    // as well just truncate.
+    aStr.Truncate(aMaxFieldLength);
+    return;
+  }
+
+  size_t cutPos = (aMaxFieldLength - kEllipsis.Length()) / 2;
+  size_t rightLen = aMaxFieldLength - kEllipsis.Length() - cutPos;
+  size_t cutLen = aStr.Length() - (cutPos + rightLen);
+
+  aStr.Replace(cutPos, cutLen, kEllipsis);
+}
+
+/**
+ * Adds a string property to a JS object, that's limited in length using
+ * LimitStringLength().
+ *
+ * @param  cx              [in] The JS context
+ * @param  aObj            [in] The object to add the property to
+ * @param  aName           [in] The name of the property to add
+ * @param  aVal            [in] The JS value of the resulting property.
+ * @param  aMaxFieldLength [in] The maximum length of the value
+ *                         (see LimitStringLength())
+ * @return true upon success
+ */
+static bool AddLengthLimitedStringProp(JSContext* cx,
+                                       JS::Handle<JSObject*> aObj,
+                                       const char* aName, const nsAString& aVal,
+                                       size_t aMaxFieldLength = MAX_PATH) {
+  JS::Rooted<JS::Value> jsval(cx);
+  nsAutoString shortVal(aVal);
+  LimitStringLength(shortVal, aMaxFieldLength);
+  jsval.setString(Common::ToJSString(cx, shortVal));
+  return JS_DefineProperty(cx, aObj, aName, jsval, JSPROP_ENUMERATE);
+};
+
+static JSString* ModuleVersionToJSString(JSContext* aCx,
+                                         const ModuleVersion& aVersion) {
+  auto [major, minor, patch, build] = aVersion.AsTuple();
+
+  constexpr auto dot = u"."_ns;
+
+  nsAutoString strVer;
+  strVer.AppendInt(major);
+  strVer.Append(dot);
+  strVer.AppendInt(minor);
+  strVer.Append(dot);
+  strVer.AppendInt(patch);
+  strVer.Append(dot);
+  strVer.AppendInt(build);
+
+  return Common::ToJSString(aCx, strVer);
+}
+
+/**
+ * Convert the given container object to a JavaScript array.
+ *
+ * @param  cx                [in] The JS context.
+ * @param  aRet              [out] This gets assigned to the newly created
+ *                           array object.
+ * @param  aContainer        [in] The source container to convert.
+ * @param  aElementConverter [in] A callable used to convert each element
+ *                           to a JS element. The form of this function is:
+ *                           bool(JSContext *cx,
+ *                                JS::MutableHandleValue aRet,
+ *                                const ElementT& aElement)
+ * @return true if aRet was successfully assigned to the new array object.
+ */
+template <typename T, typename Converter, typename... Args>
+static bool ContainerToJSArray(JSContext* cx, JS::MutableHandle<JSObject*> aRet,
+                               const T& aContainer,
+                               Converter&& aElementConverter, Args&&... aArgs) {
+  JS::Rooted<JSObject*> arr(cx, JS::NewArrayObject(cx, 0));
+  if (!arr) {
+    return false;
+  }
+
+  size_t i = 0;
+  for (auto&& item : aContainer) {
+    JS::Rooted<JS::Value> jsel(cx);
+    if (!aElementConverter(cx, &jsel, *item, std::forward<Args>(aArgs)...)) {
+      return false;
+    }
+    if (!JS_DefineElement(cx, arr, i, jsel, JSPROP_ENUMERATE)) {
+      return false;
+    }
+    ++i;
+  }
+
+  aRet.set(arr);
+  return true;
+}
+
+static bool SerializeModule(JSContext* aCx,
+                            JS::MutableHandle<JS::Value> aElement,
+                            const RefPtr<ModuleRecord>& aModule,
+                            uint32_t aFlags) {
+  if (!aModule) {
+    return false;
+  }
+
+  JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
+  if (!obj) {
+    return false;
+  }
+
+  if (aFlags & nsITelemetry::INCLUDE_PRIVATE_FIELDS_IN_LOADEVENTS) {
+    JS::Rooted<JS::Value> jsFileObj(aCx);
+    if (!dom::ToJSValue(aCx, aModule->mResolvedDosName, &jsFileObj) ||
+        !JS_DefineProperty(aCx, obj, "dllFile", jsFileObj, JSPROP_ENUMERATE)) {
+      return false;
+    }
+  } else {
+    if (!AddLengthLimitedStringProp(aCx, obj, "resolvedDllName",
+                                    aModule->mSanitizedDllName)) {
+      return false;
+    }
+  }
+
+  if (aModule->mVersion.isSome()) {
+    JS::Rooted<JS::Value> jsModuleVersion(aCx);
+    jsModuleVersion.setString(
+        ModuleVersionToJSString(aCx, aModule->mVersion.ref()));
+    if (!JS_DefineProperty(aCx, obj, "fileVersion", jsModuleVersion,
+                           JSPROP_ENUMERATE)) {
+      return false;
+    }
+  }
+
+#if defined(MOZ_GECKO_PROFILER)
+  if (aModule->mResolvedDosName) {
+    nsAutoString path;
+    if (aModule->mResolvedDosName->GetPath(path) == NS_OK) {
+      SharedLibraryInfo info = SharedLibraryInfo::GetInfoFromPath(path.Data());
+      if (info.GetSize() > 0) {
+        nsCString breakpadId = info.GetEntry(0).GetBreakpadId();
+        if (!AddLengthLimitedStringProp(aCx, obj, "debugID",
+                                        NS_ConvertASCIItoUTF16(breakpadId))) {
+          return false;
+        }
+      }
+    }
+  }
+#endif  // MOZ_GECKO_PROFILER
+
+  if (aModule->mVendorInfo.isSome()) {
+    const char* propName;
+
+    const VendorInfo& vendorInfo = aModule->mVendorInfo.ref();
+    switch (vendorInfo.mSource) {
+      case VendorInfo::Source::Signature:
+        propName = "signedBy";
+        break;
+      case VendorInfo::Source::VersionInfo:
+        propName = "companyName";
+        break;
+      default:
+        MOZ_ASSERT_UNREACHABLE("Unknown VendorInfo Source!");
+        return false;
+    }
+
+    MOZ_ASSERT(!vendorInfo.mVendor.IsEmpty());
+    if (vendorInfo.mVendor.IsEmpty()) {
+      return false;
+    }
+
+    if (!AddLengthLimitedStringProp(aCx, obj, propName, vendorInfo.mVendor)) {
+      return false;
+    }
+  }
+
+  JS::Rooted<JS::Value> jsTrustFlags(aCx);
+  jsTrustFlags.setNumber(static_cast<uint32_t>(aModule->mTrustFlags));
+  if (!JS_DefineProperty(aCx, obj, "trustFlags", jsTrustFlags,
+                         JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  aElement.setObject(*obj);
+  return true;
+}
+
+/* static */
+bool UntrustedModulesDataSerializer::SerializeEvent(
+    JSContext* aCx, JS::MutableHandle<JS::Value> aElement,
+    const ProcessedModuleLoadEventContainer& aEventContainer,
+    const IndexMap& aModuleIndices) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  const ProcessedModuleLoadEvent& event = aEventContainer.mEvent;
+  if (!event) {
+    return false;
+  }
+
+  JS::Rooted<JSObject*> obj(aCx, JS_NewPlainObject(aCx));
+  if (!obj) {
+    return false;
+  }
+
+  JS::Rooted<JS::Value> jsProcessUptimeMS(aCx);
+  // Javascript doesn't like 64-bit integers; convert to double.
+  jsProcessUptimeMS.setNumber(static_cast<double>(event.mProcessUptimeMS));
+  if (!JS_DefineProperty(aCx, obj, "processUptimeMS", jsProcessUptimeMS,
+                         JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  if (event.mLoadDurationMS) {
+    JS::Rooted<JS::Value> jsLoadDurationMS(aCx);
+    jsLoadDurationMS.setNumber(event.mLoadDurationMS.value());
+    if (!JS_DefineProperty(aCx, obj, "loadDurationMS", jsLoadDurationMS,
+                           JSPROP_ENUMERATE)) {
+      return false;
+    }
+  }
+
+  JS::Rooted<JS::Value> jsThreadId(aCx);
+  jsThreadId.setNumber(static_cast<uint32_t>(event.mThreadId));
+  if (!JS_DefineProperty(aCx, obj, "threadID", jsThreadId, JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  nsDependentCString effectiveThreadName;
+  if (event.mThreadId == ::GetCurrentThreadId()) {
+    effectiveThreadName.Rebind("Main Thread"_ns, 0);
+  } else {
+    effectiveThreadName.Rebind(event.mThreadName, 0);
+  }
+
+  if (!effectiveThreadName.IsEmpty()) {
+    JS::Rooted<JS::Value> jsThreadName(aCx);
+    jsThreadName.setString(Common::ToJSString(aCx, effectiveThreadName));
+    if (!JS_DefineProperty(aCx, obj, "threadName", jsThreadName,
+                           JSPROP_ENUMERATE)) {
+      return false;
+    }
+  }
+
+  // Don't add this property unless mRequestedDllName differs from
+  // the associated module's mSanitizedDllName
+  if (!event.mRequestedDllName.IsEmpty() &&
+      !event.mRequestedDllName.Equals(event.mModule->mSanitizedDllName,
+                                      nsCaseInsensitiveStringComparator)) {
+    if (!AddLengthLimitedStringProp(aCx, obj, "requestedDllName",
+                                    event.mRequestedDllName)) {
+      return false;
+    }
+  }
+
+  nsAutoString strBaseAddress;
+  strBaseAddress.AppendLiteral(u"0x");
+  strBaseAddress.AppendInt(event.mBaseAddress, 16);
+
+  JS::Rooted<JS::Value> jsBaseAddress(aCx);
+  jsBaseAddress.setString(Common::ToJSString(aCx, strBaseAddress));
+  if (!JS_DefineProperty(aCx, obj, "baseAddress", jsBaseAddress,
+                         JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  uint32_t index;
+  if (!aModuleIndices.Get(event.mModule->mResolvedNtName, &index)) {
+    return false;
+  }
+
+  JS::Rooted<JS::Value> jsModuleIndex(aCx);
+  jsModuleIndex.setNumber(index);
+  if (!JS_DefineProperty(aCx, obj, "moduleIndex", jsModuleIndex,
+                         JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  JS::Rooted<JS::Value> jsIsDependent(aCx);
+  jsIsDependent.setBoolean(event.mIsDependent);
+  if (!JS_DefineProperty(aCx, obj, "isDependent", jsIsDependent,
+                         JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  JS::Rooted<JS::Value> jsLoadStatus(aCx);
+  jsLoadStatus.setNumber(event.mLoadStatus);
+  if (!JS_DefineProperty(aCx, obj, "loadStatus", jsLoadStatus,
+                         JSPROP_ENUMERATE)) {
+    return false;
+  }
+
+  aElement.setObject(*obj);
+
+  return true;
+}
+
+static nsDependentCString GetProcessTypeString(GeckoProcessType aType) {
+  nsDependentCString strProcType;
+  if (aType == GeckoProcessType_Default) {
+    strProcType.Rebind("browser"_ns, 0);
+  } else {
+    strProcType.Rebind(XRE_GeckoProcessTypeToString(aType));
+  }
+  return strProcType;
+}
+
+nsresult UntrustedModulesDataSerializer::GetPerProcObject(
+    const UntrustedModulesData& aData, JS::MutableHandle<JSObject*> aObj) {
+  JS::Rooted<JS::Value> jsProcType(mCx);
+  jsProcType.setString(
+      Common::ToJSString(mCx, GetProcessTypeString(aData.mProcessType)));
+  if (!JS_DefineProperty(mCx, aObj, "processType", jsProcType,
+                         JSPROP_ENUMERATE)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  JS::Rooted<JS::Value> jsElapsed(mCx);
+  jsElapsed.setNumber(aData.mElapsed.ToSecondsSigDigits());
+  if (!JS_DefineProperty(mCx, aObj, "elapsed", jsElapsed, JSPROP_ENUMERATE)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (aData.mXULLoadDurationMS.isSome()) {
+    JS::Rooted<JS::Value> jsXulLoadDurationMS(mCx);
+    jsXulLoadDurationMS.setNumber(aData.mXULLoadDurationMS.value());
+    if (!JS_DefineProperty(mCx, aObj, "xulLoadDurationMS", jsXulLoadDurationMS,
+                           JSPROP_ENUMERATE)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  JS::Rooted<JS::Value> jsSanitizationFailures(mCx);
+  jsSanitizationFailures.setNumber(aData.mSanitizationFailures);
+  if (!JS_DefineProperty(mCx, aObj, "sanitizationFailures",
+                         jsSanitizationFailures, JSPROP_ENUMERATE)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  JS::Rooted<JS::Value> jsTrustTestFailures(mCx);
+  jsTrustTestFailures.setNumber(aData.mTrustTestFailures);
+  if (!JS_DefineProperty(mCx, aObj, "trustTestFailures", jsTrustTestFailures,
+                         JSPROP_ENUMERATE)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  JS::Rooted<JSObject*> eventsArray(mCx);
+  if (!ContainerToJSArray(mCx, &eventsArray, aData.mEvents, &SerializeEvent,
+                          mIndexMap)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!JS_DefineProperty(mCx, aObj, "events", eventsArray, JSPROP_ENUMERATE)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!(mFlags & nsITelemetry::EXCLUDE_STACKINFO_FROM_LOADEVENTS)) {
+    JS::Rooted<JSObject*> combinedStacksObj(
+        mCx, CreateJSStackObject(mCx, aData.mStacks));
+    if (!combinedStacksObj) {
+      return NS_ERROR_FAILURE;
+    }
+
+    if (!JS_DefineProperty(mCx, aObj, "combinedStacks", combinedStacksObj,
+                           JSPROP_ENUMERATE)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult UntrustedModulesDataSerializer::AddLoadEvents(
+    const UntrustedModuleLoadingEvents& aEvents,
+    JS::MutableHandle<JSObject*> aPerProcObj) {
+  JS::Rooted<JS::Value> eventsArrayVal(mCx);
+  if (!JS_GetProperty(mCx, aPerProcObj, "events", &eventsArrayVal) ||
+      !eventsArrayVal.isObject()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  JS::Rooted<JSObject*> eventsArray(mCx, &eventsArrayVal.toObject());
+  bool isArray;
+  if (!JS::IsArrayObject(mCx, eventsArray, &isArray) && !isArray) {
+    return NS_ERROR_FAILURE;
+  }
+
+  uint32_t currentPos;
+  if (!GetArrayLength(mCx, eventsArray, &currentPos)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  for (auto item : aEvents) {
+    JS::Rooted<JS::Value> jsel(mCx);
+    if (!SerializeEvent(mCx, &jsel, *item, mIndexMap) ||
+        !JS_DefineElement(mCx, eventsArray, currentPos++, jsel,
+                          JSPROP_ENUMERATE)) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult UntrustedModulesDataSerializer::AddSingleData(
+    const UntrustedModulesData& aData) {
+  // Serialize each entry in the modules hashtable out to the "modules" array
+  // and store the indices in |mIndexMap|
+  for (const auto& entry : aData.mModules) {
+    if (!mIndexMap.WithEntryHandle(entry.GetKey(), [&](auto&& addPtr) {
+          if (!addPtr) {
+            addPtr.Insert(mCurModulesArrayIdx);
+
+            JS::Rooted<JS::Value> jsModule(mCx);
+            if (!SerializeModule(mCx, &jsModule, entry.GetData(), mFlags) ||
+                !JS_DefineElement(mCx, mModulesArray, mCurModulesArrayIdx,
+                                  jsModule, JSPROP_ENUMERATE)) {
+              return false;
+            }
+
+            ++mCurModulesArrayIdx;
+          }
+          return true;
+        })) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  if (mCurModulesArrayIdx >= mMaxModulesArrayLen) {
+    return NS_ERROR_CANNOT_CONVERT_DATA;
+  }
+
+  nsAutoCString strPid;
+  strPid.Append(GetProcessTypeString(aData.mProcessType));
+  strPid.AppendLiteral(".0x");
+  strPid.AppendInt(static_cast<uint32_t>(aData.mPid), 16);
+
+  if (mFlags & nsITelemetry::EXCLUDE_STACKINFO_FROM_LOADEVENTS) {
+    JS::Rooted<JS::Value> perProcVal(mCx);
+    if (JS_GetProperty(mCx, mPerProcObjContainer, strPid.get(), &perProcVal) &&
+        perProcVal.isObject()) {
+      // If a corresponding per-proc object already exists in the dictionary,
+      // and we skip to serialize CombinedStacks, we can add loading events
+      // into the JS object directly.
+      JS::Rooted<JSObject*> perProcObj(mCx, &perProcVal.toObject());
+      return AddLoadEvents(aData.mEvents, &perProcObj);
+    }
+  }
+
+  JS::Rooted<JSObject*> perProcObj(mCx, JS_NewPlainObject(mCx));
+  if (!perProcObj) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv = GetPerProcObject(aData, &perProcObj);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  JS::Rooted<JS::Value> jsPerProcObjValue(mCx);
+  jsPerProcObjValue.setObject(*perProcObj);
+  if (!JS_DefineProperty(mCx, mPerProcObjContainer, strPid.get(),
+                         jsPerProcObjValue, JSPROP_ENUMERATE)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+UntrustedModulesDataSerializer::UntrustedModulesDataSerializer(
+    JSContext* aCx, uint32_t aMaxModulesArrayLen, uint32_t aFlags)
+    : mCtorResult(NS_ERROR_FAILURE),
+      mCx(aCx),
+      mMainObj(mCx, JS_NewPlainObject(mCx)),
+      mModulesArray(mCx, JS::NewArrayObject(mCx, 0)),
+      mBlockedModulesArray(mCx, JS::NewArrayObject(mCx, 0)),
+      mPerProcObjContainer(mCx, JS_NewPlainObject(mCx)),
+      mMaxModulesArrayLen(aMaxModulesArrayLen),
+      mCurModulesArrayIdx(0),
+      mCurBlockedModulesArrayIdx(0),
+      mFlags(aFlags) {
+  if (!mMainObj || !mModulesArray || !mBlockedModulesArray ||
+      !mPerProcObjContainer) {
+    return;
+  }
+
+  JS::Rooted<JS::Value> jsVersion(mCx);
+  jsVersion.setNumber(kThirdPartyModulesPingVersion);
+  if (!JS_DefineProperty(mCx, mMainObj, "structVersion", jsVersion,
+                         JSPROP_ENUMERATE)) {
+    return;
+  }
+
+  JS::Rooted<JS::Value> jsModulesArrayValue(mCx);
+  jsModulesArrayValue.setObject(*mModulesArray);
+  if (!JS_DefineProperty(mCx, mMainObj, "modules", jsModulesArrayValue,
+                         JSPROP_ENUMERATE)) {
+    return;
+  }
+
+  JS::Rooted<JS::Value> jsBlockedModulesArrayValue(mCx);
+  jsBlockedModulesArrayValue.setObject(*mBlockedModulesArray);
+  if (!JS_DefineProperty(mCx, mMainObj, "blockedModules",
+                         jsBlockedModulesArrayValue, JSPROP_ENUMERATE)) {
+    return;
+  }
+
+  JS::Rooted<JS::Value> jsPerProcObjContainerValue(mCx);
+  jsPerProcObjContainerValue.setObject(*mPerProcObjContainer);
+  if (!JS_DefineProperty(mCx, mMainObj, "processes", jsPerProcObjContainerValue,
+                         JSPROP_ENUMERATE)) {
+    return;
+  }
+
+  mCtorResult = NS_OK;
+}
+
+UntrustedModulesDataSerializer::operator bool() const {
+  return NS_SUCCEEDED(mCtorResult);
+}
+
+void UntrustedModulesDataSerializer::GetObject(
+    JS::MutableHandle<JS::Value> aRet) {
+  aRet.setObject(*mMainObj);
+}
+
+nsresult UntrustedModulesDataSerializer::Add(
+    const UntrustedModulesBackupData& aData) {
+  if (NS_FAILED(mCtorResult)) {
+    return mCtorResult;
+  }
+
+  for (const RefPtr<UntrustedModulesDataContainer>& container :
+       aData.Values()) {
+    if (!container) {
+      continue;
+    }
+
+    nsresult rv = AddSingleData(container->mData);
+    if (NS_FAILED(rv)) {
+      return rv;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult UntrustedModulesDataSerializer::AddBlockedModules(
+    const nsTArray<nsDependentSubstring>& blockedModules) {
+  if (NS_FAILED(mCtorResult)) {
+    return mCtorResult;
+  }
+
+  if (blockedModules.Length() >= mMaxModulesArrayLen) {
+    return NS_ERROR_CANNOT_CONVERT_DATA;
+  }
+
+  for (const auto& blockedModule : blockedModules) {
+    JS::Rooted<JS::Value> jsBlockedModule(mCx);
+    jsBlockedModule.setString(Common::ToJSString(mCx, blockedModule));
+    if (!JS_DefineElement(mCx, mBlockedModulesArray, mCurBlockedModulesArrayIdx,
+                          jsBlockedModule, JSPROP_ENUMERATE)) {
+      return NS_ERROR_FAILURE;
+    }
+    ++mCurBlockedModulesArrayIdx;
+  }
+
+  return NS_OK;
+}
+
+}  // namespace Telemetry
+}  // namespace mozilla
diff --git a/toolkit/components/telemetry/other/UntrustedModulesDataSerializer.h b/toolkit/components/telemetry/other/UntrustedModulesDataSerializer.h
new file mode 100644
index 0000000000..cb0bce18ee
--- /dev/null
+++ b/toolkit/components/telemetry/other/UntrustedModulesDataSerializer.h
@@ -0,0 +1,84 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 UntrustedModulesDataSerializer_h__
+#define UntrustedModulesDataSerializer_h__
+
+#include "js/TypeDecls.h"
+#include "mozilla/UntrustedModulesData.h"
+#include "mozilla/Vector.h"
+#include "nsTHashMap.h"
+#include "UntrustedModulesBackupService.h"
+
+namespace mozilla {
+namespace Telemetry {
+
+// This class owns a JS object and serializes a given UntrustedModulesData
+// into it.  Because this class uses JSAPI, an AutoJSAPI instance must be
+// on the stack before instantiating the class.
+class MOZ_RAII UntrustedModulesDataSerializer final {
+  using IndexMap = nsTHashMap<nsStringHashKey, uint32_t>;
+
+  nsresult mCtorResult;
+  JSContext* mCx;
+  JS::Rooted<JSObject*> mMainObj;
+  JS::Rooted<JSObject*> mModulesArray;
+  JS::Rooted<JSObject*> mBlockedModulesArray;
+  JS::Rooted<JSObject*> mPerProcObjContainer;
+
+  IndexMap mIndexMap;
+  const uint32_t mMaxModulesArrayLen;
+  uint32_t mCurModulesArrayIdx;
+  uint32_t mCurBlockedModulesArrayIdx;
+
+  // Combinations of the flags defined under nsITelemetry.
+  // (See "Flags for getUntrustedModuleLoadEvents" in nsITelemetry.idl)
+  const uint32_t mFlags;
+
+  static bool SerializeEvent(
+      JSContext* aCx, JS::MutableHandle<JS::Value> aElement,
+      const ProcessedModuleLoadEventContainer& aEventContainer,
+      const IndexMap& aModuleIndices);
+  nsresult GetPerProcObject(const UntrustedModulesData& aData,
+                            JS::MutableHandle<JSObject*> aObj);
+  nsresult AddLoadEvents(const UntrustedModuleLoadingEvents& aEvents,
+                         JS::MutableHandle<JSObject*> aPerProcObj);
+  nsresult AddSingleData(const UntrustedModulesData& aData);
+
+ public:
+  UntrustedModulesDataSerializer(JSContext* aCx, uint32_t aMaxModulesArrayLen,
+                                 uint32_t aFlags = 0);
+  explicit operator bool() const;
+
+  /**
+   * Retrieves the JS object.
+   *
+   * @param  aRet  [out] This gets assigned to the newly created object.
+   */
+  void GetObject(JS::MutableHandle<JS::Value> aRet);
+
+  /**
+   * Adds data to the JS object.
+   *
+   * When the process of a given UntrustedModulesData collides with a key in
+   * the JS object, the entire UntrustedModulesData instance in the JS object
+   * will be replaced unless EXCLUDE_STACKINFO_FROM_LOADEVENTS is set.
+   * When EXCLUDE_STACKINFO_FROM_LOADEVENTS is set, the given loading events
+   * are appended into the JS object, keeping the existing data as is.
+   *
+   * @param  aData [in] The source objects to add.
+   * @return nsresult
+   */
+  nsresult Add(const UntrustedModulesBackupData& aData);
+
+  nsresult AddBlockedModules(
+      const nsTArray<nsDependentSubstring>& blockedModules);
+};
+
+}  // namespace Telemetry
+}  // namespace mozilla
+
+#endif  // UntrustedModulesDataSerializer_h__