ui: Remove TraceController

Turn TraceController in an async function.

Change-Id: I2791e351bece49e3e5006c76a3ab69dc119fc3eb

Author: primiano

ui/src/common/actions.ts

@@ -22,20 +22,11 @@ import {
   RecordingTarget,
   State,
 } from './state';
-import {SerializedAppState} from '../public/state_serialization_schema';
-import {PostedTrace} from '../public/trace_source';
 
 type StateDraft = Draft<State>;
 
-function generateNextId(draft: StateDraft): string {
-  const nextId = String(Number(draft.nextId) + 1);
-  draft.nextId = nextId;
-  return nextId;
-}
-
 export const StateActions = {
   clearState(state: StateDraft, _args: {}) {
-    const nextId = state.nextId;
     const recordConfig = state.recordConfig;
     const recordingTarget = state.recordingTarget;
     const fetchChromeCategories = state.fetchChromeCategories;
@@ -44,7 +35,6 @@ export const StateActions = {
     const chromeCategories = state.chromeCategories;
 
     Object.assign(state, createEmptyState());
-    state.nextId = nextId;
     state.recordConfig = recordConfig;
     state.recordingTarget = recordingTarget;
     state.fetchChromeCategories = fetchChromeCategories;
@@ -53,49 +43,6 @@ export const StateActions = {
     state.chromeCategories = chromeCategories;
   },
 
-  openTraceFromFile(state: StateDraft, args: {file: File}): void {
-    this.clearState(state, {});
-    const id = generateNextId(state);
-    state.engine = {
-      id,
-      source: {type: 'FILE', file: args.file},
-    };
-  },
-
-  openTraceFromBuffer(state: StateDraft, args: PostedTrace): void {
-    this.clearState(state, {});
-    const id = generateNextId(state);
-    state.engine = {
-      id,
-      source: {type: 'ARRAY_BUFFER', ...args},
-    };
-  },
-
-  openTraceFromUrl(
-    state: StateDraft,
-    args: {url: string; serializedAppState?: SerializedAppState},
-  ): void {
-    this.clearState(state, {});
-    const id = generateNextId(state);
-    state.engine = {
-      id,
-      source: {
-        type: 'URL',
-        url: args.url,
-        serializedAppState: args.serializedAppState,
-      },
-    };
-  },
-
-  openTraceFromHttpRpc(state: StateDraft, _args: {}): void {
-    this.clearState(state, {});
-    const id = generateNextId(state);
-    state.engine = {
-      id,
-      source: {type: 'HTTP_RPC'},
-    };
-  },
-
   requestTrackReload(state: StateDraft, _: {}) {
     // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (state.lastTrackReloadRequest) {

ui/src/common/actions_unittest.ts

@@ -46,7 +46,6 @@ export function keyedMap<T>(
 export function createEmptyState(): State {
   return {
     version: STATE_VERSION,
-    nextId: '-1',
 
     recordConfig: AUTOLOAD_STARTED_CONFIG_FLAG.get()
       ? autosaveConfigStore.get()

ui/src/common/empty_state.ts

@@ -14,6 +14,7 @@
 
 import {assertExists, assertTrue} from '../../base/logging';
 import {currentDateHourAndMinute} from '../../base/time';
+import {AppImpl} from '../../core/app_impl';
 import {raf} from '../../core/raf_scheduler';
 import {globals} from '../../frontend/globals';
 import {autosaveConfigStore} from '../../frontend/record_config';
@@ -306,13 +307,11 @@ export class RecordingPageController {
     if (this.tracingSessionWrapper !== tracingSessionWrapper) {
       return;
     }
-    globals.dispatch(
-      Actions.openTraceFromBuffer({
-        title: 'Recorded trace',
-        buffer: trace.buffer,
-        fileName: `trace_${currentDateHourAndMinute()}${TRACE_SUFFIX}`,
-      }),
-    );
+    AppImpl.instance.openTraceFromBuffer({
+      title: 'Recorded trace',
+      buffer: trace.buffer,
+      fileName: `trace_${currentDateHourAndMinute()}${TRACE_SUFFIX}`,
+    });
     this.clearRecordingState();
   }
 

ui/src/common/recordingV2/recording_page_controller.ts

@@ -158,7 +158,6 @@ export interface PendingDeeplinkState {
 
 export interface State {
   version: number;
-  nextId: string;
 
   /**
    * State of the ConfigEditor.

ui/src/common/state.ts

@@ -13,10 +13,8 @@
 // limitations under the License.
 
 import {RECORDING_V2_FLAG} from '../core/feature_flags';
-import {globals} from '../frontend/globals';
 import {Child, Controller, ControllerInitializerAny} from './controller';
 import {RecordController} from './record_controller';
-import {TraceController} from './trace_controller';
 
 // The root controller for the entire app. It handles the lifetime of all
 // the other controllers (e.g., track and query controllers) according to the
@@ -44,10 +42,6 @@ export class AppController extends Controller<'main'> {
         Child('record', RecordController, {extensionPort: this.extensionPort}),
       );
     }
-    if (globals.state.engine !== undefined) {
-      const engineCfg = globals.state.engine;
-      childControllers.push(Child(engineCfg.id, TraceController, engineCfg));
-    }
     return childControllers;
   }
 }

ui/src/controller/app_controller.ts

@@ -45,6 +45,7 @@ import {
 import {Controller} from './controller';
 import {RecordConfig} from './record_config_types';
 import {Consumer, RpcConsumerPort} from './record_controller_interfaces';
+import {AppImpl} from '../core/app_impl';
 
 type RPCImplMethod = Method | rpc.ServiceMethod<Message<{}>, Message<{}>>;
 
@@ -328,13 +329,11 @@ export class RecordController extends Controller<'main'> implements Consumer {
       return;
     }
     const trace = this.generateTrace();
-    globals.dispatch(
-      Actions.openTraceFromBuffer({
-        title: 'Recorded trace',
-        buffer: trace.buffer,
-        fileName: `recorded_trace${this.recordedTraceSuffix}`,
-      }),
-    );
+    AppImpl.instance.openTraceFromBuffer({
+      title: 'Recorded trace',
+      buffer: trace.buffer,
+      fileName: `recorded_trace${this.recordedTraceSuffix}`,
+    });
     this.traceBuffer = [];
   }
 

ui/src/controller/record_controller.ts

@@ -23,10 +23,10 @@ import {PluginManager} from './plugin_manager';
 import {NewEngineMode} from '../trace_processor/engine';
 import {RouteArgs} from '../public/route_schema';
 import {SqlPackage} from '../public/extra_sql_packages';
-
-// The pseudo plugin id used for the core instance of AppImpl.
-
-export const CORE_PLUGIN_ID = '__core__';
+import {SerializedAppState} from '../public/state_serialization_schema';
+import {PostedTrace, TraceSource} from '../public/trace_source';
+import {loadTrace} from './load_trace';
+import {CORE_PLUGIN_ID} from './plugin_manager';
 
 // The args that frontend/index.ts passes when calling AppImpl.initialize().
 // This is to deal with injections that would otherwise cause circular deps.
@@ -160,6 +160,50 @@ export class AppImpl implements App {
     return this.appCtx.initialRouteArgs;
   }
 
+  openTraceFromFile(file: File): void {
+    this.openTrace({type: 'FILE', file});
+  }
+
+  openTraceFromUrl(url: string, serializedAppState?: SerializedAppState) {
+    this.openTrace({type: 'URL', url, serializedAppState});
+  }
+
+  openTraceFromBuffer(postMessageArgs: PostedTrace): void {
+    this.openTrace({type: 'ARRAY_BUFFER', ...postMessageArgs});
+  }
+
+  openTraceFromHttpRpc(): void {
+    this.openTrace({type: 'HTTP_RPC'});
+  }
+
+  private async openTrace(src: TraceSource) {
+    assertTrue(this.pluginId === CORE_PLUGIN_ID);
+    this.closeCurrentTrace();
+    this.appCtx.isLoadingTrace = true;
+    try {
+      // loadTrace() in trace_loader.ts will do the following:
+      // - Create a new engine.
+      // - Pump the data from the TraceSource into the engine.
+      // - Do the initial queries to build the TraceImpl object
+      // - Call AppImpl.setActiveTrace(TraceImpl)
+      // - Continue with the trace loading logic (track decider, plugins, etc)
+      // - Resolve the promise when everything is done.
+      await loadTrace(this, src);
+      this.omnibox.reset(/* focus= */ false);
+      // loadTrace() internally will call setActiveTrace() and change our
+      // _currentTrace in the middle of its ececution. We cannot wait for
+      // loadTrace to be finished before setting it because some internal
+      // implementation details of loadTrace() rely on that trace to be current
+      // to work properly (mainly the router hash uuid).
+    } catch (err) {
+      this.omnibox.showStatusMessage(`${err}`);
+      throw err;
+    } finally {
+      this.appCtx.isLoadingTrace = false;
+      raf.scheduleFullRedraw();
+    }
+  }
+
   closeCurrentTrace() {
     // This method should be called only on the core instance, plugins don't
     // have access to openTrace*() methods.
@@ -190,13 +234,6 @@ export class AppImpl implements App {
     return this.appCtx.isLoadingTrace;
   }
 
-  // TODO(primiano): this is very temporary and will go away as soon as
-  // TraceController is turned into an async function.
-  setIsLoadingTrace(loading: boolean) {
-    this.appCtx.isLoadingTrace = loading;
-    raf.scheduleFullRedraw();
-  }
-
   get rootUrl() {
     return this.appCtx.initArgs.rootUrl;
   }