// will NOT work
driver.defaultSession.sendCommand('Security.enable').then(_ => {
  driver.defaultSession.on('Security.securityStateChanged', state => { /* ... */ });
})

// WILL work! happy happy. :)
driver.defaultSession.on('Security.securityStateChanged', state => { /* ... */ }); // event binding is synchronous
driver.defaultSession.sendCommand('Security.enable');

{
    passes: [{
        passName: 'fastPass',
        atherers: ['fast-gatherer'],
    },
    {
        passName: 'slowPass',
        recordTrace: true,
        useThrottling: true,
        networkQuietThresholdMs: 5000,
        gatherers: ['slow-gatherer'],
     }]
 }

class JsUsage extends FRGatherer {
  meta = {
    supportedModes: ['snapshot', 'timespan', 'navigation'],
  };

  constructor() {
    super();
    this._scriptUsages = [];
  }
  async startInstrumentation(context) {
    const session = context.driver.defaultSession;
    await session.sendCommand('Profiler.enable');
    await session.sendCommand('Profiler.startPreciseCoverage', {detailed: false});
  }


  async stopInstrumentation(context) {
    const session = context.driver.defaultSession;
    const coverageResponse = await session.sendCommand('Profiler.takePreciseCoverage');
    this._scriptUsages = coverageResponse.result;
    await session.sendCommand('Profiler.stopPreciseCoverage');
    await session.sendCommand('Profiler.disable');
  }

  async getArtifact() {
    const usageByScriptId = {};
    for (const scriptUsage of this._scriptUsages) {
      if (scriptUsage.url === '' || scriptUsage.url === '_lighthouse-eval.js') {
        continue;
      }
      usageByScriptId[scriptUsage.scriptId] = scriptUsage;
    }
    return usageByScriptId;
  }
}

class  FRGatherer { meta = { supportedModes : []};    //在任意時間段內開始觀察頁面   startInstrumentation ( passContext ) { }  //Sensitive開始觀察頁面   startSensitiveInstrumentation ( passContext ) { }  //Sensitive停止觀察頁面的方法   stopSensitiveInstrumentation ( passContext ) { }  //在任意時間段內結束觀察頁面   stopInstrumentation ( passContext ) { }   //收集有關頁面的結果   getArtifact ( passContext ) { }   /** * Legacy  */   get name () {}   async beforePass ( passContext ) {}   pass ( passContext ) { }   async afterPass ( passContext, loadData ) {}

{
    'pid': 41904, // process ID
    'tid': 1295, // thread ID
    'ts': 1676836141, // timestamp in microseconds
    'ph': 'X', // trace event type
    'cat': 'toplevel', // trace category from which this event came
    'name': 'MessageLoop::RunTask', // relatively human-readable description of the trace event
    'dur': 64, // duration of the task in microseconds
    'args': {}, // contains additional data such as frame when applicable
}

{
    processEvents: [/* all trace events in the main process */],
    mainThreadEvents: [/* all trace events on the main thread */],
    timings: {
        timeOrigin: 0, // timeOrigin is always 0 
        msfirstContentfulPaint: 150, // firstContentfulPaint time in ms after time origin
        /* other key moments */
        traceEnd: 16420, // traceEnd time in ms after time origin
     },
     timestamps: {
         timeOrigin: 623000000, // timeOrigin timestamp in microseconds, marks the start of the navigation of interest
         firstContentfulPaint: 623150000, // firstContentfulPaint timestamp in microseconds
         /* other key moments */
         traceEnd: 639420000, // traceEnd timestamp in microseconds
     },
 }

begin();
  |
   → runLighthouse(); 
           |
            →  legacyNavigation();
                  

async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
    //... 
  const connection = userConnection || new CriConnection(flags.port, flags.hostname);
  const artifacts = await Runner.gather(() => {
    const requestedUrl = UrlUtils.normalizeUrl(url);
    return Runner._gatherArtifactsFromBrowser(requestedUrl, options, connection);
  }, options);
  return Runner.audit(artifacts, options);
}

static async _gatherArtifactsFromBrowser(requestedUrl, runnerOpts, connection) {
   //創(chuàng)建connection的Driver
    const driver = runnerOpts.driverMock || new Driver(connection);
    const gatherOpts = {
      driver,
      requestedUrl,
      settings: runnerOpts.config.settings,
      computedCache: runnerOpts.computedCache,
    };
    const artifacts = await GatherRunner.run(runnerOpts.config.passes, gatherOpts);
    return artifacts;
  }
 /****** GatherRunner ****/
static async run(passConfigs, options) {

  
 //1.Connecting to browser 
          //通過 Websocket 建立連接, 基于 Chrome Debugging Protocol 通信
         // CDPSession 實例用于與 Chrome Devtools 協(xié)議的原生通信 
      await driver.connect();
        // 在 devtools/extension 案例中，我們在嘗試清除狀態(tài)時仍不能在站點上
 // 所以我們首先導航到 about:blank，然后應用我們的仿真和設置
       // 2.Resetting state with about:blank  & 3.Navigating to blankPage
      await GatherRunner.loadBlank(driver);
     // 4. Benchmarking machine 
      const baseArtifacts = await GatherRunner.initializeBaseArtifacts(options);
      
      // ...processing benchmarkIndex

         // 5. Initializing…
      await GatherRunner.setupDriver(driver, options);
    
      let isFirstPass = true;
      // each pass
      for (const passConfig of passConfigs) {
        const passContext = {
          gatherMode: 'navigation',
          driver,
          url: options.requestedUrl,
          settings: options.settings,
          passConfig,
          baseArtifacts,
          computedCache: options.computedCache,
          LighthouseRunWarnings: baseArtifacts.LighthouseRunWarnings,
        };
 //Starting from about:blank, load the page and run gatherers for this pass. 
        const passResults = await GatherRunner.runPass(passContext);
        Object.assign(artifacts, passResults.artifacts);
    
        // If we encountered a pageLoadError, don't try to keep loading the page in future passes.
        if (passResults.pageLoadError && passConfig.loadFailureMode === 'fatal') {
          baseArtifacts.PageLoadError = passResults.pageLoadError;
          break;
        }
    
        if (isFirstPass) {
          await GatherRunner.populateBaseArtifacts(passContext);
          isFirstPass = false;
        }
      }
    
      await GatherRunner.disposeDriver(driver, options);
      return finalizeArtifacts(baseArtifacts, artifacts);
    } catch (err) {
      // Clean up on error. Don't await so that the root error, not a disposal error, is shown.
      GatherRunner.disposeDriver(driver, options);
    
      throw err;
    }
}

  _connectToSocket(response) {
    const url = response.webSocketDebuggerUrl;
    this._pageId = response.id;

    return new Promise((resolve, reject) => {
      const ws = new WebSocket(url, {
        perMessageDeflate: false,
      });
      ws.on('open', () => {
        this._ws = ws;
        resolve();
      });
      ws.on('message', data => this.handleRawMessage(/** @type {string} */ (data)));
      ws.on('close', this.dispose.bind(this));
      ws.on('error', reject);
    });
  }
  
  
  
   static async setupDriver(driver, options) {
    //...
    await GatherRunner.assertNoSameOriginServiceWorkerClients(session, options.requestedUrl);
 // 6. Preparing target for navigation mode,通過為全局 API 或錯誤處理啟用協(xié)議域、仿真和新文檔處理程序，準備在導航模式下分析的目標。 
    await prepare.prepareTargetForNavigationMode(driver, options.settings);
  }
  
  static async runPass(passContext) {
   //7. Running defaultPass pass

    const gathererResults = {};
    const {driver, passConfig} = passContext;

    // 8.Resetting state with about:blank 9.Navigating to about:blankGo to about:blank
 // set up

    await GatherRunner.loadBlank(driver, passConfig.blankPage);
 // 10.Preparing target for navigation ~ 13.Preparing network conditions
    const {warnings} = await prepare.prepareTargetForIndividualNavigation(
      driver.defaultSession,
      passContext.settings,
      {
        requestor: passContext.url,
        disableStorageReset: !passConfig.useThrottling,
        disableThrottling: !passConfig.useThrottling,
        blockedUrlPatterns: passConfig.blockedUrlPatterns,
      }
    );
    // run `startInstrumentation() /beforePass()` on gatherers.
    passContext.LighthouseRunWarnings.push(...warnings);
    await GatherRunner.beforePass(passContext, gathererResults);

    // 14.Beginning devtoolsLog and trace,
    //    await driver.beginDevtoolsLog(); await driver.beginTrace(settings);
    await GatherRunner.beginRecording(passContext);
     //15.Loading page & waiting for onload ,16.Navigating to https:XXX
    const {navigationError: possibleNavError} = await GatherRunner.loadPage(driver, passContext);
     //17.Gathering in-page: XXXXXXXX,run `pass()` on gatherers.
    await GatherRunner.pass(passContext, gathererResults);
    const loadData = await GatherRunner.endRecording(passContext);

     //18.Gathering trace 19.Gathering devtoolsLog & network records
    await emulation.clearThrottling(driver.defaultSession);

        //process page error

    // If no error, save devtoolsLog and trace.
    GatherRunner._addLoadDataToBaseArtifacts(passContext, loadData, passConfig.passName);

     //  20.Gathering XXX.  Run `afterPass()(stopInstrumentation -> getArtifact )` on gatherers and return collected artifacts. 
    await GatherRunner.afterPass(passContext, loadData, gathererResults);
    const artifacts = GatherRunner.collectArtifacts(gathererResults);

 
    return artifacts;
  }

{
    audits: [
        'first-contentful-paint',
        'byte-efficiency/uses-optimized-images',
    ]
}

async function legacyNavigation(url, flags = {}, configJSON, userConnection) {
    //... 
  return Runner.audit(artifacts, options);
}
  static async audit(artifacts, options) {

        //...
       //1. Analyzing and running audits &2.Auditing: XXX
      const auditResultsById = await Runner._runAudits(settings, config.audits, artifacts,
          lighthouseRunWarnings, computedCache);

   //3.Generating results...  
      if (artifacts.LighthouseRunWarnings) {
        lighthouseRunWarnings.push(...artifacts.LighthouseRunWarnings);
      }

      //....

  }

static async audit(artifacts, options) {
  
  //....
  //conclusion of the lighthouse result object
  const axeVersion = artifacts.Accessibility?.version;
      const credits = {
        'axe-core': axeVersion,
      }
      let categories = {};
      if (config.categories) {
        categories = ReportScoring.scoreAllCategories(config.categories, auditResultsById);
      }
      // Replace ICU message references with localized strings; save replaced paths in lhr.
      i18nLhr.i18n.icuMessagePaths = format.replaceIcuMessages(i18nLhr, settings.locale);
      // LHR has now been localized.
      const lhr = /** @type {LH.Result} */ (i18nLhr);
      if (settings.auditMode) {
        const path = Runner._getDataSavePath(settings);
        assetSaver.saveLhr(lhr, path);
      }
      // 生成報告
      const report = ReportGenerator.generateReport(lhr, settings.output);
      return {lhr, artifacts, report};
}