Adding upstream version 124.0.1.upstream/124.0.1

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

6 files changed, 748 insertions, 0 deletions

diff --git a/toolkit/components/glean/xpcom/FOG.cpp b/toolkit/components/glean/xpcom/FOG.cpp
new file mode 100644
index 0000000000..3673b23707
--- /dev/null
+++ b/toolkit/components/glean/xpcom/FOG.cpp
@@ -0,0 +1,433 @@
+/* -*- 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 "mozilla/FOG.h"
+
+#include "mozilla/AppShutdown.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/FOGIPC.h"
+#include "mozilla/browser/NimbusFeatures.h"
+#include "mozilla/glean/bindings/Common.h"
+#include "mozilla/glean/bindings/jog/jog_ffi_generated.h"
+#include "mozilla/glean/fog_ffi_generated.h"
+#include "mozilla/glean/GleanMetrics.h"
+#include "mozilla/Logging.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/ShutdownPhase.h"
+#include "mozilla/Unused.h"
+#include "nsContentUtils.h"
+#include "nsIFOG.h"
+#include "nsIUserIdleService.h"
+#include "nsServiceManagerUtils.h"
+#include "xpcpublic.h"
+
+namespace mozilla {
+
+using mozilla::LogLevel;
+static mozilla::LazyLogModule sLog("fog");
+
+using glean::LogToBrowserConsole;
+
+#ifdef MOZ_GLEAN_ANDROID
+// Defined by `glean-core`. We reexport it here for later use.
+extern "C" NS_EXPORT void glean_enable_logging(void);
+
+// Workaround to force a re-export of the `no_mangle` symbols from `glean-core`
+//
+// Due to how linking works and hides symbols the symbols from `glean-core`
+// might not be re-exported and thus not usable. By forcing use of _at least
+// one_ symbol in an exported function the functions will also be rexported.
+//
+// See also https://github.com/rust-lang/rust/issues/50007
+extern "C" NS_EXPORT void _fog_force_reexport_donotcall(void) {
+  glean_enable_logging();
+}
+#endif
+
+static StaticRefPtr<FOG> gFOG;
+static mozilla::Atomic<bool> gInitializeCalled(false);
+
+// We wait for 5s of idle before dumping IPC and flushing ping data to disk.
+// This number hasn't been tuned, so if you have a reason to change it,
+// please by all means do.
+const uint32_t kIdleSecs = 5;
+
+// static
+already_AddRefed<FOG> FOG::GetSingleton() {
+  if (gFOG) {
+    return do_AddRef(gFOG);
+  }
+
+  MOZ_LOG(sLog, LogLevel::Debug, ("FOG::GetSingleton()"));
+
+  gFOG = new FOG();
+
+  if (XRE_IsParentProcess()) {
+    nsresult rv;
+    nsCOMPtr<nsIUserIdleService> idleService =
+        do_GetService("@mozilla.org/widget/useridleservice;1", &rv);
+    NS_ENSURE_SUCCESS(rv, nullptr);
+    MOZ_ASSERT(idleService);
+    if (NS_WARN_IF(NS_FAILED(idleService->AddIdleObserver(gFOG, kIdleSecs)))) {
+      glean::fog::failed_idle_registration.Set(true);
+    }
+
+    RunOnShutdown(
+        [&] {
+          nsresult rv;
+          nsCOMPtr<nsIUserIdleService> idleService =
+              do_GetService("@mozilla.org/widget/useridleservice;1", &rv);
+          if (NS_SUCCEEDED(rv)) {
+            MOZ_ASSERT(idleService);
+            Unused << idleService->RemoveIdleObserver(gFOG, kIdleSecs);
+          }
+          if (!gInitializeCalled) {
+            gInitializeCalled = true;
+            // Assuming default data path and application id.
+            // Consumers using non defaults _must_ initialize FOG explicitly.
+            MOZ_LOG(sLog, LogLevel::Debug,
+                    ("Init not called. Init-ing in shutdown"));
+            glean::fog::inits_during_shutdown.Add(1);
+            // It's enough to call init before shutting down.
+            // We don't need to (and can't) wait for it to complete.
+            glean::impl::fog_init(&VoidCString(), &VoidCString());
+          }
+          gFOG->Shutdown();
+          gFOG = nullptr;
+        },
+        ShutdownPhase::XPCOMShutdown);
+  }
+  return do_AddRef(gFOG);
+}
+
+void FOG::Shutdown() {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  glean::impl::fog_shutdown();
+}
+
+// This allows us to know it's too late to submit a ping in Rust.
+extern "C" bool FOG_TooLateToSend(void) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  return AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdownNetTeardown);
+}
+
+// This allows us to pass the configurable maximum ping limit (in pings per
+// minute) to Rust. Default value is 15.
+extern "C" uint32_t FOG_MaxPingLimit(void) {
+  return NimbusFeatures::GetInt("gleanInternalSdk"_ns,
+                                "gleanMaxPingsPerMinute"_ns, 15);
+}
+
+// This allows us to pass whether to enable precise event timestamps to Rust.
+// Default is false.
+extern "C" bool FOG_EventTimestampsEnabled(void) {
+  return NimbusFeatures::GetBool("gleanInternalSdk"_ns,
+                                 "enableEventTimestamps"_ns, false);
+}
+
+// Called when knowing if we're in automation is necessary.
+extern "C" bool FOG_IPCIsInAutomation(void) { return xpc::IsInAutomation(); }
+
+NS_IMETHODIMP
+FOG::InitializeFOG(const nsACString& aDataPathOverride,
+                   const nsACString& aAppIdOverride) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  gInitializeCalled = true;
+  RunOnShutdown(
+      [&] {
+        if (NimbusFeatures::GetBool("gleanInternalSdk"_ns, "finalInactive"_ns,
+                                    false)) {
+          glean::impl::fog_internal_glean_handle_client_inactive();
+        }
+      },
+      ShutdownPhase::AppShutdownConfirmed);
+
+  return glean::impl::fog_init(&aDataPathOverride, &aAppIdOverride);
+}
+
+NS_IMETHODIMP
+FOG::RegisterCustomPings() {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  glean::impl::fog_register_pings();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+FOG::SetLogPings(bool aEnableLogPings) {
+#ifdef MOZ_GLEAN_ANDROID
+  return NS_OK;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  return glean::impl::fog_set_log_pings(aEnableLogPings);
+#endif
+}
+
+NS_IMETHODIMP
+FOG::SetTagPings(const nsACString& aDebugTag) {
+#ifdef MOZ_GLEAN_ANDROID
+  return NS_OK;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  return glean::impl::fog_set_debug_view_tag(&aDebugTag);
+#endif
+}
+
+NS_IMETHODIMP
+FOG::SendPing(const nsACString& aPingName) {
+#ifdef MOZ_GLEAN_ANDROID
+  return NS_OK;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  return glean::impl::fog_submit_ping(&aPingName);
+#endif
+}
+
+NS_IMETHODIMP
+FOG::SetExperimentActive(const nsACString& aExperimentId,
+                         const nsACString& aBranch, JS::HandleValue aExtra,
+                         JSContext* aCx) {
+#ifdef MOZ_GLEAN_ANDROID
+  NS_WARNING("Don't set experiments from Gecko in Android. Ignoring.");
+  return NS_OK;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  nsTArray<nsCString> extraKeys;
+  nsTArray<nsCString> extraValues;
+  if (!aExtra.isNullOrUndefined()) {
+    JS::RootedObject obj(aCx, &aExtra.toObject());
+    JS::Rooted<JS::IdVector> keys(aCx, JS::IdVector(aCx));
+    if (!JS_Enumerate(aCx, obj, &keys)) {
+      LogToBrowserConsole(nsIScriptError::warningFlag,
+                          u"Failed to enumerate experiment extras object."_ns);
+      return NS_OK;
+    }
+
+    for (size_t i = 0, n = keys.length(); i < n; i++) {
+      nsAutoJSCString jsKey;
+      if (!jsKey.init(aCx, keys[i])) {
+        LogToBrowserConsole(
+            nsIScriptError::warningFlag,
+            u"Extra dictionary should only contain string keys."_ns);
+        return NS_OK;
+      }
+
+      JS::Rooted<JS::Value> value(aCx);
+      if (!JS_GetPropertyById(aCx, obj, keys[i], &value)) {
+        LogToBrowserConsole(nsIScriptError::warningFlag,
+                            u"Failed to get experiment extra property."_ns);
+        return NS_OK;
+      }
+
+      nsAutoJSCString jsValue;
+      if (!value.isString()) {
+        LogToBrowserConsole(
+            nsIScriptError::warningFlag,
+            u"Experiment extra properties must have string values."_ns);
+        return NS_OK;
+      }
+
+      if (!jsValue.init(aCx, value)) {
+        LogToBrowserConsole(nsIScriptError::warningFlag,
+                            u"Can't extract experiment extra property"_ns);
+        return NS_OK;
+      }
+
+      extraKeys.AppendElement(jsKey);
+      extraValues.AppendElement(jsValue);
+    }
+  }
+  glean::impl::fog_set_experiment_active(&aExperimentId, &aBranch, &extraKeys,
+                                         &extraValues);
+  return NS_OK;
+#endif
+}
+
+NS_IMETHODIMP
+FOG::SetExperimentInactive(const nsACString& aExperimentId) {
+#ifdef MOZ_GLEAN_ANDROID
+  NS_WARNING("Don't unset experiments from Gecko in Android. Ignoring.");
+  return NS_OK;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  glean::impl::fog_set_experiment_inactive(&aExperimentId);
+  return NS_OK;
+#endif
+}
+
+NS_IMETHODIMP
+FOG::TestGetExperimentData(const nsACString& aExperimentId, JSContext* aCx,
+                           JS::MutableHandleValue aResult) {
+#ifdef MOZ_GLEAN_ANDROID
+  NS_WARNING("Don't test experiments from Gecko in Android. Throwing.");
+  aResult.set(JS::UndefinedValue());
+  return NS_ERROR_FAILURE;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  if (!glean::impl::fog_test_is_experiment_active(&aExperimentId)) {
+    aResult.set(JS::UndefinedValue());
+    return NS_OK;
+  }
+
+  // We could struct-up the branch and extras and do what
+  // EventMetric::TestGetValue does... but keeping allocation on this side feels
+  // cleaner to me at the moment.
+  nsCString branch;
+  nsTArray<nsCString> extraKeys;
+  nsTArray<nsCString> extraValues;
+
+  glean::impl::fog_test_get_experiment_data(&aExperimentId, &branch, &extraKeys,
+                                            &extraValues);
+  MOZ_ASSERT(extraKeys.Length() == extraValues.Length());
+
+  JS::RootedObject jsExperimentDataObj(aCx, JS_NewPlainObject(aCx));
+  if (NS_WARN_IF(!jsExperimentDataObj)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  JS::RootedValue jsBranchStr(aCx);
+  if (!dom::ToJSValue(aCx, branch, &jsBranchStr) ||
+      !JS_DefineProperty(aCx, jsExperimentDataObj, "branch", jsBranchStr,
+                         JSPROP_ENUMERATE)) {
+    NS_WARNING("Failed to define branch for experiment data object.");
+    return NS_ERROR_FAILURE;
+  }
+
+  JS::RootedObject jsExtraObj(aCx, JS_NewPlainObject(aCx));
+  if (!JS_DefineProperty(aCx, jsExperimentDataObj, "extra", jsExtraObj,
+                         JSPROP_ENUMERATE)) {
+    NS_WARNING("Failed to define extra for experiment data object.");
+    return NS_ERROR_FAILURE;
+  }
+
+  for (unsigned int i = 0; i < extraKeys.Length(); i++) {
+    JS::RootedValue jsValueStr(aCx);
+    if (!dom::ToJSValue(aCx, extraValues[i], &jsValueStr) ||
+        !JS_DefineProperty(aCx, jsExtraObj, extraKeys[i].Data(), jsValueStr,
+                           JSPROP_ENUMERATE)) {
+      NS_WARNING("Failed to define extra property for experiment data object.");
+      return NS_ERROR_FAILURE;
+    }
+  }
+  aResult.setObject(*jsExperimentDataObj);
+  return NS_OK;
+#endif
+}
+
+NS_IMETHODIMP
+FOG::SetMetricsFeatureConfig(const nsACString& aJsonConfig) {
+#ifdef MOZ_GLEAN_ANDROID
+  NS_WARNING(
+      "Don't set metric feature configs from Gecko in Android. Ignoring.");
+  return NS_OK;
+#else
+  MOZ_ASSERT(XRE_IsParentProcess());
+  glean::impl::fog_set_metrics_feature_config(&aJsonConfig);
+  return NS_OK;
+#endif
+}
+
+NS_IMETHODIMP
+FOG::TestFlushAllChildren(JSContext* aCx, mozilla::dom::Promise** aOutPromise) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  NS_ENSURE_ARG(aOutPromise);
+  *aOutPromise = nullptr;
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  if (NS_WARN_IF(!global)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  ErrorResult erv;
+  RefPtr<dom::Promise> promise = dom::Promise::Create(global, erv);
+  if (NS_WARN_IF(erv.Failed())) {
+    return erv.StealNSResult();
+  }
+
+  glean::FlushAndUseFOGData()->Then(
+      GetCurrentSerialEventTarget(), __func__,
+      [promise]() { promise->MaybeResolveWithUndefined(); });
+
+  promise.forget(aOutPromise);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+FOG::Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // On idle, opportunistically flush child process data to the parent,
+  // then persist ping-lifetime data to the db.
+  if (!strcmp(aTopic, OBSERVER_TOPIC_IDLE)) {
+    glean::FlushAndUseFOGData();
+#ifndef MOZ_GLEAN_ANDROID
+    Unused << glean::impl::fog_persist_ping_lifetime_data();
+#endif
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+FOG::TestResetFOG(const nsACString& aDataPathOverride,
+                  const nsACString& aAppIdOverride) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  return glean::impl::fog_test_reset(&aDataPathOverride, &aAppIdOverride);
+}
+
+NS_IMETHODIMP
+FOG::TestTriggerMetrics(uint32_t aProcessType, JSContext* aCx,
+                        mozilla::dom::Promise** aOutPromise) {
+  MOZ_ASSERT(XRE_IsParentProcess());
+  NS_ENSURE_ARG(aOutPromise);
+  *aOutPromise = nullptr;
+  nsIGlobalObject* global = xpc::CurrentNativeGlobal(aCx);
+  if (NS_WARN_IF(!global)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  ErrorResult erv;
+  RefPtr<dom::Promise> promise = dom::Promise::Create(global, erv);
+  if (NS_WARN_IF(erv.Failed())) {
+    return erv.StealNSResult();
+  }
+
+  glean::TestTriggerMetrics(aProcessType, promise);
+
+  promise.forget(aOutPromise);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+FOG::TestRegisterRuntimeMetric(
+    const nsACString& aType, const nsACString& aCategory,
+    const nsACString& aName, const nsTArray<nsCString>& aPings,
+    const nsACString& aLifetime, const bool aDisabled,
+    const nsACString& aExtraArgs, uint32_t* aMetricIdOut) {
+  *aMetricIdOut = 0;
+  *aMetricIdOut = glean::jog::jog_test_register_metric(
+      &aType, &aCategory, &aName, &aPings, &aLifetime, aDisabled, &aExtraArgs);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+FOG::TestRegisterRuntimePing(const nsACString& aName,
+                             const bool aIncludeClientId,
+                             const bool aSendIfEmpty,
+                             const bool aPreciseTimestamps,
+                             const nsTArray<nsCString>& aReasonCodes,
+                             uint32_t* aPingIdOut) {
+  *aPingIdOut = 0;
+  *aPingIdOut =
+      glean::jog::jog_test_register_ping(&aName, aIncludeClientId, aSendIfEmpty,
+                                         aPreciseTimestamps, &aReasonCodes);
+  return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(FOG, nsIFOG, nsIObserver)
+
+}  //  namespace mozilla
diff --git a/toolkit/components/glean/xpcom/FOG.h b/toolkit/components/glean/xpcom/FOG.h
new file mode 100644
index 0000000000..55e155052e
--- /dev/null
+++ b/toolkit/components/glean/xpcom/FOG.h
@@ -0,0 +1,29 @@
+/* -*- 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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_FOG_h
+#define mozilla_FOG_h
+
+#include "nsIFOG.h"
+#include "nsIObserver.h"
+
+namespace mozilla {
+class FOG final : public nsIFOG, public nsIObserver {
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSIFOG
+  NS_DECL_NSIOBSERVER
+
+ public:
+  FOG() = default;
+  static already_AddRefed<FOG> GetSingleton();
+
+ private:
+  ~FOG() = default;
+  void Shutdown();
+};
+
+};  // namespace mozilla
+
+#endif  // mozilla_FOG_h
diff --git a/toolkit/components/glean/xpcom/components.conf b/toolkit/components/glean/xpcom/components.conf
new file mode 100644
index 0000000000..b5a86537c0
--- /dev/null
+++ b/toolkit/components/glean/xpcom/components.conf
@@ -0,0 +1,18 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+Classes = [
+    {
+        'cid': '{98d0e975-9cad-4ce3-ae2f-f878b8be6307}',
+        'contract_ids': ['@mozilla.org/toolkit/glean;1'],
+        'singleton': True,
+        'type': 'mozilla::FOG',
+        'headers': ['mozilla/FOG.h'],
+        'constructor': 'mozilla::FOG::GetSingleton',
+        'js_name': 'fog',
+        'interfaces': ['nsIFOG'],
+    }
+]
diff --git a/toolkit/components/glean/xpcom/moz.build b/toolkit/components/glean/xpcom/moz.build
new file mode 100644
index 0000000000..0d967ff564
--- /dev/null
+++ b/toolkit/components/glean/xpcom/moz.build
@@ -0,0 +1,27 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+FINAL_LIBRARY = "xul"
+
+EXPORTS.mozilla += [
+    "FOG.h",
+]
+
+UNIFIED_SOURCES += [
+    "FOG.cpp",
+]
+
+XPCOM_MANIFESTS += ["components.conf"]
+
+XPIDL_MODULE = "fog"
+
+XPIDL_SOURCES += [
+    "nsIFOG.idl",
+    "nsIGleanPing.idl",
+]
+
+with Files("**"):
+    BUG_COMPONENT = ("Toolkit", "Telemetry")
diff --git a/toolkit/components/glean/xpcom/nsIFOG.idl b/toolkit/components/glean/xpcom/nsIFOG.idl
new file mode 100644
index 0000000000..682df85f1a
--- /dev/null
+++ b/toolkit/components/glean/xpcom/nsIFOG.idl
@@ -0,0 +1,190 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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 "nsISupports.idl"
+
+[scriptable, uuid(98d0e975-9cad-4ce3-ae2f-f878b8be6307)]
+interface nsIFOG : nsISupports
+{
+  /**
+   * Initialize FOG.
+   *
+   * Call it eventually. Metric data recorded beforehand will be buffered.
+   *
+   * @param aDataPathOverride - The path of a custom Glean data path to use
+   *        instead of the profile dir.
+   * @param aAppIdOverride - The application_id to use instead of
+   *        "firefox.desktop".
+   */
+  void initializeFOG([optional] in AUTF8String aDataPathOverride, [optional] in AUTF8String aAppIdOverride);
+
+  /**
+   * Register custom pings.
+   *
+   * Ensure all custom pings are registered with Glean.
+   */
+  void registerCustomPings();
+
+  /**
+   * Enable or Disable the logging of pings in the Glean SDK.
+   * See https://firefox-source-docs.mozilla.org/toolkit/components/glean/dev/testing.html
+   * for details.
+   *
+   * @param aEnableLogPings - true to enable logging, false to disable.
+   */
+  void setLogPings(in boolean aEnableLogPings);
+
+  /**
+   * Set the tag to be applied to pings assembled from now on.
+   * See https://firefox-source-docs.mozilla.org/toolkit/components/glean/dev/testing.html
+   * for details.
+   *
+   * @param aDebugTag - The string tag to apply.
+   *                    If it cannot be applied (e.g it contains characters that are
+   *                    forbidden in HTTP headers) the old value will remain.
+   */
+  void setTagPings(in ACString aDebugTag);
+
+  /**
+   * Send the named ping.
+   * See https://firefox-source-docs.mozilla.org/toolkit/components/glean/dev/testing.html
+   * for details.
+   *
+   * @param aPingName - The name of the ping to send. If no ping of that name
+   *                    exists, or the ping is known but cannot be assembled
+   *                    (e.g if it is empty), no ping will be sent.
+   */
+  void sendPing(in ACString aPingName);
+
+  /**
+   * Indicate that an experiment is running.
+   * Glean will add an experiment annotation which is sent with pings.
+   * This information is not persisted between runs.
+   *
+   * See `glean_core::Glean::set_experiment_active`.
+   *
+   * Logs on error, but does not throw.
+   *
+   * @param aExperimentId - The id/slug of the experiment.
+   * @param aBranch - The name of the active branch of the experiment.
+   * @param aExtra - Optional string -> string dictionary of extra information.
+   */
+  [implicit_jscontext]
+  void setExperimentActive(in ACString aExperimentId, in ACString aBranch, [optional] in jsval aExtra);
+
+  /**
+   * Indicate that an experiment is no longer running.
+   *
+   * See `glean_core::Glean::set_experiment_inactive`.
+   *
+   * Logs on error, but does not throw.
+   *
+   * @param aExperimentId - The id/slug of the experiment from setExperimentActive.
+   */
+  void setExperimentInactive(in ACString aExperimentId);
+
+  /**
+   * **Test-only API**
+   *
+   * If the identified experiment was set active and hasn't been set inactive,
+   * this will give you the active branch and extra information.
+   *
+   * @param aExperimentId - The id/slug of the experiment from setExperimentActive.
+   *
+   * @return an object of the form
+   *         {branch: "branch-name", extra: {extra_key1: extra_value1, ...}}
+   *         if there is an active experiment. Undefined, otherwise.
+   */
+  [implicit_jscontext]
+  jsval testGetExperimentData(in ACString aExperimentId);
+
+  /**
+   * Set remote-configuration for metrics' disabled property.
+   *
+   * See [`glean_core::Glean::set_metrics_enabled_config`]
+   *
+   * Logs on error, but does not throw.
+   *
+   * @param aJsonConfig - The stringified JSON object in the form
+   *        {metric_base_identifier: boolean,}
+   *        which may contain multiple metric object entries.
+   */
+  void setMetricsFeatureConfig(in ACString aJsonConfig);
+
+  /**
+   * ** Test-only Method **
+   *
+   * Flush all data from all child processes.
+   *
+   * @returns A promise that resolves when the data's been stored.
+   */
+  [implicit_jscontext]
+  Promise testFlushAllChildren();
+
+  /**
+   * ** Test-only Method **
+   *
+   * Reset FOG and the Glean SDK, clearing storage.
+   */
+  void testResetFOG([optional] in AUTF8String aDataPathOverride, [optional] in AUTF8String aAppIdOverride);
+
+  /**
+   * ** Test-only Method **
+   *
+   * Trigger test metric instrumentation on the GPU, RDD or Socket process.
+   *
+   * @param aProcessType - A PROCESS_TYPE_* value from the constants defined
+   *                       in the nsIXULRuntime interface.
+   *
+   * @returns A promise that resolves when the test data has been added.
+   *          The promise will be rejected if the process type is not supported
+   *          or if sending the IPC to the child process fails.
+   */
+  [implicit_jscontext]
+  Promise testTriggerMetrics(in unsigned long aProcessType);
+
+  /**
+   * ** Test-only Method **
+   *
+   * Register a metric.
+   *
+   * This function is deliberately not too friendly to use. You probably aren't
+   * supposed to use it unless you're testing metric registration itself.
+   *
+   * @param aType - The metric's type.
+   * @param aCategory - The metric's category.
+   * @param aName - The metric's name.
+   * @param aPings - The pings to send it in.
+   * @param aLifetime - The metric's lifetime.
+   * @param aDisabled - Whether the metric, though existing, isn't enabled.
+   * @param aExtraArgs - Optional JSON string of extra args.
+   */
+  uint32_t testRegisterRuntimeMetric(in ACString aType,
+                                 in ACString aCategory,
+                                 in ACString aName,
+                                 in Array<ACString> aPings,
+                                 in ACString aLifetime,
+                                 in boolean aDisabled,
+                                 [optional] in ACString aExtraArgs);
+
+  /**
+   * ** Test-only Method **
+   *
+   * Register a ping.
+   *
+   * This function is deliberately not too friendly to use. You probably aren't
+   * supposed to use it unless you're testing ping registration itself.
+   *
+   * @param aName - The ping's name.
+   * @param aIncludeClientId - Whether the ping should include the client_id.
+   * @param aSendIfEmpty - Whether the ping should send even if empty.
+   * @param aReasonCodes - The list of valid reasons for ping submission.
+   */
+  uint32_t testRegisterRuntimePing(in ACString aName,
+                                   in boolean aIncludeClientId,
+                                   in boolean aSendIfEmpty,
+                                   in boolean aPreciseTimestamps,
+                                   in Array<ACString> aReasonCodes);
+};
diff --git a/toolkit/components/glean/xpcom/nsIGleanPing.idl b/toolkit/components/glean/xpcom/nsIGleanPing.idl
new file mode 100644
index 0000000000..59d1aa8453
--- /dev/null
+++ b/toolkit/components/glean/xpcom/nsIGleanPing.idl
@@ -0,0 +1,51 @@
+/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
+/* 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 "nsISupports.idl"
+
+[scriptable, function, uuid(e5447f62-4b03-497c-81e9-6ab683d20380)]
+interface nsIGleanPingTestCallback : nsISupports
+{
+  void call(in ACString aReason);
+};
+
+[scriptable, uuid(5223a48b-687d-47ff-a629-fd4a72d1ecfa)]
+interface nsIGleanPing : nsISupports
+{
+  /**
+   * Collect and submit the ping for eventual upload.
+   *
+   * This will collect all stored data to be included in the ping.
+   * Data with lifetime `ping` will then be reset.
+   *
+   * If the ping is configured with `send_if_empty = false`
+   * and the ping currently contains no content,
+   * it will not be queued for upload.
+   * If the ping is configured with `send_if_empty = true`
+   * it will be queued for upload even if empty.
+   *
+   * Pings always contain the `ping_info` and `client_info` sections.
+   * See [ping sections](https://mozilla.github.io/glean/book/user/pings/index.html#ping-sections)
+   * for details.
+   *
+   * @param aReason - Optional. The reason the ping is being submitted.
+   *                  Must match one of the configured `reason_codes`.
+   */
+  void submit([optional] in ACString aReason);
+
+  /**
+   * **Test-only API**
+   *
+   * Register a callback to be called right before this ping is next submitted.
+   * The provided function is called exactly once before submitting.
+   *
+   * Note: The callback will be called on any call to submit.
+   * A ping might not be sent afterwards, e.g. if the ping is empty and
+   * `send_if_empty` is `false`.
+   *
+   * @param aCallback - The callback to call on the next submit.
+   */
+  void testBeforeNextSubmit(in nsIGleanPingTestCallback aCallback);
+};