Add m-esr52 at 52.6.0

1 files changed, 1620 insertions, 0 deletions

diff --git a/toolkit/components/perfmonitoring/nsPerformanceStats.cpp b/toolkit/components/perfmonitoring/nsPerformanceStats.cpp
new file mode 100644
index 000000000..eb924de46
--- /dev/null
+++ b/toolkit/components/perfmonitoring/nsPerformanceStats.cpp
@@ -0,0 +1,1620 @@
+/* -*- 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/. */
+
+#include "nsPerformanceStats.h"
+
+#include "nsMemory.h"
+#include "nsLiteralString.h"
+#include "nsCRTGlue.h"
+#include "nsServiceManagerUtils.h"
+
+#include "nsCOMArray.h"
+#include "nsContentUtils.h"
+#include "nsIMutableArray.h"
+#include "nsReadableUtils.h"
+
+#include "jsapi.h"
+#include "nsJSUtils.h"
+#include "xpcpublic.h"
+#include "jspubtd.h"
+
+#include "nsIDOMWindow.h"
+#include "nsGlobalWindow.h"
+#include "nsRefreshDriver.h"
+
+#include "mozilla/Unused.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/EventStateManager.h"
+#include "mozilla/Services.h"
+#include "mozilla/Telemetry.h"
+
+#if defined(XP_WIN)
+#include <processthreadsapi.h>
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif // defined(XP_WIN)
+
+#if defined(XP_MACOSX)
+#include <mach/mach_init.h>
+#include <mach/mach_interface.h>
+#include <mach/mach_port.h>
+#include <mach/mach_types.h>
+#include <mach/message.h>
+#include <mach/thread_info.h>
+#elif defined(XP_UNIX)
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif // defined(XP_UNIX)
+/* ------------------------------------------------------
+ *
+ * Utility functions.
+ *
+ */
+
+namespace {
+
+/**
+ * Get the private window for the current compartment.
+ *
+ * @return null if the code is not executed in a window or in
+ * case of error, a nsPIDOMWindow otherwise.
+ */
+already_AddRefed<nsPIDOMWindowOuter>
+GetPrivateWindow(JSContext* cx) {
+  nsGlobalWindow* win = xpc::CurrentWindowOrNull(cx);
+  if (!win) {
+    return nullptr;
+  }
+
+  nsPIDOMWindowOuter* outer = win->AsInner()->GetOuterWindow();
+  if (!outer) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> top = outer->GetTop();
+  if (!top) {
+    return nullptr;
+  }
+
+  return top.forget();
+}
+
+bool
+URLForGlobal(JSContext* cx, JS::Handle<JSObject*> global, nsAString& url) {
+  nsCOMPtr<nsIPrincipal> principal = nsContentUtils::ObjectPrincipal(global);
+  if (!principal) {
+    return false;
+  }
+
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = principal->GetURI(getter_AddRefs(uri));
+  if (NS_FAILED(rv) || !uri) {
+    return false;
+  }
+
+  nsAutoCString spec;
+  rv = uri->GetSpec(spec);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  url.Assign(NS_ConvertUTF8toUTF16(spec));
+  return true;
+}
+
+/**
+ * Extract a somewhat human-readable name from the current context.
+ */
+void
+CompartmentName(JSContext* cx, JS::Handle<JSObject*> global, nsAString& name) {
+  // Attempt to use the URL as name.
+  if (URLForGlobal(cx, global, name)) {
+    return;
+  }
+
+  // Otherwise, fallback to XPConnect's less readable but more
+  // complete naming scheme.
+  nsAutoCString cname;
+  xpc::GetCurrentCompartmentName(cx, cname);
+  name.Assign(NS_ConvertUTF8toUTF16(cname));
+}
+
+/**
+ * Generate a unique-to-the-application identifier for a group.
+ */
+void
+GenerateUniqueGroupId(const JSContext* cx, uint64_t uid, uint64_t processId, nsAString& groupId) {
+  uint64_t contextId = reinterpret_cast<uintptr_t>(cx);
+
+  groupId.AssignLiteral("process: ");
+  groupId.AppendInt(processId);
+  groupId.AppendLiteral(", thread: ");
+  groupId.AppendInt(contextId);
+  groupId.AppendLiteral(", group: ");
+  groupId.AppendInt(uid);
+}
+
+static const char* TOPICS[] = {
+  "profile-before-change",
+  "quit-application",
+  "quit-application-granted",
+  "xpcom-will-shutdown"
+};
+
+} // namespace
+
+/* ------------------------------------------------------
+ *
+ * class nsPerformanceObservationTarget
+ *
+ */
+
+
+NS_IMPL_ISUPPORTS(nsPerformanceObservationTarget, nsIPerformanceObservable)
+
+
+
+NS_IMETHODIMP
+nsPerformanceObservationTarget::GetTarget(nsIPerformanceGroupDetails** _result) {
+  if (mDetails) {
+    NS_IF_ADDREF(*_result = mDetails);
+  }
+  return NS_OK;
+};
+
+void
+nsPerformanceObservationTarget::SetTarget(nsPerformanceGroupDetails* details) {
+  MOZ_ASSERT(!mDetails);
+  mDetails = details;
+};
+
+NS_IMETHODIMP
+nsPerformanceObservationTarget::AddJankObserver(nsIPerformanceObserver* observer) {
+  if (!mObservers.append(observer)) {
+    MOZ_CRASH();
+  }
+  return NS_OK;
+};
+
+NS_IMETHODIMP
+nsPerformanceObservationTarget::RemoveJankObserver(nsIPerformanceObserver* observer) {
+  for (auto iter = mObservers.begin(), end = mObservers.end(); iter < end; ++iter) {
+    if (*iter == observer) {
+      mObservers.erase(iter);
+      return NS_OK;
+    }
+  }
+  return NS_OK;
+};
+
+bool
+nsPerformanceObservationTarget::HasObservers() const {
+  return !mObservers.empty();
+}
+
+void
+nsPerformanceObservationTarget::NotifyJankObservers(nsIPerformanceGroupDetails* source, nsIPerformanceAlert* gravity) {
+  // Copy the vector to make sure that it won't change under our feet.
+  mozilla::Vector<nsCOMPtr<nsIPerformanceObserver>> observers;
+  if (!observers.appendAll(mObservers)) {
+    MOZ_CRASH();
+  }
+
+  // Now actually notify.
+  for (auto iter = observers.begin(), end = observers.end(); iter < end; ++iter) {
+    nsCOMPtr<nsIPerformanceObserver> observer = *iter;
+    mozilla::Unused << observer->Observe(source, gravity);
+  }
+}
+
+/* ------------------------------------------------------
+ *
+ * class nsGroupHolder
+ *
+ */
+
+nsPerformanceObservationTarget*
+nsGroupHolder::ObservationTarget() {
+  if (!mPendingObservationTarget) {
+    mPendingObservationTarget = new nsPerformanceObservationTarget();
+  }
+  return mPendingObservationTarget;
+}
+
+nsPerformanceGroup*
+nsGroupHolder::GetGroup() {
+  return mGroup;
+}
+
+void
+nsGroupHolder::SetGroup(nsPerformanceGroup* group) {
+  MOZ_ASSERT(!mGroup);
+  mGroup = group;
+  group->SetObservationTarget(ObservationTarget());
+  mPendingObservationTarget->SetTarget(group->Details());
+}
+
+/* ------------------------------------------------------
+ *
+ * struct PerformanceData
+ *
+ */
+
+PerformanceData::PerformanceData()
+  : mTotalUserTime(0)
+  , mTotalSystemTime(0)
+  , mTotalCPOWTime(0)
+  , mTicks(0)
+{
+  mozilla::PodArrayZero(mDurations);
+}
+
+/* ------------------------------------------------------
+ *
+ * class nsPerformanceGroupDetails
+ *
+ */
+
+NS_IMPL_ISUPPORTS(nsPerformanceGroupDetails, nsIPerformanceGroupDetails)
+
+const nsAString&
+nsPerformanceGroupDetails::Name() const {
+  return mName;
+}
+
+const nsAString&
+nsPerformanceGroupDetails::GroupId() const {
+  return mGroupId;
+}
+
+const nsAString&
+nsPerformanceGroupDetails::AddonId() const {
+  return mAddonId;
+}
+
+uint64_t
+nsPerformanceGroupDetails::WindowId() const {
+  return mWindowId;
+}
+
+uint64_t
+nsPerformanceGroupDetails::ProcessId() const {
+  return mProcessId;
+}
+
+bool
+nsPerformanceGroupDetails::IsSystem() const {
+  return mIsSystem;
+}
+
+bool
+nsPerformanceGroupDetails::IsAddon() const {
+  return mAddonId.Length() != 0;
+}
+
+bool
+nsPerformanceGroupDetails::IsWindow() const {
+  return mWindowId != 0;
+}
+
+bool
+nsPerformanceGroupDetails::IsContentProcess() const {
+  return XRE_GetProcessType() == GeckoProcessType_Content;
+}
+
+/* readonly attribute AString name; */
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetName(nsAString& aName) {
+  aName.Assign(Name());
+  return NS_OK;
+};
+
+/* readonly attribute AString groupId; */
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetGroupId(nsAString& aGroupId) {
+  aGroupId.Assign(GroupId());
+  return NS_OK;
+};
+
+/* readonly attribute AString addonId; */
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetAddonId(nsAString& aAddonId) {
+  aAddonId.Assign(AddonId());
+  return NS_OK;
+};
+
+/* readonly attribute uint64_t windowId; */
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetWindowId(uint64_t *aWindowId) {
+  *aWindowId = WindowId();
+  return NS_OK;
+}
+
+/* readonly attribute bool isSystem; */
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetIsSystem(bool *_retval) {
+  *_retval = IsSystem();
+  return NS_OK;
+}
+
+/*
+  readonly attribute unsigned long long processId;
+*/
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetProcessId(uint64_t* processId) {
+  *processId = ProcessId();
+  return NS_OK;
+}
+
+/* readonly attribute bool IsContentProcess; */
+NS_IMETHODIMP
+nsPerformanceGroupDetails::GetIsContentProcess(bool *_retval) {
+  *_retval = IsContentProcess();
+  return NS_OK;
+}
+
+
+/* ------------------------------------------------------
+ *
+ * class nsPerformanceStats
+ *
+ */
+
+class nsPerformanceStats final: public nsIPerformanceStats
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPERFORMANCESTATS
+  NS_FORWARD_NSIPERFORMANCEGROUPDETAILS(mDetails->)
+
+  nsPerformanceStats(nsPerformanceGroupDetails* item,
+                     const PerformanceData& aPerformanceData)
+    : mDetails(item)
+    , mPerformanceData(aPerformanceData)
+  {
+  }
+
+
+private:
+  RefPtr<nsPerformanceGroupDetails> mDetails;
+  PerformanceData mPerformanceData;
+
+  ~nsPerformanceStats() {}
+};
+
+NS_IMPL_ISUPPORTS(nsPerformanceStats, nsIPerformanceStats, nsIPerformanceGroupDetails)
+
+/* readonly attribute unsigned long long totalUserTime; */
+NS_IMETHODIMP
+nsPerformanceStats::GetTotalUserTime(uint64_t *aTotalUserTime) {
+  *aTotalUserTime = mPerformanceData.mTotalUserTime;
+  return NS_OK;
+};
+
+/* readonly attribute unsigned long long totalSystemTime; */
+NS_IMETHODIMP
+nsPerformanceStats::GetTotalSystemTime(uint64_t *aTotalSystemTime) {
+  *aTotalSystemTime = mPerformanceData.mTotalSystemTime;
+  return NS_OK;
+};
+
+/* readonly attribute unsigned long long totalCPOWTime; */
+NS_IMETHODIMP
+nsPerformanceStats::GetTotalCPOWTime(uint64_t *aCpowTime) {
+  *aCpowTime = mPerformanceData.mTotalCPOWTime;
+  return NS_OK;
+};
+
+/* readonly attribute unsigned long long ticks; */
+NS_IMETHODIMP
+nsPerformanceStats::GetTicks(uint64_t *aTicks) {
+  *aTicks = mPerformanceData.mTicks;
+  return NS_OK;
+};
+
+/* void getDurations (out unsigned long aCount, [array, size_is (aCount), retval] out unsigned long long aNumberOfOccurrences); */
+NS_IMETHODIMP
+nsPerformanceStats::GetDurations(uint32_t *aCount, uint64_t **aNumberOfOccurrences) {
+  const size_t length = mozilla::ArrayLength(mPerformanceData.mDurations);
+  if (aCount) {
+    *aCount = length;
+  }
+  *aNumberOfOccurrences = new uint64_t[length];
+  for (size_t i = 0; i < length; ++i) {
+    (*aNumberOfOccurrences)[i] = mPerformanceData.mDurations[i];
+  }
+  return NS_OK;
+};
+
+
+/* ------------------------------------------------------
+ *
+ * struct nsPerformanceSnapshot
+ *
+ */
+
+class nsPerformanceSnapshot final : public nsIPerformanceSnapshot
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPERFORMANCESNAPSHOT
+
+  nsPerformanceSnapshot() {}
+
+  /**
+   * Append statistics to the list of components data.
+   */
+  void AppendComponentsStats(nsIPerformanceStats* stats);
+
+  /**
+   * Set the statistics attached to process data.
+   */
+  void SetProcessStats(nsIPerformanceStats* group);
+
+private:
+  ~nsPerformanceSnapshot() {}
+
+private:
+  /**
+   * The data for all components.
+   */
+  nsCOMArray<nsIPerformanceStats> mComponentsData;
+
+  /**
+   * The data for the process.
+   */
+  nsCOMPtr<nsIPerformanceStats> mProcessData;
+};
+
+NS_IMPL_ISUPPORTS(nsPerformanceSnapshot, nsIPerformanceSnapshot)
+
+
+/* nsIArray getComponentsData (); */
+NS_IMETHODIMP
+nsPerformanceSnapshot::GetComponentsData(nsIArray * *aComponents)
+{
+  const size_t length = mComponentsData.Length();
+  nsCOMPtr<nsIMutableArray> components = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  for (size_t i = 0; i < length; ++i) {
+    nsCOMPtr<nsIPerformanceStats> stats = mComponentsData[i];
+    mozilla::DebugOnly<nsresult> rv = components->AppendElement(stats, false);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+  components.forget(aComponents);
+  return NS_OK;
+}
+
+/* nsIPerformanceStats getProcessData (); */
+NS_IMETHODIMP
+nsPerformanceSnapshot::GetProcessData(nsIPerformanceStats * *aProcess)
+{
+  NS_IF_ADDREF(*aProcess = mProcessData);
+  return NS_OK;
+}
+
+void
+nsPerformanceSnapshot::AppendComponentsStats(nsIPerformanceStats* stats)
+{
+  mComponentsData.AppendElement(stats);
+}
+
+void
+nsPerformanceSnapshot::SetProcessStats(nsIPerformanceStats* stats)
+{
+  mProcessData = stats;
+}
+
+
+
+/* ------------------------------------------------------
+ *
+ * class PerformanceAlert
+ *
+ */
+class PerformanceAlert final: public nsIPerformanceAlert {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPERFORMANCEALERT
+
+  PerformanceAlert(const uint32_t reason, nsPerformanceGroup* source);
+private:
+  ~PerformanceAlert() {}
+
+  const uint32_t mReason;
+
+  // The highest values reached by this group since the latest alert,
+  // in microseconds.
+  const uint64_t mHighestJank;
+  const uint64_t mHighestCPOW;
+};
+
+NS_IMPL_ISUPPORTS(PerformanceAlert, nsIPerformanceAlert);
+
+PerformanceAlert::PerformanceAlert(const uint32_t reason, nsPerformanceGroup* source)
+  : mReason(reason)
+  , mHighestJank(source->HighestRecentJank())
+  , mHighestCPOW(source->HighestRecentCPOW())
+{ }
+
+NS_IMETHODIMP
+PerformanceAlert::GetHighestJank(uint64_t* result) {
+  *result = mHighestJank;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PerformanceAlert::GetHighestCPOW(uint64_t* result) {
+  *result = mHighestCPOW;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PerformanceAlert::GetReason(uint32_t* result) {
+  *result = mReason;
+  return NS_OK;
+}
+/* ------------------------------------------------------
+ *
+ * class PendingAlertsCollector
+ *
+ */
+
+/**
+ * A timer callback in charge of collecting the groups in
+ * `mPendingAlerts` and triggering dispatch of performance alerts.
+ */
+class PendingAlertsCollector final: public nsITimerCallback {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITIMERCALLBACK
+
+  explicit PendingAlertsCollector(nsPerformanceStatsService* service)
+    : mService(service)
+    , mPending(false)
+  { }
+
+  nsresult Start(uint32_t timerDelayMS);
+  nsresult Dispose();
+
+private:
+  ~PendingAlertsCollector() {}
+
+  RefPtr<nsPerformanceStatsService> mService;
+  bool mPending;
+
+  nsCOMPtr<nsITimer> mTimer;
+
+  mozilla::Vector<uint64_t> mJankLevels;
+};
+
+NS_IMPL_ISUPPORTS(PendingAlertsCollector, nsITimerCallback);
+
+NS_IMETHODIMP
+PendingAlertsCollector::Notify(nsITimer*) {
+  mPending = false;
+  mService->NotifyJankObservers(mJankLevels);
+  return NS_OK;
+}
+
+nsresult
+PendingAlertsCollector::Start(uint32_t timerDelayMS) {
+  if (mPending) {
+    // Collector is already started.
+    return NS_OK;
+  }
+
+  if (!mTimer) {
+    mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
+  }
+
+  nsresult rv = mTimer->InitWithCallback(this, timerDelayMS, nsITimer::TYPE_ONE_SHOT);
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  mPending = true;
+  {
+    mozilla::DebugOnly<bool> result = nsRefreshDriver::GetJankLevels(mJankLevels);
+    MOZ_ASSERT(result);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+PendingAlertsCollector::Dispose() {
+  if (mTimer) {
+    mozilla::Unused << mTimer->Cancel();
+    mTimer = nullptr;
+  }
+  mService = nullptr;
+  return NS_OK;
+}
+
+
+
+/* ------------------------------------------------------
+ *
+ * class nsPerformanceStatsService
+ *
+ */
+
+NS_IMPL_ISUPPORTS(nsPerformanceStatsService, nsIPerformanceStatsService, nsIObserver)
+
+nsPerformanceStatsService::nsPerformanceStatsService()
+  : mIsAvailable(false)
+  , mDisposed(false)
+#if defined(XP_WIN)
+  , mProcessId(GetCurrentProcessId())
+#else
+  , mProcessId(getpid())
+#endif
+  , mContext(mozilla::dom::danger::GetJSContext())
+  , mUIdCounter(0)
+  , mTopGroup(nsPerformanceGroup::Make(mContext,
+                                       this,
+                                       NS_LITERAL_STRING("<process>"), // name
+                                       NS_LITERAL_STRING(""),          // addonid
+                                       0,    // windowId
+                                       mProcessId,
+                                       true, // isSystem
+                                       nsPerformanceGroup::GroupScope::RUNTIME // scope
+                                     ))
+  , mIsHandlingUserInput(false)
+  , mProcessStayed(0)
+  , mProcessMoved(0)
+  , mProcessUpdateCounter(0)
+  , mIsMonitoringPerCompartment(false)
+  , mJankAlertThreshold(mozilla::MaxValue<uint64_t>::value) // By default, no alerts
+  , mJankAlertBufferingDelay(1000 /* ms */)
+  , mJankLevelVisibilityThreshold(/* 2 ^ */ 8 /* ms */)
+  , mMaxExpectedDurationOfInteractionUS(150 * 1000)
+{
+  mPendingAlertsCollector = new PendingAlertsCollector(this);
+
+  // Attach some artificial group information to the universal listeners, to aid with debugging.
+  nsString groupIdForAddons;
+  GenerateUniqueGroupId(mContext, GetNextId(), mProcessId, groupIdForAddons);
+  mUniversalTargets.mAddons->
+    SetTarget(new nsPerformanceGroupDetails(NS_LITERAL_STRING("<universal add-on listener>"),
+                                            groupIdForAddons,
+                                            NS_LITERAL_STRING("<universal add-on listener>"),
+                                            0, // window id
+                                            mProcessId,
+                                            false));
+
+
+  nsString groupIdForWindows;
+  GenerateUniqueGroupId(mContext, GetNextId(), mProcessId, groupIdForWindows);
+  mUniversalTargets.mWindows->
+    SetTarget(new nsPerformanceGroupDetails(NS_LITERAL_STRING("<universal window listener>"),
+                                            groupIdForWindows,
+                                            NS_LITERAL_STRING("<universal window listener>"),
+                                            0, // window id
+                                            mProcessId,
+                                            false));
+}
+
+nsPerformanceStatsService::~nsPerformanceStatsService()
+{ }
+
+/**
+ * Clean up the service.
+ *
+ * Called during shutdown. Idempotent.
+ */
+void
+nsPerformanceStatsService::Dispose()
+{
+  // Make sure that we do not accidentally destroy `this` while we are
+  // cleaning up back references.
+  RefPtr<nsPerformanceStatsService> kungFuDeathGrip(this);
+  mIsAvailable = false;
+
+  if (mDisposed) {
+    // Make sure that we don't double-dispose.
+    return;
+  }
+  mDisposed = true;
+
+  // Disconnect from nsIObserverService.
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    for (size_t i = 0; i < mozilla::ArrayLength(TOPICS); ++i) {
+      mozilla::Unused << obs->RemoveObserver(this, TOPICS[i]);
+    }
+  }
+
+  // Clear up and disconnect from JSAPI.
+  JSContext* cx = mContext;
+  js::DisposePerformanceMonitoring(cx);
+
+  mozilla::Unused << js::SetStopwatchIsMonitoringCPOW(cx, false);
+  mozilla::Unused << js::SetStopwatchIsMonitoringJank(cx, false);
+
+  mozilla::Unused << js::SetStopwatchStartCallback(cx, nullptr, nullptr);
+  mozilla::Unused << js::SetStopwatchCommitCallback(cx, nullptr, nullptr);
+  mozilla::Unused << js::SetGetPerformanceGroupsCallback(cx, nullptr, nullptr);
+
+  // Clear up and disconnect the alerts collector.
+  if (mPendingAlertsCollector) {
+    mPendingAlertsCollector->Dispose();
+    mPendingAlertsCollector = nullptr;
+  }
+  mPendingAlerts.clear();
+
+  // Disconnect universal observers. Per-group observers will be
+  // disconnected below as part of `group->Dispose()`.
+  mUniversalTargets.mAddons = nullptr;
+  mUniversalTargets.mWindows = nullptr;
+
+  // At this stage, the JS VM may still be holding references to
+  // instances of PerformanceGroup on the stack. To let the service be
+  // collected, we need to break the references from these groups to
+  // `this`.
+  mTopGroup->Dispose();
+  mTopGroup = nullptr;
+
+  // Copy references to the groups to a vector to ensure that we do
+  // not modify the hashtable while iterating it.
+  GroupVector groups;
+  for (auto iter = mGroups.Iter(); !iter.Done(); iter.Next()) {
+    if (!groups.append(iter.Get()->GetKey())) {
+      MOZ_CRASH();
+    }
+  }
+  for (auto iter = groups.begin(), end = groups.end(); iter < end; ++iter) {
+    RefPtr<nsPerformanceGroup> group = *iter;
+    group->Dispose();
+  }
+
+  // Any remaining references to PerformanceGroup will be released as
+  // the VM unrolls the stack. If there are any nested event loops,
+  // this may take time.
+}
+
+nsresult
+nsPerformanceStatsService::Init()
+{
+  nsresult rv = InitInternal();
+  if (NS_FAILED(rv)) {
+    // Attempt to clean up.
+    Dispose();
+  }
+  return rv;
+}
+
+nsresult
+nsPerformanceStatsService::InitInternal()
+{
+  // Make sure that we release everything during shutdown.
+  // We are a bit defensive here, as we know that some strange behavior can break the
+  // regular shutdown order.
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    for (size_t i = 0; i < mozilla::ArrayLength(TOPICS); ++i) {
+      mozilla::Unused << obs->AddObserver(this, TOPICS[i], false);
+    }
+  }
+
+  // Connect to JSAPI.
+  JSContext* cx = mContext;
+  if (!js::SetStopwatchStartCallback(cx, StopwatchStartCallback, this)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  if (!js::SetStopwatchCommitCallback(cx, StopwatchCommitCallback, this)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+  if (!js::SetGetPerformanceGroupsCallback(cx, GetPerformanceGroupsCallback, this)) {
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  mTopGroup->setIsActive(true);
+  mIsAvailable = true;
+
+  return NS_OK;
+}
+
+// Observe shutdown events.
+NS_IMETHODIMP
+nsPerformanceStatsService::Observe(nsISupports *aSubject, const char *aTopic,
+                                   const char16_t *aData)
+{
+  MOZ_ASSERT(strcmp(aTopic, "profile-before-change") == 0
+             || strcmp(aTopic, "quit-application") == 0
+             || strcmp(aTopic, "quit-application-granted") == 0
+             || strcmp(aTopic, "xpcom-will-shutdown") == 0);
+
+  Dispose();
+  return NS_OK;
+}
+
+/*static*/ bool
+nsPerformanceStatsService::IsHandlingUserInput() {
+  if (mozilla::EventStateManager::LatestUserInputStart().IsNull()) {
+    return false;
+  }
+  bool result = mozilla::TimeStamp::Now() - mozilla::EventStateManager::LatestUserInputStart() <= mozilla::TimeDuration::FromMicroseconds(mMaxExpectedDurationOfInteractionUS);
+  return result;
+}
+
+/* [implicit_jscontext] attribute bool isMonitoringCPOW; */
+NS_IMETHODIMP
+nsPerformanceStatsService::GetIsMonitoringCPOW(JSContext* cx, bool *aIsStopwatchActive)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  *aIsStopwatchActive = js::GetStopwatchIsMonitoringCPOW(cx);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPerformanceStatsService::SetIsMonitoringCPOW(JSContext* cx, bool aIsStopwatchActive)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (!js::SetStopwatchIsMonitoringCPOW(cx, aIsStopwatchActive)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  return NS_OK;
+}
+
+/* [implicit_jscontext] attribute bool isMonitoringJank; */
+NS_IMETHODIMP
+nsPerformanceStatsService::GetIsMonitoringJank(JSContext* cx, bool *aIsStopwatchActive)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  *aIsStopwatchActive = js::GetStopwatchIsMonitoringJank(cx);
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPerformanceStatsService::SetIsMonitoringJank(JSContext* cx, bool aIsStopwatchActive)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (!js::SetStopwatchIsMonitoringJank(cx, aIsStopwatchActive)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  return NS_OK;
+}
+
+/* [implicit_jscontext] attribute bool isMonitoringPerCompartment; */
+NS_IMETHODIMP
+nsPerformanceStatsService::GetIsMonitoringPerCompartment(JSContext*, bool *aIsMonitoringPerCompartment)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  *aIsMonitoringPerCompartment = mIsMonitoringPerCompartment;
+  return NS_OK;
+}
+NS_IMETHODIMP
+nsPerformanceStatsService::SetIsMonitoringPerCompartment(JSContext*, bool aIsMonitoringPerCompartment)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (aIsMonitoringPerCompartment == mIsMonitoringPerCompartment) {
+    return NS_OK;
+  }
+
+  // Relatively slow update: walk the entire lost of performance groups,
+  // update the active flag of those that have changed.
+  //
+  // Alternative strategies could be envisioned to make the update
+  // much faster, at the expense of the speed of calling `isActive()`,
+  // (e.g. deferring `isActive()` to the nsPerformanceStatsService),
+  // but we expect that `isActive()` can be called thousands of times
+  // per second, while `SetIsMonitoringPerCompartment` is not called
+  // at all during most Firefox runs.
+
+  for (auto iter = mGroups.Iter(); !iter.Done(); iter.Next()) {
+    RefPtr<nsPerformanceGroup> group = iter.Get()->GetKey();
+    if (group->Scope() == nsPerformanceGroup::GroupScope::COMPARTMENT) {
+      group->setIsActive(aIsMonitoringPerCompartment);
+    }
+  }
+  mIsMonitoringPerCompartment = aIsMonitoringPerCompartment;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::GetJankAlertThreshold(uint64_t* result) {
+  *result = mJankAlertThreshold;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::SetJankAlertThreshold(uint64_t value) {
+  mJankAlertThreshold = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::GetJankAlertBufferingDelay(uint32_t* result) {
+  *result = mJankAlertBufferingDelay;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::SetJankAlertBufferingDelay(uint32_t value) {
+  mJankAlertBufferingDelay = value;
+  return NS_OK;
+}
+
+nsresult
+nsPerformanceStatsService::UpdateTelemetry()
+{
+  // Promote everything to floating-point explicitly before dividing.
+  const double processStayed = mProcessStayed;
+  const double processMoved = mProcessMoved;
+
+  if (processStayed <= 0 || processMoved <= 0 || processStayed + processMoved <= 0) {
+    // Overflow/underflow/nothing to report
+    return NS_OK;
+  }
+
+  const double proportion = (100 * processStayed) / (processStayed + processMoved);
+  if (proportion < 0 || proportion > 100) {
+    // Overflow/underflow
+    return NS_OK;
+  }
+
+  mozilla::Telemetry::Accumulate(mozilla::Telemetry::PERF_MONITORING_TEST_CPU_RESCHEDULING_PROPORTION_MOVED, (uint32_t)proportion);
+  return NS_OK;
+}
+
+
+/* static */ nsIPerformanceStats*
+nsPerformanceStatsService::GetStatsForGroup(const js::PerformanceGroup* group)
+{
+  return GetStatsForGroup(nsPerformanceGroup::Get(group));
+}
+
+/* static */ nsIPerformanceStats*
+nsPerformanceStatsService::GetStatsForGroup(const nsPerformanceGroup* group)
+{
+  return new nsPerformanceStats(group->Details(), group->data);
+}
+
+/* [implicit_jscontext] nsIPerformanceSnapshot getSnapshot (); */
+NS_IMETHODIMP
+nsPerformanceStatsService::GetSnapshot(JSContext* cx, nsIPerformanceSnapshot * *aSnapshot)
+{
+  if (!mIsAvailable) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  RefPtr<nsPerformanceSnapshot> snapshot = new nsPerformanceSnapshot();
+  snapshot->SetProcessStats(GetStatsForGroup(mTopGroup));
+
+  for (auto iter = mGroups.Iter(); !iter.Done(); iter.Next()) {
+    auto* entry = iter.Get();
+    nsPerformanceGroup* group = entry->GetKey();
+    if (group->isActive()) {
+      snapshot->AppendComponentsStats(GetStatsForGroup(group));
+    }
+  }
+
+  js::GetPerfMonitoringTestCpuRescheduling(cx, &mProcessStayed, &mProcessMoved);
+
+  if (++mProcessUpdateCounter % 10 == 0) {
+    mozilla::Unused << UpdateTelemetry();
+  }
+
+  snapshot.forget(aSnapshot);
+
+  return NS_OK;
+}
+
+uint64_t
+nsPerformanceStatsService::GetNextId() {
+  return ++mUIdCounter;
+}
+
+/* static*/ bool
+nsPerformanceStatsService::GetPerformanceGroupsCallback(JSContext* cx,
+                                                        js::PerformanceGroupVector& out,
+                                                        void* closure)
+{
+  RefPtr<nsPerformanceStatsService> self = reinterpret_cast<nsPerformanceStatsService*>(closure);
+  return self->GetPerformanceGroups(cx, out);
+}
+
+bool
+nsPerformanceStatsService::GetPerformanceGroups(JSContext* cx,
+                                                js::PerformanceGroupVector& out)
+{
+  JS::RootedObject global(cx, JS::CurrentGlobalOrNull(cx));
+  if (!global) {
+    // While it is possible for a compartment to have no global
+    // (e.g. atoms), this compartment is not very interesting for us.
+    return true;
+  }
+
+  // All compartments belong to the top group.
+  if (!out.append(mTopGroup)) {
+    JS_ReportOutOfMemory(cx);
+    return false;
+  }
+
+  nsAutoString name;
+  CompartmentName(cx, global, name);
+  bool isSystem = nsContentUtils::IsSystemPrincipal(nsContentUtils::ObjectPrincipal(global));
+
+  // Find out if the compartment is executed by an add-on. If so, its
+  // duration should count towards the total duration of the add-on.
+  JSAddonId* jsaddonId = AddonIdOfObject(global);
+  nsString addonId;
+  if (jsaddonId) {
+    AssignJSFlatString(addonId, (JSFlatString*)jsaddonId);
+    auto entry = mAddonIdToGroup.PutEntry(addonId);
+    if (!entry->GetGroup()) {
+      nsString addonName = name;
+      addonName.AppendLiteral(" (as addon ");
+      addonName.Append(addonId);
+      addonName.AppendLiteral(")");
+      entry->
+        SetGroup(nsPerformanceGroup::Make(mContext, this,
+                                          addonName, addonId, 0,
+                                          mProcessId, isSystem,
+                                          nsPerformanceGroup::GroupScope::ADDON)
+                 );
+    }
+    if (!out.append(entry->GetGroup())) {
+      JS_ReportOutOfMemory(cx);
+      return false;
+    }
+  }
+
+  // Find out if the compartment is executed by a window. If so, its
+  // duration should count towards the total duration of the window.
+  uint64_t windowId = 0;
+  if (nsCOMPtr<nsPIDOMWindowOuter> ptop = GetPrivateWindow(cx)) {
+    windowId = ptop->WindowID();
+    auto entry = mWindowIdToGroup.PutEntry(windowId);
+    if (!entry->GetGroup()) {
+      nsString windowName = name;
+      windowName.AppendLiteral(" (as window ");
+      windowName.AppendInt(windowId);
+      windowName.AppendLiteral(")");
+      entry->
+        SetGroup(nsPerformanceGroup::Make(mContext, this,
+                                          windowName, EmptyString(), windowId,
+                                          mProcessId, isSystem,
+                                          nsPerformanceGroup::GroupScope::WINDOW)
+                 );
+    }
+    if (!out.append(entry->GetGroup())) {
+      JS_ReportOutOfMemory(cx);
+      return false;
+    }
+  }
+
+  // All compartments have their own group.
+  auto group =
+    nsPerformanceGroup::Make(mContext, this,
+                             name, addonId, windowId,
+                             mProcessId, isSystem,
+                             nsPerformanceGroup::GroupScope::COMPARTMENT);
+  if (!out.append(group)) {
+    JS_ReportOutOfMemory(cx);
+    return false;
+  }
+
+  return true;
+}
+
+/*static*/ bool
+nsPerformanceStatsService::StopwatchStartCallback(uint64_t iteration, void* closure) {
+  RefPtr<nsPerformanceStatsService> self = reinterpret_cast<nsPerformanceStatsService*>(closure);
+  return self->StopwatchStart(iteration);
+}
+
+bool
+nsPerformanceStatsService::StopwatchStart(uint64_t iteration) {
+  mIteration = iteration;
+
+  mIsHandlingUserInput = IsHandlingUserInput();
+  mUserInputCount = mozilla::EventStateManager::UserInputCount();
+
+  nsresult rv = GetResources(&mUserTimeStart, &mSystemTimeStart);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  return true;
+}
+
+/*static*/ bool
+nsPerformanceStatsService::StopwatchCommitCallback(uint64_t iteration,
+                                                   js::PerformanceGroupVector& recentGroups,
+                                                   void* closure)
+{
+  RefPtr<nsPerformanceStatsService> self = reinterpret_cast<nsPerformanceStatsService*>(closure);
+  return self->StopwatchCommit(iteration, recentGroups);
+}
+
+bool
+nsPerformanceStatsService::StopwatchCommit(uint64_t iteration,
+                                           js::PerformanceGroupVector& recentGroups)
+{
+  MOZ_ASSERT(iteration == mIteration);
+  MOZ_ASSERT(!recentGroups.empty());
+
+  uint64_t userTimeStop, systemTimeStop;
+  nsresult rv = GetResources(&userTimeStop, &systemTimeStop);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  // `GetResources` is not guaranteed to be monotonic, so round up
+  // any negative result to 0 milliseconds.
+  uint64_t userTimeDelta = 0;
+  if (userTimeStop > mUserTimeStart)
+    userTimeDelta = userTimeStop - mUserTimeStart;
+
+  uint64_t systemTimeDelta = 0;
+  if (systemTimeStop > mSystemTimeStart)
+    systemTimeDelta = systemTimeStop - mSystemTimeStart;
+
+  MOZ_ASSERT(mTopGroup->isUsedInThisIteration());
+  const uint64_t totalRecentCycles = mTopGroup->recentCycles(iteration);
+
+  const bool isHandlingUserInput = mIsHandlingUserInput || mozilla::EventStateManager::UserInputCount() > mUserInputCount;
+
+  // We should only reach this stage if `group` has had some activity.
+  MOZ_ASSERT(mTopGroup->recentTicks(iteration) > 0);
+  for (auto iter = recentGroups.begin(), end = recentGroups.end(); iter != end; ++iter) {
+    RefPtr<nsPerformanceGroup> group = nsPerformanceGroup::Get(*iter);
+    CommitGroup(iteration, userTimeDelta, systemTimeDelta, totalRecentCycles, isHandlingUserInput, group);
+  }
+
+  // Make sure that `group` was treated along with the other items of `recentGroups`.
+  MOZ_ASSERT(!mTopGroup->isUsedInThisIteration());
+  MOZ_ASSERT(mTopGroup->recentTicks(iteration) == 0);
+
+  if (!mPendingAlerts.empty()) {
+    mPendingAlertsCollector->Start(mJankAlertBufferingDelay);
+  }
+
+  return true;
+}
+
+void
+nsPerformanceStatsService::CommitGroup(uint64_t iteration,
+                                       uint64_t totalUserTimeDelta, uint64_t totalSystemTimeDelta,
+                                       uint64_t totalCyclesDelta,
+                                       bool isHandlingUserInput,
+                                       nsPerformanceGroup* group) {
+
+  MOZ_ASSERT(group->isUsedInThisIteration());
+
+  const uint64_t ticksDelta = group->recentTicks(iteration);
+  const uint64_t cpowTimeDelta = group->recentCPOW(iteration);
+  const uint64_t cyclesDelta = group->recentCycles(iteration);
+  group->resetRecentData();
+
+  // We have now performed all cleanup and may `return` at any time without fear of leaks.
+
+  if (group->iteration() != iteration) {
+    // Stale data, don't commit.
+    return;
+  }
+
+  // When we add a group as changed, we immediately set its
+  // `recentTicks` from 0 to 1.  If we have `ticksDelta == 0` at
+  // this stage, we have already called `resetRecentData` but we
+  // haven't removed it from the list.
+  MOZ_ASSERT(ticksDelta != 0);
+  MOZ_ASSERT(cyclesDelta <= totalCyclesDelta);
+  if (cyclesDelta == 0 || totalCyclesDelta == 0) {
+    // Nothing useful, don't commit.
+    return;
+  }
+
+  double proportion = (double)cyclesDelta / (double)totalCyclesDelta;
+  MOZ_ASSERT(proportion <= 1);
+
+  const uint64_t userTimeDelta = proportion * totalUserTimeDelta;
+  const uint64_t systemTimeDelta = proportion * totalSystemTimeDelta;
+
+  group->data.mTotalUserTime += userTimeDelta;
+  group->data.mTotalSystemTime += systemTimeDelta;
+  group->data.mTotalCPOWTime += cpowTimeDelta;
+  group->data.mTicks += ticksDelta;
+
+  const uint64_t totalTimeDelta = userTimeDelta + systemTimeDelta + cpowTimeDelta;
+  uint64_t duration = 1000;   // 1ms in µs
+  for (size_t i = 0;
+       i < mozilla::ArrayLength(group->data.mDurations) && duration < totalTimeDelta;
+       ++i, duration *= 2) {
+    group->data.mDurations[i]++;
+  }
+
+  group->RecordJank(totalTimeDelta);
+  group->RecordCPOW(cpowTimeDelta);
+  if (isHandlingUserInput) {
+    group->RecordUserInput();
+  }
+
+  if (totalTimeDelta >= mJankAlertThreshold) {
+    if (!group->HasPendingAlert()) {
+      if (mPendingAlerts.append(group)) {
+        group->SetHasPendingAlert(true);
+      }
+      return;
+    }
+  }
+
+  return;
+}
+
+nsresult
+nsPerformanceStatsService::GetResources(uint64_t* userTime,
+                                        uint64_t* systemTime) const {
+  MOZ_ASSERT(userTime);
+  MOZ_ASSERT(systemTime);
+
+#if defined(XP_MACOSX)
+  // On MacOS X, to get we per-thread data, we need to
+  // reach into the kernel.
+
+  mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+  thread_basic_info_data_t info;
+  mach_port_t port = mach_thread_self();
+  kern_return_t err =
+    thread_info(/* [in] targeted thread*/ port,
+                /* [in] nature of information*/ THREAD_BASIC_INFO,
+                /* [out] thread information */  (thread_info_t)&info,
+                /* [inout] number of items */   &count);
+
+  // We do not need ability to communicate with the thread, so
+  // let's release the port.
+  mach_port_deallocate(mach_task_self(), port);
+
+  if (err != KERN_SUCCESS)
+    return NS_ERROR_FAILURE;
+
+  *userTime = info.user_time.microseconds + info.user_time.seconds * 1000000;
+  *systemTime = info.system_time.microseconds + info.system_time.seconds * 1000000;
+
+#elif defined(XP_UNIX)
+  struct rusage rusage;
+#if defined(RUSAGE_THREAD)
+  // Under Linux, we can obtain per-thread statistics
+  int err = getrusage(RUSAGE_THREAD, &rusage);
+#else
+  // Under other Unices, we need to do with more noisy
+  // per-process statistics.
+  int err = getrusage(RUSAGE_SELF, &rusage);
+#endif // defined(RUSAGE_THREAD)
+
+  if (err)
+    return NS_ERROR_FAILURE;
+
+  *userTime = rusage.ru_utime.tv_usec + rusage.ru_utime.tv_sec * 1000000;
+  *systemTime = rusage.ru_stime.tv_usec + rusage.ru_stime.tv_sec * 1000000;
+
+#elif defined(XP_WIN)
+  // Under Windows, we can obtain per-thread statistics. Experience
+  // seems to suggest that they are not very accurate under Windows
+  // XP, though.
+  FILETIME creationFileTime; // Ignored
+  FILETIME exitFileTime; // Ignored
+  FILETIME kernelFileTime;
+  FILETIME userFileTime;
+  BOOL success = GetThreadTimes(GetCurrentThread(),
+                                &creationFileTime, &exitFileTime,
+                                &kernelFileTime, &userFileTime);
+
+  if (!success)
+    return NS_ERROR_FAILURE;
+
+  ULARGE_INTEGER kernelTimeInt;
+  kernelTimeInt.LowPart = kernelFileTime.dwLowDateTime;
+  kernelTimeInt.HighPart = kernelFileTime.dwHighDateTime;
+  // Convert 100 ns to 1 us.
+  *systemTime = kernelTimeInt.QuadPart / 10;
+
+  ULARGE_INTEGER userTimeInt;
+  userTimeInt.LowPart = userFileTime.dwLowDateTime;
+  userTimeInt.HighPart = userFileTime.dwHighDateTime;
+  // Convert 100 ns to 1 us.
+  *userTime = userTimeInt.QuadPart / 10;
+
+#endif // defined(XP_MACOSX) || defined(XP_UNIX) || defined(XP_WIN)
+
+  return NS_OK;
+}
+
+void
+nsPerformanceStatsService::NotifyJankObservers(const mozilla::Vector<uint64_t>& aPreviousJankLevels) {
+  GroupVector alerts;
+  mPendingAlerts.swap(alerts);
+  if (!mPendingAlertsCollector) {
+    // We are shutting down.
+    return;
+  }
+
+  // Find out if we have noticed any user-noticeable delay in an
+  // animation recently (i.e. since the start of the execution of JS
+  // code that caused this collector to start). If so, we'll mark any
+  // alert as part of a user-noticeable jank. Note that this doesn't
+  // mean with any certainty that the alert is the only cause of jank,
+  // or even the main cause of jank.
+  mozilla::Vector<uint64_t> latestJankLevels;
+  {
+    mozilla::DebugOnly<bool> result = nsRefreshDriver::GetJankLevels(latestJankLevels);
+    MOZ_ASSERT(result);
+  }
+  MOZ_ASSERT(latestJankLevels.length() == aPreviousJankLevels.length());
+
+  bool isJankInAnimation = false;
+  for (size_t i = mJankLevelVisibilityThreshold; i < latestJankLevels.length(); ++i) {
+    if (latestJankLevels[i] > aPreviousJankLevels[i]) {
+      isJankInAnimation = true;
+      break;
+    }
+  }
+
+  MOZ_ASSERT(!alerts.empty());
+  const bool hasUniversalAddonObservers = mUniversalTargets.mAddons->HasObservers();
+  const bool hasUniversalWindowObservers = mUniversalTargets.mWindows->HasObservers();
+  for (auto iter = alerts.begin(); iter < alerts.end(); ++iter) {
+    MOZ_ASSERT(iter);
+    RefPtr<nsPerformanceGroup> group = *iter;
+    group->SetHasPendingAlert(false);
+
+    RefPtr<nsPerformanceGroupDetails> details = group->Details();
+    nsPerformanceObservationTarget* targets[3] = {
+      hasUniversalAddonObservers && details->IsAddon() ? mUniversalTargets.mAddons.get() : nullptr,
+      hasUniversalWindowObservers && details->IsWindow() ? mUniversalTargets.mWindows.get() : nullptr,
+      group->ObservationTarget()
+    };
+
+    bool isJankInInput = group->HasRecentUserInput();
+
+    RefPtr<PerformanceAlert> alert;
+    for (nsPerformanceObservationTarget* target : targets) {
+      if (!target) {
+        continue;
+      }
+      if (!alert) {
+        const uint32_t reason = nsIPerformanceAlert::REASON_SLOWDOWN
+          | (isJankInAnimation ? nsIPerformanceAlert::REASON_JANK_IN_ANIMATION : 0)
+          | (isJankInInput ? nsIPerformanceAlert::REASON_JANK_IN_INPUT : 0);
+        // Wait until we are sure we need to allocate before we allocate.
+        alert = new PerformanceAlert(reason, group);
+      }
+      target->NotifyJankObservers(details, alert);
+    }
+
+    group->ResetRecent();
+  }
+
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::GetObservableAddon(const nsAString& addonId,
+                                              nsIPerformanceObservable** result) {
+  if (addonId.Equals(NS_LITERAL_STRING("*"))) {
+    NS_IF_ADDREF(*result = mUniversalTargets.mAddons);
+  } else {
+    auto entry = mAddonIdToGroup.PutEntry(addonId);
+    NS_IF_ADDREF(*result = entry->ObservationTarget());
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::GetObservableWindow(uint64_t windowId,
+                                               nsIPerformanceObservable** result) {
+  if (windowId == 0) {
+    NS_IF_ADDREF(*result = mUniversalTargets.mWindows);
+  } else {
+    auto entry = mWindowIdToGroup.PutEntry(windowId);
+    NS_IF_ADDREF(*result = entry->ObservationTarget());
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::GetAnimationJankLevelThreshold(short* result) {
+  *result = mJankLevelVisibilityThreshold;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::SetAnimationJankLevelThreshold(short value) {
+  mJankLevelVisibilityThreshold = value;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::GetUserInputDelayThreshold(uint64_t* result) {
+  *result = mMaxExpectedDurationOfInteractionUS;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPerformanceStatsService::SetUserInputDelayThreshold(uint64_t value) {
+  mMaxExpectedDurationOfInteractionUS = value;
+  return NS_OK;
+}
+
+
+
+nsPerformanceStatsService::UniversalTargets::UniversalTargets()
+  : mAddons(new nsPerformanceObservationTarget())
+  , mWindows(new nsPerformanceObservationTarget())
+{ }
+
+/* ------------------------------------------------------
+ *
+ * Class nsPerformanceGroup
+ *
+ */
+
+/*static*/ nsPerformanceGroup*
+nsPerformanceGroup::Make(JSContext* cx,
+                         nsPerformanceStatsService* service,
+                         const nsAString& name,
+                         const nsAString& addonId,
+                         uint64_t windowId,
+                         uint64_t processId,
+                         bool isSystem,
+                         GroupScope scope)
+{
+  nsString groupId;
+  ::GenerateUniqueGroupId(cx, service->GetNextId(), processId, groupId);
+  return new nsPerformanceGroup(service, name, groupId, addonId, windowId, processId, isSystem, scope);
+}
+
+nsPerformanceGroup::nsPerformanceGroup(nsPerformanceStatsService* service,
+                                       const nsAString& name,
+                                       const nsAString& groupId,
+                                       const nsAString& addonId,
+                                       uint64_t windowId,
+                                       uint64_t processId,
+                                       bool isSystem,
+                                       GroupScope scope)
+  : mDetails(new nsPerformanceGroupDetails(name, groupId, addonId, windowId, processId, isSystem))
+  , mService(service)
+  , mScope(scope)
+  , mHighestJank(0)
+  , mHighestCPOW(0)
+  , mHasRecentUserInput(false)
+  , mHasPendingAlert(false)
+{
+  mozilla::Unused << mService->mGroups.PutEntry(this);
+
+#if defined(DEBUG)
+  if (scope == GroupScope::ADDON) {
+    MOZ_ASSERT(mDetails->IsAddon());
+    MOZ_ASSERT(!mDetails->IsWindow());
+  } else if (scope == GroupScope::WINDOW) {
+    MOZ_ASSERT(mDetails->IsWindow());
+    MOZ_ASSERT(!mDetails->IsAddon());
+  } else if (scope == GroupScope::RUNTIME) {
+    MOZ_ASSERT(!mDetails->IsWindow());
+    MOZ_ASSERT(!mDetails->IsAddon());
+  }
+#endif // defined(DEBUG)
+  setIsActive(mScope != GroupScope::COMPARTMENT || mService->mIsMonitoringPerCompartment);
+}
+
+void
+nsPerformanceGroup::Dispose() {
+  if (!mService) {
+    // We have already called `Dispose()`.
+    return;
+  }
+  if (mObservationTarget) {
+    mObservationTarget = nullptr;
+  }
+
+  // Remove any reference to the service.
+  RefPtr<nsPerformanceStatsService> service;
+  service.swap(mService);
+
+  // Remove any dangling pointer to `this`.
+  service->mGroups.RemoveEntry(this);
+
+  if (mScope == GroupScope::ADDON) {
+    MOZ_ASSERT(mDetails->IsAddon());
+    service->mAddonIdToGroup.RemoveEntry(mDetails->AddonId());
+  } else if (mScope == GroupScope::WINDOW) {
+    MOZ_ASSERT(mDetails->IsWindow());
+    service->mWindowIdToGroup.RemoveEntry(mDetails->WindowId());
+  }
+}
+
+nsPerformanceGroup::~nsPerformanceGroup() {
+  Dispose();
+}
+
+nsPerformanceGroup::GroupScope
+nsPerformanceGroup::Scope() const {
+  return mScope;
+}
+
+nsPerformanceGroupDetails*
+nsPerformanceGroup::Details() const {
+  return mDetails;
+}
+
+void
+nsPerformanceGroup::SetObservationTarget(nsPerformanceObservationTarget* target) {
+  MOZ_ASSERT(!mObservationTarget);
+  mObservationTarget = target;
+}
+
+nsPerformanceObservationTarget*
+nsPerformanceGroup::ObservationTarget() const {
+  return mObservationTarget;
+}
+
+bool
+nsPerformanceGroup::HasPendingAlert() const {
+  return mHasPendingAlert;
+}
+
+void
+nsPerformanceGroup::SetHasPendingAlert(bool value) {
+  mHasPendingAlert = value;
+}
+
+
+void
+nsPerformanceGroup::RecordJank(uint64_t jank) {
+  if (jank > mHighestJank) {
+    mHighestJank = jank;
+  }
+}
+
+void
+nsPerformanceGroup::RecordCPOW(uint64_t cpow) {
+  if (cpow > mHighestCPOW) {
+    mHighestCPOW = cpow;
+  }
+}
+
+uint64_t
+nsPerformanceGroup::HighestRecentJank() {
+  return mHighestJank;
+}
+
+uint64_t
+nsPerformanceGroup::HighestRecentCPOW() {
+  return mHighestCPOW;
+}
+
+bool
+nsPerformanceGroup::HasRecentUserInput() {
+  return mHasRecentUserInput;
+}
+
+void
+nsPerformanceGroup::RecordUserInput() {
+  mHasRecentUserInput = true;
+}
+
+void
+nsPerformanceGroup::ResetRecent() {
+  mHighestJank = 0;
+  mHighestCPOW = 0;
+  mHasRecentUserInput = false;
+}