Method traceEngine

front_end/testing/TraceLoader.ts:146–209

* Executes only the new trace engine on the fixture and returns the resulting parsed data. * * @param context The Mocha test context. Processing a trace can easily * takes up longer than the default Mocha timeout, which is 2s. So we have to * increase this test's timeout. It might be nul

(
      context: Mocha.Context|Mocha.Suite|null, name: string,
      config: Trace.Types.Configuration.Configuration = Trace.Types.Configuration.defaults(), opts = {
        withTimelinePanel: true,
      })

   * will fall back to the Default config if not provided.
   */
  static async traceEngine(
      context: Mocha.Context|Mocha.Suite|null, name: string,
      config: Trace.Types.Configuration.Configuration = Trace.Types.Configuration.defaults(), opts = {
        withTimelinePanel: true,
      }): Promise<Trace.TraceModel.ParsedTrace> {
    if (context) {
      TraceLoader.setTestTimeout(context);
    }
    let timelineModule: typeof Timeline|undefined;
    if (opts.withTimelinePanel) {
      timelineModule = await import('../panels/timeline/timeline.js');
    }
    // Force the TraceBounds to be reset to empty. This ensures that in
    // tests where we are using the new engine data we don't accidentally
    // rely on the fact that a previous test has set the BoundsManager.
    TraceBounds.TraceBounds.BoundsManager.instance({forceNew: true});

    const configCacheKey = Trace.Types.Configuration.configToCacheKey(config);

    const fromCache = traceEngineCache.get(name)?.get(configCacheKey);

    // If we have results from the cache, we use those to ensure we keep the
    // tests speedy and don't re-parse trace files over and over again.
    if (fromCache) {
      const parsedTrace = fromCache.parsedTrace;
      await wrapInTimeout(context, () => {
        const syntheticEventsManager = fromCache.model.syntheticTraceEventsManager(0);
        if (!syntheticEventsManager) {
          throw new Error('Cached trace engine result did not have a synthetic events manager instance');
        }
        Trace.Helpers.SyntheticEvents.SyntheticEventsManager.activate(syntheticEventsManager);
        TraceLoader.initTraceBoundsManager(parsedTrace);
        if (timelineModule) {
          timelineModule.ModificationsManager.ModificationsManager.reset();
          timelineModule.ModificationsManager.ModificationsManager.initAndActivateModificationsManager(
              fromCache.model, 0);
        }
      }, 4_000, 'Initializing state for cached trace');
      return parsedTrace;
    }

    const fileContents = await wrapInTimeout(context, async () => {
      return await TraceLoader.fixtureContents(context, name);
    }, 30_000, `Loading fixtureContents for ${name}`);

    const parsedTraceFileAndModel = await wrapInTimeout(context, async () => {
      return await TraceLoader.executeTraceEngineOnFileContents(
          fileContents, /* emulate fresh recording */ false, config);
    }, 30_000, `Executing traceEngine for ${name}`);

    const cacheByName = traceEngineCache.get(name) ?? new Map<string, ParsedTraceAndModel>();
    cacheByName.set(configCacheKey, parsedTraceFileAndModel);
    traceEngineCache.set(name, cacheByName);

    TraceLoader.initTraceBoundsManager(parsedTraceFileAndModel.parsedTrace);
    if (timelineModule) {
      await wrapInTimeout(context, () => {
        timelineModule.ModificationsManager.ModificationsManager.reset();