tor-browser

commit 6096d75e23e25ba7a24e2cd5ffc30ff86f484d94
parent 6c32c84c319590ccc055b85fa0185ed3ee721139
Author: Greg Tatum <tatum.creative@gmail.com>
Date:   Fri, 31 Oct 2025 15:04:31 +0000

Bug 1996291 - Adjust the flow for accessing the MLEngine to make the types correct r=firefox-ai-ml-reviewers,tarek

This changes the implementation a bit, but the flow should have the
exact same behavior. The ready status is not being applied in a promise
which should run before any other code. You can still check if the
engine is ready by awaiting on the engine. However, now when you need
the engine you just await the #engine property.

The documentation for the type was incorrect to what it actually was as
the #engine was original wrapped in a promise, then it was unwrapped,
which was a bit confusing to work with.

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

Diffstat:
M
toolkit/components/ml/actors/MLEngineChild.sys.mjs
 | 
37
++++++++++++++++++-------------------

1 file changed, 18 insertions(+), 19 deletions(-)
diff --git a/toolkit/components/ml/actors/MLEngineChild.sys.mjs b/toolkit/components/ml/actors/MLEngineChild.sys.mjs
@@ -151,7 +151,7 @@ export class MLEngineChild extends JSProcessActorChild {
       // NOTE: This is done after adding to #engineDispatchers to ensure other
       // async calls see the new dispatcher.
       if (!lazy.PipelineOptions.isMocked(pipelineOptions)) {
-        await dispatcher.ensureInferenceEngineIsReady();
+        await dispatcher.isReady();
       }
 
       this.#engineStatuses.set(engineId, "READY");
@@ -314,8 +314,8 @@ class EngineDispatcher {
   /** @type {PromiseWithResolvers} */
   #modelRequest;
 
-  /** @type {Promise<InferenceEngine> | null} */
-  #engine = null;
+  /** @type {Promise<InferenceEngine>} */
+  #engine;
 
   /** @type {string} */
   #taskName;
@@ -429,9 +429,12 @@ class EngineDispatcher {
       }
     );
 
-    // Trigger the keep alive timer.
     this.#engine
-      .then(() => void this.keepAlive())
+      .then(() => {
+        this.#status = "READY";
+        // Trigger the keep alive timer.
+        void this.keepAlive();
+      })
       .catch(error => {
         if (
           // Ignore errors from tests intentionally causing errors.
@@ -455,14 +458,6 @@ class EngineDispatcher {
     };
   }
 
-  /**
-   * Resolves the engine to fully initialize it.
-   */
-  async ensureInferenceEngineIsReady() {
-    this.#engine = await this.#engine;
-    this.#status = "READY";
-  }
-
   handleInitProgressStatus(port, notificationsData) {
     port.postMessage({
       type: "EnginePort:InitProgress",
@@ -508,6 +503,13 @@ class EngineDispatcher {
   }
 
   /**
+   * Wait for the engine to be ready.
+   */
+  async isReady() {
+    await this.#engine;
+  }
+
+  /**
    * @param {MessagePort} port
    */
   #setupMessageHandler(port) {
@@ -544,7 +546,7 @@ class EngineDispatcher {
         case "EnginePort:Run": {
           const { requestId, request, engineRunOptions } = data;
           try {
-            await this.ensureInferenceEngineIsReady();
+            await this.isReady();
           } catch (error) {
             port.postMessage({
               type: "EnginePort:RunResponse",
@@ -565,15 +567,12 @@ class EngineDispatcher {
           this.keepAlive();
 
           this.#status = "RUNNING";
+          const engine = await this.#engine;
           try {
             port.postMessage({
               type: "EnginePort:RunResponse",
               requestId,
-              response: await this.#engine.run(
-                request,
-                requestId,
-                engineRunOptions
-              ),
+              response: await engine.run(request, requestId, engineRunOptions),
               error: null,
             });
           } catch (error) {