From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 11:22:09 +0200
Subject: Adding upstream version 110.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 browser/modules/BrowserUsageTelemetry.jsm | 1381 +++++++++++++++++++++++++++++
 1 file changed, 1381 insertions(+)
 create mode 100644 browser/modules/BrowserUsageTelemetry.jsm

(limited to 'browser/modules/BrowserUsageTelemetry.jsm')

diff --git a/browser/modules/BrowserUsageTelemetry.jsm b/browser/modules/BrowserUsageTelemetry.jsm
new file mode 100644
index 0000000000..7d720062f9
--- /dev/null
+++ b/browser/modules/BrowserUsageTelemetry.jsm
@@ -0,0 +1,1381 @@
+/* -*- js-indent-level: 2; indent-tabs-mode: nil -*- */
+/* 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/. */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = [
+  "BrowserUsageTelemetry",
+  "getUniqueDomainsVisitedInPast24Hours",
+  "URICountListener",
+  "MINIMUM_TAB_COUNT_INTERVAL_MS",
+];
+
+const { XPCOMUtils } = ChromeUtils.importESModule(
+  "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+const { AppConstants } = ChromeUtils.importESModule(
+  "resource://gre/modules/AppConstants.sys.mjs"
+);
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ClientID: "resource://gre/modules/ClientID.sys.mjs",
+  PrivateBrowsingUtils: "resource://gre/modules/PrivateBrowsingUtils.sys.mjs",
+  SearchSERPTelemetry: "resource:///modules/SearchSERPTelemetry.sys.mjs",
+  clearInterval: "resource://gre/modules/Timer.sys.mjs",
+  clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+  setInterval: "resource://gre/modules/Timer.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  CustomizableUI: "resource:///modules/CustomizableUI.jsm",
+  PageActions: "resource:///modules/PageActions.jsm",
+  WindowsInstallsInfo:
+    "resource://gre/modules/components-utils/WindowsInstallsInfo.jsm",
+});
+
+// This pref is in seconds!
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "gRecentVisitedOriginsExpiry",
+  "browser.engagement.recent_visited_origins.expiry"
+);
+
+// The upper bound for the count of the visited unique domain names.
+const MAX_UNIQUE_VISITED_DOMAINS = 100;
+
+// Observed topic names.
+const TAB_RESTORING_TOPIC = "SSTabRestoring";
+const TELEMETRY_SUBSESSIONSPLIT_TOPIC =
+  "internal-telemetry-after-subsession-split";
+const DOMWINDOW_OPENED_TOPIC = "domwindowopened";
+
+// Probe names.
+const MAX_TAB_COUNT_SCALAR_NAME = "browser.engagement.max_concurrent_tab_count";
+const MAX_WINDOW_COUNT_SCALAR_NAME =
+  "browser.engagement.max_concurrent_window_count";
+const TAB_OPEN_EVENT_COUNT_SCALAR_NAME =
+  "browser.engagement.tab_open_event_count";
+const MAX_TAB_PINNED_COUNT_SCALAR_NAME =
+  "browser.engagement.max_concurrent_tab_pinned_count";
+const TAB_PINNED_EVENT_COUNT_SCALAR_NAME =
+  "browser.engagement.tab_pinned_event_count";
+const WINDOW_OPEN_EVENT_COUNT_SCALAR_NAME =
+  "browser.engagement.window_open_event_count";
+const UNIQUE_DOMAINS_COUNT_SCALAR_NAME =
+  "browser.engagement.unique_domains_count";
+const TOTAL_URI_COUNT_SCALAR_NAME = "browser.engagement.total_uri_count";
+const UNFILTERED_URI_COUNT_SCALAR_NAME =
+  "browser.engagement.unfiltered_uri_count";
+const TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE_SCALAR_NAME =
+  "browser.engagement.total_uri_count_normal_and_private_mode";
+
+const CONTENT_PROCESS_COUNT = "CONTENT_PROCESS_COUNT";
+const CONTENT_PROCESS_PRECISE_COUNT = "CONTENT_PROCESS_PRECISE_COUNT";
+
+const MINIMUM_TAB_COUNT_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes, in ms
+const CONTENT_PROCESS_COUNT_INTERVAL_MS = 5 * 60 * 1000;
+
+// The elements we consider to be interactive.
+const UI_TARGET_ELEMENTS = [
+  "menuitem",
+  "toolbarbutton",
+  "key",
+  "command",
+  "checkbox",
+  "input",
+  "button",
+  "image",
+  "radio",
+  "richlistitem",
+];
+
+// The containers of interactive elements that we care about and their pretty
+// names. These should be listed in order of most-specific to least-specific,
+// when iterating JavaScript will guarantee that ordering and so we will find
+// the most specific area first.
+const BROWSER_UI_CONTAINER_IDS = {
+  "toolbar-menubar": "menu-bar",
+  TabsToolbar: "tabs-bar",
+  PersonalToolbar: "bookmarks-bar",
+  "appMenu-popup": "app-menu",
+  tabContextMenu: "tabs-context",
+  contentAreaContextMenu: "content-context",
+  "widget-overflow-list": "overflow-menu",
+  "widget-overflow-fixed-list": "pinned-overflow-menu",
+  "page-action-buttons": "pageaction-urlbar",
+  pageActionPanel: "pageaction-panel",
+  "unified-extensions-area": "unified-extensions-area",
+
+  // This should appear last as some of the above are inside the nav bar.
+  "nav-bar": "nav-bar",
+};
+
+// A list of the expected panes in about:preferences
+const PREFERENCES_PANES = [
+  "paneHome",
+  "paneGeneral",
+  "panePrivacy",
+  "paneSearch",
+  "paneSearchResults",
+  "paneSync",
+  "paneContainers",
+  "paneExperimental",
+  "paneMoreFromMozilla",
+];
+
+const IGNORABLE_EVENTS = new WeakMap();
+
+const KNOWN_ADDONS = [];
+
+// Buttons that, when clicked, set a preference to true. The convention
+// is that the preference is named:
+//
+// browser.engagement.<button id>.has-used
+//
+// and is defaulted to false.
+const SET_USAGE_PREF_BUTTONS = [
+  "downloads-button",
+  "fxa-toolbar-menu-button",
+  "home-button",
+  "sidebar-button",
+  "library-button",
+];
+
+// Buttons that, when clicked, increase a counter. The convention
+// is that the preference is named:
+//
+// browser.engagement.<button id>.used-count
+//
+// and doesn't have a default value.
+const SET_USAGECOUNT_PREF_BUTTONS = [
+  "pageAction-panel-copyURL",
+  "pageAction-panel-emailLink",
+  "pageAction-panel-pinTab",
+  "pageAction-panel-screenshots_mozilla_org",
+  "pageAction-panel-shareURL",
+];
+
+function telemetryId(widgetId, obscureAddons = true) {
+  // Add-on IDs need to be obscured.
+  function addonId(id) {
+    if (!obscureAddons) {
+      return id;
+    }
+
+    let pos = KNOWN_ADDONS.indexOf(id);
+    if (pos < 0) {
+      pos = KNOWN_ADDONS.length;
+      KNOWN_ADDONS.push(id);
+    }
+    return `addon${pos}`;
+  }
+
+  if (widgetId.endsWith("-browser-action")) {
+    widgetId = addonId(
+      widgetId.substring(0, widgetId.length - "-browser-action".length)
+    );
+  } else if (widgetId.startsWith("pageAction-")) {
+    let actionId;
+    if (widgetId.startsWith("pageAction-urlbar-")) {
+      actionId = widgetId.substring("pageAction-urlbar-".length);
+    } else if (widgetId.startsWith("pageAction-panel-")) {
+      actionId = widgetId.substring("pageAction-panel-".length);
+    }
+
+    if (actionId) {
+      let action = lazy.PageActions.actionForID(actionId);
+      widgetId = action?._isMozillaAction ? actionId : addonId(actionId);
+    }
+  } else if (widgetId.startsWith("ext-keyset-id-")) {
+    // Webextension command shortcuts don't have an id on their key element so
+    // we see the id from the keyset that contains them.
+    widgetId = addonId(widgetId.substring("ext-keyset-id-".length));
+  } else if (widgetId.startsWith("ext-key-id-")) {
+    // The command for a webextension sidebar action is an exception to the above rule.
+    widgetId = widgetId.substring("ext-key-id-".length);
+    if (widgetId.endsWith("-sidebar-action")) {
+      widgetId = addonId(
+        widgetId.substring(0, widgetId.length - "-sidebar-action".length)
+      );
+    }
+  }
+
+  return widgetId.replace(/_/g, "-");
+}
+
+function getOpenTabsAndWinsCounts() {
+  let loadedTabCount = 0;
+  let tabCount = 0;
+  let winCount = 0;
+
+  for (let win of Services.wm.getEnumerator("navigator:browser")) {
+    winCount++;
+    tabCount += win.gBrowser.tabs.length;
+    for (const tab of win.gBrowser.tabs) {
+      if (tab.getAttribute("pending") !== "true") {
+        loadedTabCount += 1;
+      }
+    }
+  }
+
+  return { loadedTabCount, tabCount, winCount };
+}
+
+function getPinnedTabsCount() {
+  let pinnedTabs = 0;
+
+  for (let win of Services.wm.getEnumerator("navigator:browser")) {
+    pinnedTabs += [...win.ownerGlobal.gBrowser.tabs].filter(t => t.pinned)
+      .length;
+  }
+
+  return pinnedTabs;
+}
+
+let URICountListener = {
+  // A set containing the visited domains, see bug 1271310.
+  _domainSet: new Set(),
+  // A set containing the visited origins during the last 24 hours (similar to domains, but not quite the same)
+  _domain24hrSet: new Set(),
+  // A map to keep track of the URIs loaded from the restored tabs.
+  _restoredURIsMap: new WeakMap(),
+  // Ongoing expiration timeouts.
+  _timeouts: new Set(),
+
+  isHttpURI(uri) {
+    // Only consider http(s) schemas.
+    return uri.schemeIs("http") || uri.schemeIs("https");
+  },
+
+  addRestoredURI(browser, uri) {
+    if (!this.isHttpURI(uri)) {
+      return;
+    }
+
+    this._restoredURIsMap.set(browser, uri.spec);
+  },
+
+  onLocationChange(browser, webProgress, request, uri, flags) {
+    if (
+      !(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT) &&
+      webProgress.isTopLevel
+    ) {
+      // By default, assume we no longer need to track this tab.
+      lazy.SearchSERPTelemetry.stopTrackingBrowser(browser);
+    }
+
+    // Don't count this URI if it's an error page.
+    if (flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE) {
+      return;
+    }
+
+    // We only care about top level loads.
+    if (!webProgress.isTopLevel) {
+      return;
+    }
+
+    // The SessionStore sets the URI of a tab first, firing onLocationChange the
+    // first time, then manages content loading using its scheduler. Once content
+    // loads, we will hit onLocationChange again.
+    // We can catch the first case by checking for null requests: be advised that
+    // this can also happen when navigating page fragments, so account for it.
+    if (
+      !request &&
+      !(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)
+    ) {
+      return;
+    }
+
+    // Don't include URI and domain counts when in private mode.
+    let shouldCountURI =
+      !lazy.PrivateBrowsingUtils.isWindowPrivate(browser.ownerGlobal) ||
+      Services.prefs.getBoolPref(
+        "browser.engagement.total_uri_count.pbm",
+        false
+      );
+
+    // Track URI loads, even if they're not http(s).
+    let uriSpec = null;
+    try {
+      uriSpec = uri.spec;
+    } catch (e) {
+      // If we have troubles parsing the spec, still count this as
+      // an unfiltered URI.
+      if (shouldCountURI) {
+        Services.telemetry.scalarAdd(UNFILTERED_URI_COUNT_SCALAR_NAME, 1);
+      }
+      return;
+    }
+
+    // Don't count about:blank and similar pages, as they would artificially
+    // inflate the counts.
+    if (browser.ownerGlobal.gInitialPages.includes(uriSpec)) {
+      return;
+    }
+
+    // If the URI we're loading is in the _restoredURIsMap, then it comes from a
+    // restored tab. If so, let's skip it and remove it from the map as we want to
+    // count page refreshes.
+    if (this._restoredURIsMap.get(browser) === uriSpec) {
+      this._restoredURIsMap.delete(browser);
+      return;
+    }
+
+    // The URI wasn't from a restored tab. Count it among the unfiltered URIs.
+    // If this is an http(s) URI, this also gets counted by the "total_uri_count"
+    // probe.
+    if (shouldCountURI) {
+      Services.telemetry.scalarAdd(UNFILTERED_URI_COUNT_SCALAR_NAME, 1);
+    }
+
+    if (!this.isHttpURI(uri)) {
+      return;
+    }
+
+    if (!(flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)) {
+      lazy.SearchSERPTelemetry.updateTrackingStatus(
+        browser,
+        uriSpec,
+        webProgress.loadType
+      );
+    }
+
+    // Update total URI count, including when in private mode.
+    Services.telemetry.scalarAdd(
+      TOTAL_URI_COUNT_NORMAL_AND_PRIVATE_MODE_SCALAR_NAME,
+      1
+    );
+    Glean.browserEngagement.uriCount.add(1);
+
+    if (!shouldCountURI) {
+      return;
+    }
+
+    // Update the URI counts.
+    Services.telemetry.scalarAdd(TOTAL_URI_COUNT_SCALAR_NAME, 1);
+
+    // Update tab count
+    BrowserUsageTelemetry._recordTabCounts(getOpenTabsAndWinsCounts());
+
+    // Unique domains should be aggregated by (eTLD + 1): x.test.com and y.test.com
+    // are counted once as test.com.
+    let baseDomain;
+    try {
+      // Even if only considering http(s) URIs, |getBaseDomain| could still throw
+      // due to the URI containing invalid characters or the domain actually being
+      // an ipv4 or ipv6 address.
+      baseDomain = Services.eTLD.getBaseDomain(uri);
+    } catch (e) {
+      return;
+    }
+
+    // We only want to count the unique domains up to MAX_UNIQUE_VISITED_DOMAINS.
+    if (this._domainSet.size < MAX_UNIQUE_VISITED_DOMAINS) {
+      this._domainSet.add(baseDomain);
+      Services.telemetry.scalarSet(
+        UNIQUE_DOMAINS_COUNT_SCALAR_NAME,
+        this._domainSet.size
+      );
+    }
+
+    this._domain24hrSet.add(baseDomain);
+    if (lazy.gRecentVisitedOriginsExpiry) {
+      let timeoutId = lazy.setTimeout(() => {
+        this._domain24hrSet.delete(baseDomain);
+        this._timeouts.delete(timeoutId);
+      }, lazy.gRecentVisitedOriginsExpiry * 1000);
+      this._timeouts.add(timeoutId);
+    }
+  },
+
+  /**
+   * Reset the counts. This should be called when breaking a session in Telemetry.
+   */
+  reset() {
+    this._domainSet.clear();
+  },
+
+  /**
+   * Returns the number of unique domains visited in this session during the
+   * last 24 hours.
+   */
+  get uniqueDomainsVisitedInPast24Hours() {
+    return this._domain24hrSet.size;
+  },
+
+  /**
+   * Resets the number of unique domains visited in this session.
+   */
+  resetUniqueDomainsVisitedInPast24Hours() {
+    this._timeouts.forEach(timeoutId => lazy.clearTimeout(timeoutId));
+    this._timeouts.clear();
+    this._domain24hrSet.clear();
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIWebProgressListener",
+    "nsISupportsWeakReference",
+  ]),
+};
+
+let BrowserUsageTelemetry = {
+  /**
+   * This is a policy object used to override behavior for testing.
+   */
+  Policy: {
+    getTelemetryClientId: async () => lazy.ClientID.getClientID(),
+    getUpdateDirectory: () => Services.dirsvc.get("UpdRootD", Ci.nsIFile),
+    readProfileCountFile: async path => IOUtils.readUTF8(path),
+    writeProfileCountFile: async (path, data) => IOUtils.writeUTF8(path, data),
+  },
+
+  _inited: false,
+
+  init() {
+    this._lastRecordTabCount = 0;
+    this._lastRecordLoadedTabCount = 0;
+    this._setupAfterRestore();
+    this._inited = true;
+
+    Services.prefs.addObserver("browser.tabs.inTitlebar", this);
+
+    this._recordUITelemetry();
+
+    this._recordContentProcessCountInterval = lazy.setInterval(
+      () => this._recordContentProcessCount(),
+      CONTENT_PROCESS_COUNT_INTERVAL_MS
+    );
+  },
+
+  /**
+   * Resets the masked add-on identifiers. Only for use in tests.
+   */
+  _resetAddonIds() {
+    KNOWN_ADDONS.length = 0;
+  },
+
+  /**
+   * Handle subsession splits in the parent process.
+   */
+  afterSubsessionSplit() {
+    // Scalars just got cleared due to a subsession split. We need to set the maximum
+    // concurrent tab and window counts so that they reflect the correct value for the
+    // new subsession.
+    const counts = getOpenTabsAndWinsCounts();
+    Services.telemetry.scalarSetMaximum(
+      MAX_TAB_COUNT_SCALAR_NAME,
+      counts.tabCount
+    );
+    Services.telemetry.scalarSetMaximum(
+      MAX_WINDOW_COUNT_SCALAR_NAME,
+      counts.winCount
+    );
+
+    // Reset the URI counter.
+    URICountListener.reset();
+  },
+
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIObserver",
+    "nsISupportsWeakReference",
+  ]),
+
+  uninit() {
+    if (!this._inited) {
+      return;
+    }
+    Services.obs.removeObserver(this, DOMWINDOW_OPENED_TOPIC);
+    Services.obs.removeObserver(this, TELEMETRY_SUBSESSIONSPLIT_TOPIC);
+
+    lazy.clearInterval(this._recordContentProcessCountInterval);
+  },
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      case DOMWINDOW_OPENED_TOPIC:
+        this._onWindowOpen(subject);
+        break;
+      case TELEMETRY_SUBSESSIONSPLIT_TOPIC:
+        this.afterSubsessionSplit();
+        break;
+      case "nsPref:changed":
+        switch (data) {
+          case "browser.tabs.inTitlebar":
+            this._recordWidgetChange(
+              "titlebar",
+              Services.appinfo.drawInTitlebar ? "off" : "on",
+              "pref"
+            );
+            break;
+        }
+        break;
+    }
+  },
+
+  handleEvent(event) {
+    switch (event.type) {
+      case "TabOpen":
+        this._onTabOpen(getOpenTabsAndWinsCounts());
+        break;
+      case "TabPinned":
+        this._onTabPinned();
+        break;
+      case "unload":
+        this._unregisterWindow(event.target);
+        break;
+      case TAB_RESTORING_TOPIC:
+        // We're restoring a new tab from a previous or crashed session.
+        // We don't want to track the URIs from these tabs, so let
+        // |URICountListener| know about them.
+        let browser = event.target.linkedBrowser;
+        URICountListener.addRestoredURI(browser, browser.currentURI);
+
+        const { loadedTabCount } = getOpenTabsAndWinsCounts();
+        this._recordTabCounts({ loadedTabCount });
+        break;
+    }
+  },
+
+  /**
+   * This gets called shortly after the SessionStore has finished restoring
+   * windows and tabs. It counts the open tabs and adds listeners to all the
+   * windows.
+   */
+  _setupAfterRestore() {
+    // Make sure to catch new chrome windows and subsession splits.
+    Services.obs.addObserver(this, DOMWINDOW_OPENED_TOPIC, true);
+    Services.obs.addObserver(this, TELEMETRY_SUBSESSIONSPLIT_TOPIC, true);
+
+    // Attach the tabopen handlers to the existing Windows.
+    for (let win of Services.wm.getEnumerator("navigator:browser")) {
+      this._registerWindow(win);
+    }
+
+    // Get the initial tab and windows max counts.
+    const counts = getOpenTabsAndWinsCounts();
+    Services.telemetry.scalarSetMaximum(
+      MAX_TAB_COUNT_SCALAR_NAME,
+      counts.tabCount
+    );
+    Services.telemetry.scalarSetMaximum(
+      MAX_WINDOW_COUNT_SCALAR_NAME,
+      counts.winCount
+    );
+  },
+
+  _buildWidgetPositions() {
+    let widgetMap = new Map();
+
+    const toolbarState = nodeId => {
+      let value;
+      if (nodeId == "PersonalToolbar") {
+        value = Services.prefs.getCharPref(
+          "browser.toolbars.bookmarks.visibility",
+          "newtab"
+        );
+        if (value != "newtab") {
+          return value == "never" ? "off" : "on";
+        }
+        return value;
+      }
+      value = Services.xulStore.getValue(
+        AppConstants.BROWSER_CHROME_URL,
+        nodeId,
+        "collapsed"
+      );
+
+      if (value) {
+        return value == "true" ? "off" : "on";
+      }
+      return "off";
+    };
+
+    widgetMap.set(
+      BROWSER_UI_CONTAINER_IDS.PersonalToolbar,
+      toolbarState("PersonalToolbar")
+    );
+
+    let menuBarHidden =
+      Services.xulStore.getValue(
+        AppConstants.BROWSER_CHROME_URL,
+        "toolbar-menubar",
+        "autohide"
+      ) != "false";
+
+    widgetMap.set("menu-toolbar", menuBarHidden ? "off" : "on");
+
+    // Drawing in the titlebar means not showing the titlebar, hence the negation.
+    widgetMap.set("titlebar", Services.appinfo.drawInTitlebar ? "off" : "on");
+
+    for (let area of lazy.CustomizableUI.areas) {
+      if (!(area in BROWSER_UI_CONTAINER_IDS)) {
+        continue;
+      }
+
+      let position = BROWSER_UI_CONTAINER_IDS[area];
+      if (area == "nav-bar") {
+        position = `${BROWSER_UI_CONTAINER_IDS[area]}-start`;
+      }
+
+      let widgets = lazy.CustomizableUI.getWidgetsInArea(area);
+
+      for (let widget of widgets) {
+        if (!widget) {
+          continue;
+        }
+
+        if (widget.id.startsWith("customizableui-special-")) {
+          continue;
+        }
+
+        if (area == "nav-bar" && widget.id == "urlbar-container") {
+          position = `${BROWSER_UI_CONTAINER_IDS[area]}-end`;
+          continue;
+        }
+
+        widgetMap.set(widget.id, position);
+      }
+    }
+
+    let actions = lazy.PageActions.actions;
+    for (let action of actions) {
+      if (action.pinnedToUrlbar) {
+        widgetMap.set(action.id, "pageaction-urlbar");
+      }
+    }
+
+    return widgetMap;
+  },
+
+  _getWidgetID(node) {
+    // We want to find a sensible ID for this element.
+    if (!node) {
+      return null;
+    }
+
+    // See if this is a customizable widget.
+    if (node.ownerDocument.URL == AppConstants.BROWSER_CHROME_URL) {
+      // First find if it is inside one of the customizable areas.
+      for (let area of lazy.CustomizableUI.areas) {
+        if (node.closest(`#${CSS.escape(area)}`)) {
+          for (let widget of lazy.CustomizableUI.getWidgetIdsInArea(area)) {
+            if (
+              // We care about the buttons on the tabs themselves.
+              widget == "tabbrowser-tabs" ||
+              // We care about the page action and other buttons in here.
+              widget == "urlbar-container" ||
+              // We care about the actual menu items.
+              widget == "menubar-items" ||
+              // We care about individual bookmarks here.
+              widget == "personal-bookmarks"
+            ) {
+              continue;
+            }
+
+            if (node.closest(`#${CSS.escape(widget)}`)) {
+              return widget;
+            }
+          }
+          break;
+        }
+      }
+    }
+
+    if (node.id) {
+      return node.id;
+    }
+
+    // A couple of special cases in the tabs.
+    for (let cls of ["bookmark-item", "tab-icon-sound", "tab-close-button"]) {
+      if (node.classList.contains(cls)) {
+        return cls;
+      }
+    }
+
+    // One of these will at least let us know what the widget is for.
+    let possibleAttributes = [
+      "preference",
+      "command",
+      "observes",
+      "data-l10n-id",
+    ];
+
+    // The key attribute on key elements is the actual key to listen for.
+    if (node.localName != "key") {
+      possibleAttributes.unshift("key");
+    }
+
+    for (let idAttribute of possibleAttributes) {
+      if (node.hasAttribute(idAttribute)) {
+        return node.getAttribute(idAttribute);
+      }
+    }
+
+    return this._getWidgetID(node.parentElement);
+  },
+
+  _getBrowserWidgetContainer(node) {
+    // Find the container holding this element.
+    for (let containerId of Object.keys(BROWSER_UI_CONTAINER_IDS)) {
+      let container = node.ownerDocument.getElementById(containerId);
+      if (container && container.contains(node)) {
+        return BROWSER_UI_CONTAINER_IDS[containerId];
+      }
+    }
+    // Treat toolbar context menu items that relate to tabs as the tab menu:
+    if (
+      node.closest("#toolbar-context-menu") &&
+      node.getAttribute("contexttype") == "tabbar"
+    ) {
+      return BROWSER_UI_CONTAINER_IDS.tabContextMenu;
+    }
+    return null;
+  },
+
+  _getWidgetContainer(node) {
+    if (node.localName == "key") {
+      return "keyboard";
+    }
+
+    const { URL } = node.ownerDocument;
+    if (URL == AppConstants.BROWSER_CHROME_URL) {
+      return this._getBrowserWidgetContainer(node);
+    }
+    if (URL.startsWith("about:preferences")) {
+      // Find the element's category.
+      let container = node.closest("[data-category]");
+      if (!container) {
+        return null;
+      }
+
+      let pane = container.getAttribute("data-category");
+
+      if (!PREFERENCES_PANES.includes(pane)) {
+        pane = "paneUnknown";
+      }
+
+      return `preferences_${pane}`;
+    }
+
+    return null;
+  },
+
+  lastClickTarget: null,
+
+  ignoreEvent(event) {
+    IGNORABLE_EVENTS.set(event, true);
+  },
+
+  _recordCommand(event) {
+    if (IGNORABLE_EVENTS.get(event)) {
+      return;
+    }
+
+    let types = [event.type];
+    let sourceEvent = event;
+    while (sourceEvent.sourceEvent) {
+      sourceEvent = sourceEvent.sourceEvent;
+      types.push(sourceEvent.type);
+    }
+
+    let lastTarget = this.lastClickTarget?.get();
+    if (
+      lastTarget &&
+      sourceEvent.type == "command" &&
+      sourceEvent.target.contains(lastTarget)
+    ) {
+      // Ignore a command event triggered by a click.
+      this.lastClickTarget = null;
+      return;
+    }
+
+    this.lastClickTarget = null;
+
+    if (sourceEvent.type == "click") {
+      // Only care about main button clicks.
+      if (sourceEvent.button != 0) {
+        return;
+      }
+
+      // This click may trigger a command event so retain the target to be able
+      // to dedupe that event.
+      this.lastClickTarget = Cu.getWeakReference(sourceEvent.target);
+    }
+
+    // We should never see events from web content as they are fired in a
+    // content process, but let's be safe.
+    let url = sourceEvent.target.ownerDocument.documentURIObject;
+    if (!url.schemeIs("chrome") && !url.schemeIs("about")) {
+      return;
+    }
+
+    // This is what events targetted  at content will actually look like.
+    if (sourceEvent.target.localName == "browser") {
+      return;
+    }
+
+    // Find the actual element we're interested in.
+    let node = sourceEvent.target;
+    const isAboutPreferences = node.ownerDocument.URL.startsWith(
+      "about:preferences"
+    );
+    while (
+      !UI_TARGET_ELEMENTS.includes(node.localName) &&
+      !node.classList?.contains("wants-telemetry") &&
+      // We are interested in links on about:preferences as well.
+      !(
+        isAboutPreferences &&
+        (node.getAttribute("is") === "text-link" || node.localName === "a")
+      )
+    ) {
+      node = node.parentNode;
+      if (!node?.parentNode) {
+        // A click on a space or label or top-level document or something we're
+        // not interested in.
+        return;
+      }
+    }
+
+    let item = this._getWidgetID(node);
+    let source = this._getWidgetContainer(node);
+
+    if (item && source) {
+      let scalar = `browser.ui.interaction.${source.replace(/-/g, "_")}`;
+      Services.telemetry.keyedScalarAdd(scalar, telemetryId(item), 1);
+      if (SET_USAGECOUNT_PREF_BUTTONS.includes(item)) {
+        let pref = `browser.engagement.${item}.used-count`;
+        Services.prefs.setIntPref(pref, Services.prefs.getIntPref(pref, 0) + 1);
+      }
+      if (SET_USAGE_PREF_BUTTONS.includes(item)) {
+        Services.prefs.setBoolPref(`browser.engagement.${item}.has-used`, true);
+      }
+    }
+  },
+
+  /**
+   * Listens for UI interactions in the window.
+   */
+  _addUsageListeners(win) {
+    // Listen for command events from the UI.
+    win.addEventListener("command", event => this._recordCommand(event), true);
+    win.addEventListener("click", event => this._recordCommand(event), true);
+  },
+
+  /**
+   * A public version of the private method to take care of the `nav-bar-start`,
+   * `nav-bar-end` thing that callers shouldn't have to care about. It also
+   * accepts the DOM ids for the areas rather than the cleaner ones we report
+   * to telemetry.
+   */
+  recordWidgetChange(widgetId, newPos, reason) {
+    try {
+      if (newPos) {
+        newPos = BROWSER_UI_CONTAINER_IDS[newPos];
+      }
+
+      if (newPos == "nav-bar") {
+        let { position } = lazy.CustomizableUI.getPlacementOfWidget(widgetId);
+        let {
+          position: urlPosition,
+        } = lazy.CustomizableUI.getPlacementOfWidget("urlbar-container");
+        newPos = newPos + (urlPosition > position ? "-start" : "-end");
+      }
+
+      this._recordWidgetChange(widgetId, newPos, reason);
+    } catch (e) {
+      console.error(e);
+    }
+  },
+
+  recordToolbarVisibility(toolbarId, newState, reason) {
+    if (typeof newState != "string") {
+      newState = newState ? "on" : "off";
+    }
+    this._recordWidgetChange(
+      BROWSER_UI_CONTAINER_IDS[toolbarId],
+      newState,
+      reason
+    );
+  },
+
+  _recordWidgetChange(widgetId, newPos, reason) {
+    // In some cases (like when add-ons are detected during startup) this gets
+    // called before we've reported the initial positions. Ignore such cases.
+    if (!this.widgetMap) {
+      return;
+    }
+
+    if (widgetId == "urlbar-container") {
+      // We don't report the position of the url bar, it is after nav-bar-start
+      // and before nav-bar-end. But moving it means the widgets around it have
+      // effectively moved so update those.
+      let position = "nav-bar-start";
+      let widgets = lazy.CustomizableUI.getWidgetsInArea("nav-bar");
+
+      for (let widget of widgets) {
+        if (!widget) {
+          continue;
+        }
+
+        if (widget.id.startsWith("customizableui-special-")) {
+          continue;
+        }
+
+        if (widget.id == "urlbar-container") {
+          position = "nav-bar-end";
+          continue;
+        }
+
+        // This will do nothing if the position hasn't changed.
+        this._recordWidgetChange(widget.id, position, reason);
+      }
+
+      return;
+    }
+
+    let oldPos = this.widgetMap.get(widgetId);
+    if (oldPos == newPos) {
+      return;
+    }
+
+    let action = "move";
+
+    if (!oldPos) {
+      action = "add";
+    } else if (!newPos) {
+      action = "remove";
+    }
+
+    let key = `${telemetryId(widgetId, false)}_${action}_${oldPos ??
+      "na"}_${newPos ?? "na"}_${reason}`;
+    Services.telemetry.keyedScalarAdd("browser.ui.customized_widgets", key, 1);
+
+    if (newPos) {
+      this.widgetMap.set(widgetId, newPos);
+    } else {
+      this.widgetMap.delete(widgetId);
+    }
+  },
+
+  _recordUITelemetry() {
+    this.widgetMap = this._buildWidgetPositions();
+
+    for (let [widgetId, position] of this.widgetMap.entries()) {
+      let key = `${telemetryId(widgetId, false)}_pinned_${position}`;
+      Services.telemetry.keyedScalarSet(
+        "browser.ui.toolbar_widgets",
+        key,
+        true
+      );
+    }
+  },
+
+  /**
+   * Adds listeners to a single chrome window.
+   */
+  _registerWindow(win) {
+    this._addUsageListeners(win);
+
+    win.addEventListener("unload", this);
+    win.addEventListener("TabOpen", this, true);
+    win.addEventListener("TabPinned", this, true);
+
+    win.gBrowser.tabContainer.addEventListener(TAB_RESTORING_TOPIC, this);
+    win.gBrowser.addTabsProgressListener(URICountListener);
+  },
+
+  /**
+   * Removes listeners from a single chrome window.
+   */
+  _unregisterWindow(win) {
+    win.removeEventListener("unload", this);
+    win.removeEventListener("TabOpen", this, true);
+    win.removeEventListener("TabPinned", this, true);
+
+    win.defaultView.gBrowser.tabContainer.removeEventListener(
+      TAB_RESTORING_TOPIC,
+      this
+    );
+    win.defaultView.gBrowser.removeTabsProgressListener(URICountListener);
+  },
+
+  /**
+   * Updates the tab counts.
+   * @param {Object} [counts] The counts returned by `getOpenTabsAndWindowCounts`.
+   */
+  _onTabOpen({ tabCount, loadedTabCount }) {
+    // Update the "tab opened" count and its maximum.
+    Services.telemetry.scalarAdd(TAB_OPEN_EVENT_COUNT_SCALAR_NAME, 1);
+    Services.telemetry.scalarSetMaximum(MAX_TAB_COUNT_SCALAR_NAME, tabCount);
+
+    this._recordTabCounts({ tabCount, loadedTabCount });
+  },
+
+  _onTabPinned(target) {
+    const pinnedTabs = getPinnedTabsCount();
+
+    // Update the "tab pinned" count and its maximum.
+    Services.telemetry.scalarAdd(TAB_PINNED_EVENT_COUNT_SCALAR_NAME, 1);
+    Services.telemetry.scalarSetMaximum(
+      MAX_TAB_PINNED_COUNT_SCALAR_NAME,
+      pinnedTabs
+    );
+  },
+
+  /**
+   * Tracks the window count and registers the listeners for the tab count.
+   * @param{Object} win The window object.
+   */
+  _onWindowOpen(win) {
+    // Make sure to have a |nsIDOMWindow|.
+    if (!(win instanceof Ci.nsIDOMWindow)) {
+      return;
+    }
+
+    let onLoad = () => {
+      win.removeEventListener("load", onLoad);
+
+      // Ignore non browser windows.
+      if (
+        win.document.documentElement.getAttribute("windowtype") !=
+        "navigator:browser"
+      ) {
+        return;
+      }
+
+      this._registerWindow(win);
+      // Track the window open event and check the maximum.
+      const counts = getOpenTabsAndWinsCounts();
+      Services.telemetry.scalarAdd(WINDOW_OPEN_EVENT_COUNT_SCALAR_NAME, 1);
+      Services.telemetry.scalarSetMaximum(
+        MAX_WINDOW_COUNT_SCALAR_NAME,
+        counts.winCount
+      );
+
+      // We won't receive the "TabOpen" event for the first tab within a new window.
+      // Account for that.
+      this._onTabOpen(counts);
+    };
+    win.addEventListener("load", onLoad);
+  },
+
+  /**
+   * Record telemetry about the given tab counts.
+   *
+   * Telemetry for each count will only be recorded if the value isn't
+   * `undefined`.
+   *
+   * @param {object} [counts] The tab counts to register with telemetry.
+   * @param {number} [counts.tabCount] The number of tabs in all browsers.
+   * @param {number} [counts.loadedTabCount] The number of loaded (i.e., not
+   *                                         pending) tabs in all browsers.
+   */
+  _recordTabCounts({ tabCount, loadedTabCount }) {
+    let currentTime = Date.now();
+    if (
+      tabCount !== undefined &&
+      currentTime > this._lastRecordTabCount + MINIMUM_TAB_COUNT_INTERVAL_MS
+    ) {
+      Services.telemetry.getHistogramById("TAB_COUNT").add(tabCount);
+      this._lastRecordTabCount = currentTime;
+    }
+
+    if (
+      loadedTabCount !== undefined &&
+      currentTime >
+        this._lastRecordLoadedTabCount + MINIMUM_TAB_COUNT_INTERVAL_MS
+    ) {
+      Services.telemetry
+        .getHistogramById("LOADED_TAB_COUNT")
+        .add(loadedTabCount);
+      this._lastRecordLoadedTabCount = currentTime;
+    }
+  },
+
+  _checkProfileCountFileSchema(fileData) {
+    // Verifies that the schema of the file is the expected schema
+    if (typeof fileData.version != "string") {
+      throw new Error("Schema Mismatch Error: Bad type for 'version' field");
+    }
+    if (!Array.isArray(fileData.profileTelemetryIds)) {
+      throw new Error(
+        "Schema Mismatch Error: Bad type for 'profileTelemetryIds' field"
+      );
+    }
+    for (let profileTelemetryId of fileData.profileTelemetryIds) {
+      if (typeof profileTelemetryId != "string") {
+        throw new Error(
+          "Schema Mismatch Error: Bad type for an element of 'profileTelemetryIds'"
+        );
+      }
+    }
+  },
+
+  // Reports the number of Firefox profiles on this machine to telemetry.
+  async reportProfileCount() {
+    if (AppConstants.platform != "win") {
+      // This is currently a windows-only feature.
+      return;
+    }
+
+    // To report only as much data as we need, we will bucket our values.
+    // Rather than the raw value, we will report the greatest value in the list
+    // below that is no larger than the raw value.
+    const buckets = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 1000, 10000];
+
+    // We need both the C:\ProgramData\Mozilla directory and the install
+    // directory hash to create the profile count file path. We can easily
+    // reassemble this from the update directory, which looks like:
+    // C:\ProgramData\Mozilla\updates\hash
+    // Retrieving the directory this way also ensures that the "Mozilla"
+    // directory is created with the correct permissions.
+    // The ProgramData directory, by default, grants write permissions only to
+    // file creators. The directory service calls GetCommonUpdateDirectory,
+    // which makes sure the the directory is created with user-writable
+    // permissions.
+    const updateDirectory = BrowserUsageTelemetry.Policy.getUpdateDirectory();
+    const hash = updateDirectory.leafName;
+    const profileCountFilename = "profile_count_" + hash + ".json";
+    let profileCountFile = updateDirectory.parent.parent;
+    profileCountFile.append(profileCountFilename);
+
+    let readError = false;
+    let fileData;
+    try {
+      let json = await BrowserUsageTelemetry.Policy.readProfileCountFile(
+        profileCountFile.path
+      );
+      fileData = JSON.parse(json);
+      BrowserUsageTelemetry._checkProfileCountFileSchema(fileData);
+    } catch (ex) {
+      // Note that since this also catches the "no such file" error, this is
+      // always the template that we use when writing to the file for the first
+      // time.
+      fileData = { version: "1", profileTelemetryIds: [] };
+      if (!(ex.name == "NotFoundError")) {
+        console.error(ex);
+        // Don't just return here on a read error. We need to send the error
+        // value to telemetry and we want to attempt to fix the file.
+        // However, we will still report an error for this ping, even if we
+        // fix the file. This is to prevent always sending a profile count of 1
+        // if, for some reason, we always get a read error but never a write
+        // error.
+        readError = true;
+      }
+    }
+
+    let writeError = false;
+    let currentTelemetryId = await BrowserUsageTelemetry.Policy.getTelemetryClientId();
+    // Don't add our telemetry ID to the file if we've already reached the
+    // largest bucket. This prevents the file size from growing forever.
+    if (
+      !fileData.profileTelemetryIds.includes(currentTelemetryId) &&
+      fileData.profileTelemetryIds.length < Math.max(...buckets)
+    ) {
+      fileData.profileTelemetryIds.push(currentTelemetryId);
+      try {
+        await BrowserUsageTelemetry.Policy.writeProfileCountFile(
+          profileCountFile.path,
+          JSON.stringify(fileData)
+        );
+      } catch (ex) {
+        console.error(ex);
+        writeError = true;
+      }
+    }
+
+    // Determine the bucketed value to report
+    let rawProfileCount = fileData.profileTelemetryIds.length;
+    let valueToReport = 0;
+    for (let bucket of buckets) {
+      if (bucket <= rawProfileCount && bucket > valueToReport) {
+        valueToReport = bucket;
+      }
+    }
+
+    if (readError || writeError) {
+      // We convey errors via a profile count of 0.
+      valueToReport = 0;
+    }
+
+    Services.telemetry.scalarSet(
+      "browser.engagement.profile_count",
+      valueToReport
+    );
+  },
+
+  /**
+   * Check if this is the first run of this profile since installation,
+   * if so then send installation telemetry.
+   *
+   * @param {nsIFile} [dataPathOverride] Optional, full data file path, for tests.
+   * @param {Array<string>} [msixPackagePrefixes] Optional, list of prefixes to
+            consider "existing" installs when looking at installed MSIX packages.
+            Defaults to prefixes for builds produced in Firefox automation.
+   * @return {Promise}
+   * @resolves When the event has been recorded, or if the data file was not found.
+   * @rejects JavaScript exception on any failure.
+   */
+  async reportInstallationTelemetry(
+    dataPathOverride,
+    msixPackagePrefixes = ["Mozilla.Firefox", "Mozilla.MozillaFirefox"]
+  ) {
+    if (AppConstants.platform != "win") {
+      // This is a windows-only feature.
+      return;
+    }
+
+    const TIMESTAMP_PREF = "app.installation.timestamp";
+    const lastInstallTime = Services.prefs.getStringPref(TIMESTAMP_PREF, null);
+    const wpm = Cc["@mozilla.org/windows-package-manager;1"].createInstance(
+      Ci.nsIWindowsPackageManager
+    );
+    let installer_type = "";
+    let pfn;
+    try {
+      pfn = Services.sysinfo.getProperty("winPackageFamilyName");
+    } catch (e) {}
+
+    function getInstallData() {
+      // We only care about where _any_ other install existed - no
+      // need to count more than 1.
+      const installPaths = lazy.WindowsInstallsInfo.getInstallPaths(
+        1,
+        new Set([Services.dirsvc.get("GreBinD", Ci.nsIFile).path])
+      );
+      const msixInstalls = new Set();
+      // We're just going to eat all errors here -- we don't want the event
+      // to go unsent if we were unable to look for MSIX installs.
+      try {
+        wpm
+          .findUserInstalledPackages(msixPackagePrefixes)
+          .forEach(i => msixInstalls.add(i));
+        if (pfn) {
+          msixInstalls.delete(pfn);
+        }
+      } catch (ex) {}
+      return {
+        installPaths,
+        msixInstalls,
+      };
+    }
+
+    let extra = {};
+
+    if (pfn) {
+      if (lastInstallTime != null) {
+        // We've already seen this install
+        return;
+      }
+
+      // First time seeing this install, record the timestamp.
+      Services.prefs.setStringPref(TIMESTAMP_PREF, wpm.getInstalledDate());
+      let install_data = getInstallData();
+
+      installer_type = "msix";
+
+      // Build the extra event data
+      extra.version = AppConstants.MOZ_APP_VERSION;
+      extra.build_id = AppConstants.MOZ_BUILDID;
+      // The next few keys are static for the reasons described
+      // No way to detect whether or not we were installed by an admin
+      extra.admin_user = "false";
+      // Always false at the moment, because we create a new profile
+      // on first launch
+      extra.profdir_existed = "false";
+      // Obviously false for MSIX installs
+      extra.from_msi = "false";
+      // We have no way of knowing whether we were installed via the GUI,
+      // through the command line, or some Enterprise management tool.
+      extra.silent = "false";
+      // There's no way to change the install path for an MSIX package
+      extra.default_path = "true";
+      extra.install_existed = install_data.msixInstalls.has(pfn).toString();
+      install_data.msixInstalls.delete(pfn);
+      extra.other_inst = (!!install_data.installPaths.size).toString();
+      extra.other_msix_inst = (!!install_data.msixInstalls.size).toString();
+    } else {
+      let dataPath = dataPathOverride;
+      if (!dataPath) {
+        dataPath = Services.dirsvc.get("GreD", Ci.nsIFile);
+        dataPath.append("installation_telemetry.json");
+      }
+
+      let dataBytes;
+      try {
+        dataBytes = await IOUtils.read(dataPath.path);
+      } catch (ex) {
+        if (ex.name == "NotFoundError") {
+          // Many systems will not have the data file, return silently if not found as
+          // there is nothing to record.
+          return;
+        }
+        throw ex;
+      }
+      const dataString = new TextDecoder("utf-16").decode(dataBytes);
+      const data = JSON.parse(dataString);
+
+      if (lastInstallTime && data.install_timestamp == lastInstallTime) {
+        // We've already seen this install
+        return;
+      }
+
+      // First time seeing this install, record the timestamp.
+      Services.prefs.setStringPref(TIMESTAMP_PREF, data.install_timestamp);
+      let install_data = getInstallData();
+
+      installer_type = data.installer_type;
+
+      // Installation timestamp is not intended to be sent with telemetry,
+      // remove it to emphasize this point.
+      delete data.install_timestamp;
+
+      // Build the extra event data
+      extra.version = data.version;
+      extra.build_id = data.build_id;
+      extra.admin_user = data.admin_user.toString();
+      extra.install_existed = data.install_existed.toString();
+      extra.profdir_existed = data.profdir_existed.toString();
+      extra.other_inst = (!!install_data.installPaths.size).toString();
+      extra.other_msix_inst = (!!install_data.msixInstalls.size).toString();
+
+      if (data.installer_type == "full") {
+        extra.silent = data.silent.toString();
+        extra.from_msi = data.from_msi.toString();
+        extra.default_path = data.default_path.toString();
+      }
+    }
+    // Record the event
+    Services.telemetry.setEventRecordingEnabled("installation", true);
+    Services.telemetry.recordEvent(
+      "installation",
+      "first_seen",
+      installer_type,
+      null,
+      extra
+    );
+  },
+
+  /**
+   * Record the number of content processes.
+   */
+  _recordContentProcessCount() {
+    // All DOM processes includes the parent.
+    const count = ChromeUtils.getAllDOMProcesses().length - 1;
+
+    Services.telemetry.getHistogramById(CONTENT_PROCESS_COUNT).add(count);
+    Services.telemetry
+      .getHistogramById(CONTENT_PROCESS_PRECISE_COUNT)
+      .add(count);
+  },
+};
+
+// Used by nsIBrowserUsage
+function getUniqueDomainsVisitedInPast24Hours() {
+  return URICountListener.uniqueDomainsVisitedInPast24Hours;
+}
-- 
cgit v1.2.3