Bug 1886175 - Properly count urlbar hidden exposures whose hypothetical rows can't immediately be shown. r=mak,wstuckey

The problem has to do with hidden exposures whose hypothetical rows can't
immediately be made visible either because they would overflow the filled-up
view or because a misplaced result was seen.

The relevant part of `#updateResults()` is [here](https://searchfox.org/mozilla-central/rev/6a2a2a52d7e544a2fd5678d04991a7e78b694f22/browser/components/urlbar/UrlbarView.sys.mjs#1289-1291). When `canBeVisible` is false,
we effectively forget about that hidden-exposure result, which is not right. For
normal results, we also have that `canBeVisible` logic (a few lines down from
the part I linked), but the difference is that we create a hidden row for them
and then unhide the row when the query finishes and stale rows are removed.
We're missing an analog to that logic for hidden-exposure results, so we're
undercounting them.

Fortunately it's not too hard to fix. I added a new kind of exposure for
`TelemetryEvent` to track called "tentative" exposures. Tentative exposures are
entirely analogous to this case where a row would be added but hidden, and then
unhidden when stale rows are removed.

While I was modifying the test, I rephrased the comments for existing tasks so
hopefully they're easier to understand.

Differential Revision: https://phabricator.services.mozilla.com/D205155

Author: 0c0w3

browser/components/urlbar/UrlbarController.sys.mjs

@@ -708,7 +708,6 @@ class TelemetryEvent {
   constructor(controller, category) {
     this._controller = controller;
     this._category = category;
-    this.#exposureResultTypes = new Set();
     this.#beginObservingPingPrefs();
   }
 
@@ -1093,18 +1092,20 @@ class TelemetryEvent {
     }
 
     // First check to see if we can record an exposure event
-    if (
-      (method === "abandonment" || method === "engagement") &&
-      this.#exposureResultTypes.size
-    ) {
-      const exposureResults = Array.from(this.#exposureResultTypes).join(",");
-      this._controller.logger.debug(
-        `exposure event: ${JSON.stringify({ results: exposureResults })}`
-      );
-      Glean.urlbar.exposure.record({ results: exposureResults });
+    if (method === "abandonment" || method === "engagement") {
+      if (this.#exposureResultTypes.size) {
+        let exposure = {
+          results: [...this.#exposureResultTypes].sort().join(","),
+        };
+        this._controller.logger.debug(
+          `exposure event: ${JSON.stringify(exposure)}`
+        );
+        Glean.urlbar.exposure.record(exposure);
+      }
 
       // reset the provider list on the controller
       this.#exposureResultTypes.clear();
+      this.#tentativeExposureResultTypes.clear();
     }
 
     this._controller.logger.info(
@@ -1115,16 +1116,54 @@ class TelemetryEvent {
   }
 
   /**
-   * Add result type to engagementEvent instance exposureResultTypes Set.
+   * Registers an exposure for a result in the current urlbar session. All
+   * exposures that are added during a session are recorded in an exposure event
+   * at the end of the session. Exposures are cleared at the end of each session
+   * and do not carry over to the next session.
    *
-   * @param {UrlbarResult} result UrlbarResult to have exposure recorded.
+   * @param {UrlbarResult} result An exposure will be added for this result if
+   *        exposures are enabled for its result type.
    */
   addExposure(result) {
     if (result.exposureResultType) {
       this.#exposureResultTypes.add(result.exposureResultType);
     }
   }
 
+  /**
+   * Registers a tentative exposure for a result in the current urlbar session.
+   * Exposures that remain tentative at the end of the session are discarded and
+   * are not recorded in the exposure event.
+   *
+   * @param {UrlbarResult} result A tentative exposure will be added for this
+   *        result if exposures are enabled for its result type.
+   */
+  addTentativeExposure(result) {
+    if (result.exposureResultType) {
+      this.#tentativeExposureResultTypes.add(result.exposureResultType);
+    }
+  }
+
+  /**
+   * Converts all tentative exposures that were added and not yet discarded
+   * during the current urlbar session into actual exposures that will be
+   * recorded at the end of the session.
+   */
+  acceptTentativeExposures() {
+    for (let type of this.#tentativeExposureResultTypes) {
+      this.#exposureResultTypes.add(type);
+    }
+    this.#tentativeExposureResultTypes.clear();
+  }
+
+  /**
+   * Discards all tentative exposures that were added and not yet accepted
+   * during the current urlbar session.
+   */
+  discardTentativeExposures() {
+    this.#tentativeExposureResultTypes.clear();
+  }
+
   #getInteractionType(
     method,
     startEventInfo,
@@ -1313,5 +1352,6 @@ class TelemetryEvent {
 
   #previousSearchWordsSet = null;
 
-  #exposureResultTypes;
+  #exposureResultTypes = new Set();
+  #tentativeExposureResultTypes = new Set();
 }

browser/components/urlbar/UrlbarView.sys.mjs

@@ -1181,6 +1181,10 @@ export class UrlbarView {
     // future we should make it support any type of result. Or, even better,
     // results should be grouped, thus we can directly update groups.
 
+    // Discard tentative exposures. This is analogous to marking the
+    // hypothetical hidden rows of hidden-exposure results as stale.
+    this.controller.engagementEvent.discardTentativeExposures();
+
     // Walk rows and find an insertion index for results. To avoid flicker, we
     // skip rows until we find one compatible with the result we want to apply.
     // If we couldn't find a compatible range, we'll just update.
@@ -1217,7 +1221,7 @@ export class UrlbarView {
         ) {
           // We can replace the row's current result with the new one.
           if (result.exposureResultHidden) {
-            this.#addExposure(result);
+            this.controller.engagementEvent.addExposure(result);
           } else {
             this.#updateRow(row, result);
           }
@@ -1287,7 +1291,13 @@ export class UrlbarView {
         newSpanCount <= this.#queryContext.maxResults && !seenMisplacedResult;
       if (result.exposureResultHidden) {
         if (canBeVisible) {
-          this.#addExposure(result);
+          this.controller.engagementEvent.addExposure(result);
+        } else {
+          // Add a tentative exposure: The hypothetical row for this
+          // hidden-exposure result can't be visible now, but as long as it were
+          // not marked stale in a later update, it would be shown when stale
+          // rows are removed.
+          this.controller.engagementEvent.addTentativeExposure(result);
         }
         continue;
       }
@@ -2126,7 +2136,7 @@ export class UrlbarView {
       let visible = this.#isElementVisible(item);
       if (visible) {
         if (item.result.exposureResultType) {
-          this.#addExposure(item.result);
+          this.controller.engagementEvent.addExposure(item.result);
         }
         this.visibleResults.push(item.result);
       }
@@ -2363,6 +2373,10 @@ export class UrlbarView {
       row = next;
     }
     this.#updateIndices();
+
+    // Accept tentative exposures. This is analogous to unhiding the
+    // hypothetical non-stale hidden rows of hidden-exposure results.
+    this.controller.engagementEvent.acceptTentativeExposures();
   }
 
   #startRemoveStaleRowsTimer() {
@@ -3460,15 +3474,6 @@ export class UrlbarView {
       this.#populateResultMenu();
     }
   }
-
-  /**
-   * Add result to exposure set on the controller.
-   *
-   * @param {UrlbarResult} result UrlbarResult for which to record an exposure.
-   */
-  #addExposure(result) {
-    this.controller.engagementEvent.addExposure(result);
-  }
 }
 
 /**