Add m-esr52 at 52.6.0

1 files changed, 825 insertions, 0 deletions

diff --git a/toolkit/components/perfmonitoring/nsPerformanceStats.h b/toolkit/components/perfmonitoring/nsPerformanceStats.h
new file mode 100644
index 0000000000..c82a3e92c7
--- /dev/null
+++ b/toolkit/components/perfmonitoring/nsPerformanceStats.h
@@ -0,0 +1,825 @@
+/* -*- 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 nsPerformanceStats_h
+#define nsPerformanceStats_h
+
+#include "jsapi.h"
+
+#include "nsHashKeys.h"
+#include "nsTHashtable.h"
+
+#include "nsIObserver.h"
+#include "nsPIDOMWindow.h"
+
+#include "nsIPerformanceStats.h"
+
+class nsPerformanceGroup;
+class nsPerformanceGroupDetails;
+
+typedef mozilla::Vector<RefPtr<nsPerformanceGroup>> GroupVector;
+
+/**
+ * A data structure for registering observers interested in
+ * performance alerts.
+ *
+ * Each performance group owns a single instance of this class.
+ * Additionally, the service owns instances designed to observe the
+ * performance alerts in all add-ons (respectively webpages).
+ */
+class nsPerformanceObservationTarget final: public nsIPerformanceObservable {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPERFORMANCEOBSERVABLE
+
+  /**
+   * `true` if this target has at least once performance observer
+   * registered, `false` otherwise.
+   */
+  bool HasObservers() const;
+
+  /**
+   * Notify all the observers that jank has happened.
+   */
+  void NotifyJankObservers(nsIPerformanceGroupDetails* source, nsIPerformanceAlert* gravity);
+
+  /**
+   * Set the details on the group being observed.
+   */
+  void SetTarget(nsPerformanceGroupDetails* details);
+
+private:
+  ~nsPerformanceObservationTarget() {}
+
+  // The observers for this target. We hold them as a vector, despite
+  // the linear removal cost, as we expect that the typical number of
+  // observers will be lower than 3, and that (un)registrations will
+  // be fairly infrequent.
+  mozilla::Vector<nsCOMPtr<nsIPerformanceObserver>> mObservers;
+
+  // Details on the group being observed. May be `nullptr`.
+  RefPtr<nsPerformanceGroupDetails> mDetails;
+};
+
+/**
+ * The base class for entries of maps from addon id/window id to
+ * performance group.
+ *
+ * Performance observers may be registered before their group is
+ * created (e.g., one may register an observer for an add-on before
+ * all its modules are loaded, or even before the add-on is loaded at
+ * all or for an observer for a webpage before all its iframes are
+ * loaded). This class serves to hold the observation target until the
+ * performance group may be created, and then to associate the
+ * observation target and the performance group.
+ */
+class nsGroupHolder {
+public:
+  nsGroupHolder()
+    : mGroup(nullptr)
+    , mPendingObservationTarget(nullptr)
+  { }
+
+  /**
+   * Get the observation target, creating it if necessary.
+   */
+  nsPerformanceObservationTarget* ObservationTarget();
+
+  /**
+   * Get the group, if it has been created.
+   *
+   * May return `null` if the group hasn't been created yet.
+   */
+  class nsPerformanceGroup* GetGroup();
+
+  /**
+   * Set the group.
+   *
+   * Once this method has been called, calling
+   * `this->ObservationTarget()` and `group->ObservationTarget()` is equivalent.
+   *
+   * Must only be called once.
+   */
+  void SetGroup(class nsPerformanceGroup*);
+private:
+  // The group. Initially `nullptr`, until we have called `SetGroup`.
+  class nsPerformanceGroup* mGroup;
+
+  // The observation target. Instantiated by the first call to
+  // `ObservationTarget()`.
+  RefPtr<nsPerformanceObservationTarget> mPendingObservationTarget;
+};
+
+/**
+ * An implementation of the nsIPerformanceStatsService.
+ *
+ * Note that this implementation is not thread-safe.
+ */
+class nsPerformanceStatsService final : public nsIPerformanceStatsService,
+                                        public nsIObserver
+{
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPERFORMANCESTATSSERVICE
+  NS_DECL_NSIOBSERVER
+
+  nsPerformanceStatsService();
+  nsresult Init();
+
+private:
+  nsresult InitInternal();
+  void Dispose();
+  ~nsPerformanceStatsService();
+
+protected:
+  friend nsPerformanceGroup;
+
+  /**
+   * `false` until `Init()` and after `Dispose()`, `true` inbetween.
+   */
+  bool mIsAvailable;
+
+  /**
+   * `true` once we have called `Dispose()`.
+   */
+  bool mDisposed;
+
+  /**
+   * A unique identifier for the process.
+   *
+   * Process HANDLE under Windows, pid under Unix.
+   */
+  const uint64_t mProcessId;
+
+  /**
+   * The JS Context for the main thread.
+   */
+  JSContext* const mContext;
+
+  /**
+   * Generate unique identifiers.
+   */
+  uint64_t GetNextId();
+  uint64_t mUIdCounter;
+
+
+
+  /**
+   * Extract a snapshot of performance statistics from a performance group.
+   */
+  static nsIPerformanceStats* GetStatsForGroup(const js::PerformanceGroup* group);
+  static nsIPerformanceStats* GetStatsForGroup(const nsPerformanceGroup* group);
+
+
+
+  /**
+   * Get the performance groups associated to a given JS compartment.
+   *
+   * A compartment is typically associated to the following groups:
+   * - the top group, shared by the entire process;
+   * - the window group, if the code is executed in a window, shared
+   *     by all compartments for that window (typically, all frames);
+   * - the add-on group, if the code is executed as an add-on, shared
+   *     by all compartments for that add-on (typically, all modules);
+   * - the compartment's own group.
+   *
+   * Pre-condition: the VM must have entered the JS compartment.
+   *
+   * The caller is expected to cache the results of this method, as
+   * calling it more than once may not return the same instances of
+   * performance groups.
+   */
+  bool GetPerformanceGroups(JSContext* cx, js::PerformanceGroupVector&);
+  static bool GetPerformanceGroupsCallback(JSContext* cx, js::PerformanceGroupVector&, void* closure);
+
+
+
+  /**********************************************************
+   *
+   * Sets of all performance groups, indexed by several keys.
+   *
+   * These sets do not keep the performance groups alive. Rather, a
+   * performance group is inserted in the relevant sets upon
+   * construction and removed from the sets upon destruction or when
+   * we Dispose() of the service.
+   *
+   * A `nsPerformanceGroup` is typically kept alive (as a
+   * `js::PerformanceGroup`) by the JSCompartment to which it is
+   * associated. It may also temporarily be kept alive by the JS
+   * stack, in particular in case of nested event loops.
+   */
+
+  /**
+   * Set of performance groups associated to add-ons, indexed
+   * by add-on id. Each item is shared by all the compartments
+   * that belong to the add-on.
+   */
+  struct AddonIdToGroup: public nsStringHashKey,
+                         public nsGroupHolder {
+    explicit AddonIdToGroup(const nsAString* key)
+      : nsStringHashKey(key)
+    { }
+  };
+  nsTHashtable<AddonIdToGroup> mAddonIdToGroup;
+
+  /**
+   * Set of performance groups associated to windows, indexed by outer
+   * window id. Each item is shared by all the compartments that
+   * belong to the window.
+   */
+  struct WindowIdToGroup: public nsUint64HashKey,
+                          public nsGroupHolder {
+    explicit WindowIdToGroup(const uint64_t* key)
+      : nsUint64HashKey(key)
+    {}
+  };
+  nsTHashtable<WindowIdToGroup> mWindowIdToGroup;
+
+  /**
+   * Set of all performance groups.
+   */
+  struct Groups: public nsPtrHashKey<nsPerformanceGroup> {
+    explicit Groups(const nsPerformanceGroup* key)
+      : nsPtrHashKey<nsPerformanceGroup>(key)
+    {}
+  };
+  nsTHashtable<Groups> mGroups;
+
+  /**
+   * The performance group representing the runtime itself.  All
+   * compartments are associated to this group.
+   */
+  RefPtr<nsPerformanceGroup> mTopGroup;
+
+  /**********************************************************
+   *
+   * Measuring and recording the CPU use of the system.
+   *
+   */
+
+  /**
+   * Get the OS-reported time spent in userland/systemland, in
+   * microseconds. On most platforms, this data is per-thread,
+   * but on some platforms we need to fall back to per-process.
+   *
+   * Data is not guaranteed to be monotonic.
+   */
+  nsresult GetResources(uint64_t* userTime, uint64_t* systemTime) const;
+
+  /**
+   * Amount of user/system CPU time used by the thread (or process,
+   * for platforms that don't support per-thread measure) since start.
+   * Updated by `StopwatchStart` at most once per event.
+   *
+   * Unit: microseconds.
+   */
+  uint64_t mUserTimeStart;
+  uint64_t mSystemTimeStart;
+
+  bool mIsHandlingUserInput;
+
+  /**
+   * The number of user inputs since the start of the process. Used to
+   * determine whether the current iteration has triggered a
+   * (JS-implemented) user input.
+   */
+  uint64_t mUserInputCount;
+
+  /**********************************************************
+   *
+   * Callbacks triggered by the JS VM when execution of JavaScript
+   * code starts/completes.
+   *
+   * As measures of user CPU time/system CPU time have low resolution
+   * (and are somewhat slow), we measure both only during the calls to
+   * `StopwatchStart`/`StopwatchCommit` and we make the assumption
+   * that each group's user/system CPU time is proportional to the
+   * number of clock cycles spent executing code in the group between
+   * `StopwatchStart`/`StopwatchCommit`.
+   *
+   * The results may be skewed by the thread being rescheduled to a
+   * different CPU during the measure, but we expect that on average,
+   * the skew will have limited effects, and will generally tend to
+   * make already-slow executions appear slower.
+   */
+
+  /**
+   * Execution of JavaScript code has started. This may happen several
+   * times in succession if the JavaScript code contains nested event
+   * loops, in which case only the innermost call will receive
+   * `StopwatchCommitCallback`.
+   *
+   * @param iteration The number of times we have started executing
+   * JavaScript code.
+   */
+  static bool StopwatchStartCallback(uint64_t iteration, void* closure);
+  bool StopwatchStart(uint64_t iteration);
+
+  /**
+   * Execution of JavaScript code has reached completion (including
+   * enqueued microtasks). In cse of tested event loops, any ongoing
+   * measurement on outer loops is silently cancelled without any call
+   * to this method.
+   *
+   * @param iteration The number of times we have started executing
+   * JavaScript code.
+   * @param recentGroups The groups that have seen activity during this
+   * event.
+   */
+  static bool StopwatchCommitCallback(uint64_t iteration,
+                                      js::PerformanceGroupVector& recentGroups,
+                                      void* closure);
+  bool StopwatchCommit(uint64_t iteration, js::PerformanceGroupVector& recentGroups);
+
+  /**
+   * The number of times we have started executing JavaScript code.
+   */
+  uint64_t mIteration;
+
+  /**
+   * Commit performance measures of a single group.
+   *
+   * Data is transfered from `group->recent*` to `group->data`.
+   *
+   *
+   * @param iteration The current iteration.
+   * @param userTime The total user CPU time for this thread (or
+   *   process, if per-thread data is not available) between the
+   *   calls to `StopwatchStart` and `StopwatchCommit`.
+   * @param systemTime The total system CPU time for this thread (or
+   *   process, if per-thread data is not available) between the
+   *   calls to `StopwatchStart` and `StopwatchCommit`.
+   * @param cycles The total number of cycles for this thread
+   *   between the calls to `StopwatchStart` and `StopwatchCommit`.
+   * @param isJankVisible If `true`, expect that the user will notice
+   *   any slowdown.
+   * @param group The group containing the data to commit.
+   */
+  void CommitGroup(uint64_t iteration,
+                   uint64_t userTime, uint64_t systemTime,  uint64_t cycles,
+                   bool isJankVisible,
+                   nsPerformanceGroup* group);
+
+
+
+
+  /**********************************************************
+   *
+   * To check whether our algorithm makes sense, we keep count of the
+   * number of times the process has been rescheduled to another CPU
+   * while we were monitoring the performance of a group and we upload
+   * this data through Telemetry.
+   */
+  nsresult UpdateTelemetry();
+
+  uint64_t mProcessStayed;
+  uint64_t mProcessMoved;
+  uint32_t mProcessUpdateCounter;
+
+  /**********************************************************
+   *
+   * Options controlling measurements.
+   */
+
+  /**
+   * Determine if we are measuring the performance of every individual
+   * compartment (in particular, every individual module, frame,
+   * sandbox). Note that this makes measurements noticeably slower.
+   */
+  bool mIsMonitoringPerCompartment;
+
+
+  /**********************************************************
+   *
+   * Determining whether jank is user-visible.
+   */
+
+  /**
+   * `true` if we believe that any slowdown can cause a noticeable
+   * delay in handling user-input.
+   *
+   * In the current implementation, we return `true` if the latest
+   * user input was less than MAX_DURATION_OF_INTERACTION_MS ago. This
+   * includes all inputs (mouse, keyboard, other devices), with the
+   * exception of mousemove.
+   */
+  bool IsHandlingUserInput();
+
+
+public:
+  /**********************************************************
+   *
+   * Letting observers register themselves to watch for performance
+   * alerts.
+   *
+   * To avoid saturating clients with alerts (or even creating loops
+   * of alerts), each alert is buffered. At the end of each iteration
+   * of the event loop, groups that have caused performance alerts
+   * are registered in a set of pending alerts, and the collection
+   * timer hasn't been started yet, it is started. Once the timer
+   * firers, we gather all the pending alerts, empty the set and
+   * dispatch to observers.
+   */
+
+  /**
+   * Clear the set of pending alerts and dispatch the pending alerts
+   * to observers.
+   */
+  void NotifyJankObservers(const mozilla::Vector<uint64_t>& previousJankLevels);
+
+private:
+  /**
+   * The set of groups for which we know that an alert should be
+   * raised. This set is cleared once `mPendingAlertsCollector`
+   * fires.
+   *
+   * Invariant: no group may appear twice in this vector.
+   */
+  GroupVector mPendingAlerts;
+
+  /**
+   * A timer callback in charge of collecting the groups in
+   * `mPendingAlerts` and triggering `NotifyJankObservers` to dispatch
+   * performance alerts.
+   */
+  RefPtr<class PendingAlertsCollector> mPendingAlertsCollector;
+
+
+  /**
+   * Observation targets that are not attached to a specific group.
+   */
+  struct UniversalTargets {
+    UniversalTargets();
+    /**
+     * A target for observers interested in watching all addons.
+     */
+    RefPtr<nsPerformanceObservationTarget> mAddons;
+
+    /**
+     * A target for observers interested in watching all windows.
+     */
+    RefPtr<nsPerformanceObservationTarget> mWindows;
+  };
+  UniversalTargets mUniversalTargets;
+
+  /**
+   * The threshold, in microseconds, above which a performance group is
+   * considered "slow" and should raise performance alerts.
+   */
+  uint64_t mJankAlertThreshold;
+
+  /**
+   * A buffering delay, in milliseconds, used by the service to
+   * regroup performance alerts, before observers are actually
+   * noticed. Higher delays let the system avoid redundant
+   * notifications for the same group, and are generally better for
+   * performance.
+   */
+  uint32_t mJankAlertBufferingDelay;
+
+  /**
+   * The threshold above which jank, as reported by the refresh drivers,
+   * is considered user-visible.
+   *
+   * A value of n means that any jank above 2^n ms will be considered
+   * user visible.
+   */
+  short mJankLevelVisibilityThreshold;
+
+  /**
+   * The number of microseconds during which we assume that a
+   * user-interaction can keep the code jank-critical. Any user
+   * interaction that lasts longer than this duration is expected to
+   * either have already caused jank or have caused a nested event
+   * loop.
+   *
+   * In either case, we consider that monitoring
+   * jank-during-interaction after this duration is useless.
+   */
+  uint64_t mMaxExpectedDurationOfInteractionUS;
+};
+
+
+
+/**
+ * Container for performance data.
+ *
+ * All values are monotonic.
+ *
+ * All values are updated after running to completion.
+ */
+struct PerformanceData {
+  /**
+   * Number of times we have spent at least 2^n consecutive
+   * milliseconds executing code in this group.
+   * durations[0] is increased whenever we spend at least 1 ms
+   * executing code in this group
+   * durations[1] whenever we spend 2ms+
+   * ...
+   * durations[i] whenever we spend 2^ims+
+   */
+  uint64_t mDurations[10];
+
+  /**
+   * Total amount of time spent executing code in this group, in
+   * microseconds.
+   */
+  uint64_t mTotalUserTime;
+  uint64_t mTotalSystemTime;
+  uint64_t mTotalCPOWTime;
+
+  /**
+   * Total number of times code execution entered this group, since
+   * process launch. This may be greater than the number of times we
+   * have entered the event loop.
+   */
+  uint64_t mTicks;
+
+  PerformanceData();
+  PerformanceData(const PerformanceData& from) = default;
+  PerformanceData& operator=(const PerformanceData& from) = default;
+};
+
+
+
+/**
+ * Identification information for an item that can hold performance
+ * data.
+ */
+class nsPerformanceGroupDetails final: public nsIPerformanceGroupDetails {
+public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPERFORMANCEGROUPDETAILS
+
+  nsPerformanceGroupDetails(const nsAString& aName,
+                            const nsAString& aGroupId,
+                            const nsAString& aAddonId,
+                            const uint64_t aWindowId,
+                            const uint64_t aProcessId,
+                            const bool aIsSystem)
+    : mName(aName)
+    , mGroupId(aGroupId)
+    , mAddonId(aAddonId)
+    , mWindowId(aWindowId)
+    , mProcessId(aProcessId)
+    , mIsSystem(aIsSystem)
+  { }
+public:
+  const nsAString& Name() const;
+  const nsAString& GroupId() const;
+  const nsAString& AddonId() const;
+  uint64_t WindowId() const;
+  uint64_t ProcessId() const;
+  bool IsAddon() const;
+  bool IsWindow() const;
+  bool IsSystem() const;
+  bool IsContentProcess() const;
+private:
+  ~nsPerformanceGroupDetails() {}
+
+  const nsString mName;
+  const nsString mGroupId;
+  const nsString mAddonId;
+  const uint64_t mWindowId;
+  const uint64_t mProcessId;
+  const bool mIsSystem;
+};
+
+/**
+ * The kind of compartments represented by this group.
+ */
+enum class PerformanceGroupScope {
+  /**
+   * This group represents the entire runtime (i.e. the thread).
+   */
+  RUNTIME,
+
+  /**
+   * This group represents all the compartments executed in a window.
+   */
+  WINDOW,
+
+  /**
+   * This group represents all the compartments provided by an addon.
+   */
+  ADDON,
+
+  /**
+   * This group represents a single compartment.
+   */
+  COMPARTMENT,
+};
+
+/**
+ * A concrete implementation of `js::PerformanceGroup`, also holding
+ * performance data. Instances may represent individual compartments,
+ * windows, addons or the entire runtime.
+ *
+ * This class is intended to be the sole implementation of
+ * `js::PerformanceGroup`.
+ */
+class nsPerformanceGroup final: public js::PerformanceGroup {
+public:
+
+  // Ideally, we would define the enum class in nsPerformanceGroup,
+  // but this seems to choke some versions of gcc.
+  typedef PerformanceGroupScope GroupScope;
+
+  /**
+   * Construct a performance group.
+   *
+   * @param cx The container context. Used to generate a unique identifier.
+   * @param service The performance service. Used during destruction to
+   *   cleanup the hash tables.
+   * @param name A name for the group, designed mostly for debugging purposes,
+   *   so it should be at least somewhat human-readable.
+   * @param addonId The identifier of the add-on. Should be "" when the
+   *   group is not part of an add-on,
+   * @param windowId The identifier of the window. Should be 0 when the
+   *   group is not part of a window.
+   * @param processId A unique identifier for the process.
+   * @param isSystem `true` if the code of the group is executed with
+   *   system credentials, `false` otherwise.
+   * @param scope the scope of this group.
+   */
+  static nsPerformanceGroup*
+    Make(JSContext* cx,
+         nsPerformanceStatsService* service,
+         const nsAString& name,
+         const nsAString& addonId,
+         uint64_t windowId,
+         uint64_t processId,
+         bool isSystem,
+         GroupScope scope);
+
+  /**
+   * Utility: type-safer conversion from js::PerformanceGroup to nsPerformanceGroup.
+   */
+  static inline nsPerformanceGroup* Get(js::PerformanceGroup* self) {
+    return static_cast<nsPerformanceGroup*>(self);
+  }
+  static inline const nsPerformanceGroup* Get(const js::PerformanceGroup* self) {
+    return static_cast<const nsPerformanceGroup*>(self);
+  }
+
+  /**
+   * The performance data committed to this group.
+   */
+  PerformanceData data;
+
+  /**
+   * The scope of this group. Used to determine whether the group
+   * should be (de)activated.
+   */
+  GroupScope Scope() const;
+
+  /**
+   * Identification details for this group.
+   */
+  nsPerformanceGroupDetails* Details() const;
+
+  /**
+   * Cleanup any references.
+   */
+  void Dispose();
+
+  /**
+   * Set the observation target for this group.
+   *
+   * This method must be called exactly once, when the performance
+   * group is attached to its `nsGroupHolder`.
+   */
+  void SetObservationTarget(nsPerformanceObservationTarget*);
+
+
+  /**
+   * `true` if we have already noticed that a performance alert should
+   * be raised for this group but we have not dispatched it yet,
+   * `false` otherwise.
+   */
+  bool HasPendingAlert() const;
+  void SetHasPendingAlert(bool value);
+
+protected:
+  nsPerformanceGroup(nsPerformanceStatsService* service,
+                     const nsAString& name,
+                     const nsAString& groupId,
+                     const nsAString& addonId,
+                     uint64_t windowId,
+                     uint64_t processId,
+                     bool isSystem,
+                     GroupScope scope);
+
+
+  /**
+   * Virtual implementation of `delete`, to make sure that objects are
+   * destoyed with an implementation of `delete` compatible with the
+   * implementation of `new` used to allocate them.
+   *
+   * Called by SpiderMonkey.
+   */
+  virtual void Delete() override {
+    delete this;
+  }
+  ~nsPerformanceGroup();
+
+private:
+  /**
+   * Identification details for this group.
+   */
+  RefPtr<nsPerformanceGroupDetails> mDetails;
+
+  /**
+   * The stats service. Used to perform cleanup during destruction.
+   */
+  RefPtr<nsPerformanceStatsService> mService;
+
+  /**
+   * The scope of this group. Used to determine whether the group
+   * should be (de)activated.
+   */
+  const GroupScope mScope;
+
+// Observing performance alerts.
+
+public:
+  /**
+   * The observation target, used to register observers.
+   */
+  nsPerformanceObservationTarget* ObservationTarget() const;
+
+  /**
+   * Record a jank duration.
+   *
+   * Update the highest recent jank if necessary.
+   */
+  void RecordJank(uint64_t jank);
+  uint64_t HighestRecentJank();
+
+  /**
+   * Record a CPOW duration.
+   *
+   * Update the highest recent CPOW if necessary.
+   */
+  void RecordCPOW(uint64_t cpow);
+  uint64_t HighestRecentCPOW();
+
+  /**
+   * Record that this group has recently been involved in handling
+   * user input. Note that heuristics are involved here, so the
+   * result is not 100% accurate.
+   */
+  void RecordUserInput();
+  bool HasRecentUserInput();
+
+  /**
+   * Reset recent values (recent highest CPOW and jank, involvement in
+   * user input).
+   */
+  void ResetRecent();
+private:
+  /**
+   * The target used by observers to register for watching slow
+   * performance alerts caused by this group.
+   *
+   * May be nullptr for groups that cannot be watched (the top group).
+   */
+  RefPtr<class nsPerformanceObservationTarget> mObservationTarget;
+
+  /**
+   * The highest jank encountered since jank observers for this group
+   * were last called, in microseconds.
+   */
+  uint64_t mHighestJank;
+
+  /**
+   * The highest CPOW encountered since jank observers for this group
+   * were last called, in microseconds.
+   */
+  uint64_t mHighestCPOW;
+
+  /**
+   * `true` if this group has been involved in handling user input,
+   * `false` otherwise.
+   *
+   * Note that we use heuristics to determine whether a group is
+   * involved in handling user input, so this value is not 100%
+   * accurate.
+   */
+  bool mHasRecentUserInput;
+
+  /**
+   * `true` if this group has caused a performance alert and this alert
+   * hasn't been dispatched yet.
+   *
+   * We use this as part of the buffering of performance alerts. If
+   * the group generates several alerts several times during the
+   * buffering delay, we only wish to add the group once to the list
+   * of alerts.
+   */
+  bool mHasPendingAlert;
+};
+
+#endif