Recompute tabToThreadIndexesMap from the sanitized profile

When a tab filter was active during publishing, a hidden non-thread
track (e.g. a screenshot or a per-process network track) could
reappear after sanitization. attemptToPublish was remapping the URL
state's hidden-track set against a global track list filtered using
the prePublishedState's tabToThreadIndexesMap; that map's
Set<ThreadIndex> values referred to old thread indexes, so when
sanitization shifted surviving threads down by removing an earlier
thread, filterGlobalTracksByTab picked the wrong threads and the
hidden track ended up at a stale TrackIndex.

attemptToPublish now builds the map from the sanitized profile's
threads and pages so its ThreadIndex values are valid in the new
track-index space. The innerWindowID to tabID computation is
extracted into a shared computeInnerWindowIDToTabMap helper that the
getInnerWindowIDToTabMap selector also uses.

Author: fatadel

src/actions/publish.ts

@@ -29,7 +29,6 @@ import {
   getCommittedRange,
   getGlobalTracks,
   getLocalTracksByPid,
-  getTabToThreadIndexesMap,
 } from 'firefox-profiler/selectors/profile';
 import { viewProfile } from './receive-profile';
 import { ensureExists } from 'firefox-profiler/utils/types';
@@ -43,6 +42,10 @@ import {
   computeHiddenTracksAfterSanitization,
   computeTrackOrderAfterSanitization,
 } from 'firefox-profiler/profile-logic/tracks';
+import {
+  computeInnerWindowIDToTabMap,
+  computeTabToThreadIndexesMap,
+} from 'firefox-profiler/profile-logic/profile-data';
 
 import type {
   Action,
@@ -494,13 +497,17 @@ export function attemptToPublish(
             oldThreadIndexToNew
           );
 
-          const tabToThreadIndexesMap =
-            getTabToThreadIndexesMap(prePublishedState);
+          // The selector-derived map keys ThreadIndex values from the
+          // prePublishedState; rebuild it against the sanitized profile.
+          const newTabToThreadIndexesMap = computeTabToThreadIndexesMap(
+            profile.threads,
+            computeInnerWindowIDToTabMap(profile.pages)
+          );
           const tabFilter = getTabFilter(prePublishedState);
           const newGlobalTracks = computeGlobalTracks(
             profile,
             tabFilter,
-            tabToThreadIndexesMap
+            newTabToThreadIndexesMap
           );
           const newLocalTracksByPid = computeLocalTracksByPid(
             profile,

src/profile-logic/profile-data.ts

@@ -4469,6 +4469,23 @@ export function determineTimelineType(profile: Profile): TimelineType {
   return 'cpu-category';
 }
 
+/**
+ * Compute an innerWindowID → tabID lookup from a profile's pages list.
+ * Returns null when the profile has no pages.
+ */
+export function computeInnerWindowIDToTabMap(
+  pages: PageList | null | undefined
+): Map<InnerWindowID, TabID> | null {
+  if (!pages) {
+    return null;
+  }
+  const innerWindowIDToTabMap = new Map<InnerWindowID, TabID>();
+  for (const page of pages) {
+    innerWindowIDToTabMap.set(page.innerWindowID, page.tabID);
+  }
+  return innerWindowIDToTabMap;
+}
+
 /**
  * Compute a map of tab to thread indexes map. This is useful for learning which
  * threads are involved for tabs. This is mainly used for the tab selector on

src/selectors/profile.ts

@@ -16,6 +16,7 @@ import {
   getFriendlyThreadName,
   processCounter,
   getInclusiveSampleIndexRangeForSelection,
+  computeInnerWindowIDToTabMap,
   computeTabToThreadIndexesMap,
   computeStackTableFromRawStackTable,
   reserveFunctionsForCollapsedResources,
@@ -428,19 +429,7 @@ export const getInnerWindowIDToPageMap: Selector<Map<
 export const getInnerWindowIDToTabMap: Selector<Map<
   InnerWindowID,
   TabID
-> | null> = createSelector(getPageList, (pages) => {
-  if (!pages) {
-    // Return null if there are no pages.
-    return null;
-  }
-
-  const innerWindowIDToTabMap: Map<InnerWindowID, TabID> = new Map();
-  for (const page of pages) {
-    innerWindowIDToTabMap.set(page.innerWindowID, page.tabID);
-  }
-
-  return innerWindowIDToTabMap;
-});
+> | null> = createSelector(getPageList, computeInnerWindowIDToTabMap);
 
 /**
  * Return a map of tab to thread indexes map. This is useful for learning which

src/test/store/publish.test.ts

@@ -59,6 +59,7 @@ import {
   hideGlobalTrack,
   commitRange,
 } from '../../actions/profile-view';
+import { changeTabFilter } from '../../actions/receive-profile';
 
 import {
   retrieveUploadedProfileInformationFromDb,
@@ -629,6 +630,102 @@ describe('attemptToPublish', function () {
     );
   });
 
+  it('keeps a hidden screenshot track hidden after sanitization when a tab filter is active', async function () {
+    const { profile } = getProfileFromTextSamples('A', 'B', 'C', 'D', 'E');
+    profile.meta.updateChannel = 'release';
+
+    profile.threads[0].name = 'GeckoMain';
+    profile.threads[0].isMainThread = true;
+    profile.threads[0].processType = 'default';
+    profile.threads[0].pid = '100';
+    profile.threads[1].name = 'GeckoMain';
+    profile.threads[1].isMainThread = true;
+    profile.threads[1].processType = 'tab';
+    profile.threads[1].pid = '200';
+    profile.threads[2].name = 'GeckoMain';
+    profile.threads[2].isMainThread = true;
+    profile.threads[2].processType = 'tab';
+    profile.threads[2].pid = '300';
+    profile.threads[3].name = 'GeckoMain';
+    profile.threads[3].isMainThread = true;
+    profile.threads[3].processType = 'tab';
+    profile.threads[3].pid = '400';
+    profile.threads[4].name = 'GeckoMain';
+    profile.threads[4].isMainThread = true;
+    profile.threads[4].processType = 'tab';
+    profile.threads[4].pid = '500';
+
+    const tab1ID = 1;
+    const tab2ID = 2;
+    const tab1InnerWindowID = 1001;
+    const tab2InnerWindowID = 1002;
+    profile.pages = [
+      {
+        tabID: tab1ID,
+        innerWindowID: tab1InnerWindowID,
+        url: 'https://tab1.example.com/',
+        embedderInnerWindowID: 0,
+      },
+      {
+        tabID: tab2ID,
+        innerWindowID: tab2InnerWindowID,
+        url: 'https://tab2.example.com/',
+        embedderInnerWindowID: 0,
+      },
+    ];
+    profile.threads[0].usedInnerWindowIDs = [tab1InnerWindowID];
+    profile.threads[1].usedInnerWindowIDs = [tab1InnerWindowID];
+    profile.threads[2].usedInnerWindowIDs = [tab1InnerWindowID];
+    profile.threads[3].usedInnerWindowIDs = [tab2InnerWindowID];
+    profile.threads[4].usedInnerWindowIDs = [tab2InnerWindowID];
+
+    addRawMarkersToThread(profile.threads[2], profile.shared, [
+      makeCompositorScreenshot(0.5),
+    ]);
+
+    const store = storeWithProfile(profile);
+    const { dispatch, getState, resolveUpload, assertUploadSuccess } =
+      setupFakeUploadsWithStore(store);
+
+    dispatch(updateSharingOption('includeScreenshots', true));
+    dispatch(changeTabFilter(tab1ID));
+
+    const globalTracksBefore = getGlobalTracks(getState());
+    const pid200TrackIndex = globalTracksBefore.findIndex(
+      (t) => t.type === 'process' && t.pid === '200'
+    );
+    const screenshotTrackIndex = globalTracksBefore.findIndex(
+      (t) => t.type === 'screenshots'
+    );
+    expect(pid200TrackIndex).toBeGreaterThanOrEqual(0);
+    expect(screenshotTrackIndex).toBeGreaterThanOrEqual(0);
+
+    dispatch(hideGlobalTrack(pid200TrackIndex));
+    dispatch(hideGlobalTrack(screenshotTrackIndex));
+
+    expect(getHiddenGlobalTracks(getState())).toContain(screenshotTrackIndex);
+
+    const publishAttempt = dispatch(attemptToPublish());
+    resolveUpload(JWT_TOKEN);
+    await assertUploadSuccess(publishAttempt);
+
+    const globalTracksAfter = getGlobalTracks(getState());
+    expect(
+      globalTracksAfter.some((t) => t.type === 'process' && t.pid === '200')
+    ).toBe(false);
+    expect(
+      globalTracksAfter.some((t) => t.type === 'process' && t.pid === '300')
+    ).toBe(true);
+    const newScreenshotTrackIndex = globalTracksAfter.findIndex(
+      (t) => t.type === 'screenshots'
+    );
+    expect(newScreenshotTrackIndex).toBeGreaterThanOrEqual(0);
+
+    expect(getHiddenGlobalTracks(getState())).toContain(
+      newScreenshotTrackIndex
+    );
+  });
+
   describe('with zip files', function () {
     const setupZipFileTests = async () => {
       const { store } = await storeWithZipFile([