HWInferenceParent.cpp

firefox-main/toolkit/components/ml/ipc/HWInferenceParent.cpp (file symbol)

Enable keyboard shortcuts

Source code

Revision control

Copy as Markdown

Other Tools

HG Web

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mozilla/Preferences.h"

#include "mozilla/StaticPrefs_browser.h"

#include "mozilla/StaticPtr.h"

#include "nsTHashSet.h"

#include "HWInferenceParent.h"

#include "mozilla/dom/Blob.h"

#include "mozilla/dom/BlobBinding.h"

#include "mozilla/ipc/FileDescriptor.h"

#include "mozilla/ipc/UtilityProcessParent.h"

#include "mozilla/ipc/UtilityProcessManager.h"

#include "mozilla/dom/Promise.h"

#include "mozilla/dom/Promise-inl.h"

#include "mozilla/dom/FileBlobImpl.h"

#include "mozilla/dom/IPCBlobUtils.h"

#include "mozilla/dom/Blob.h"

#include "mozilla/dom/BlobBinding.h"

#include "mozilla/ErrorNames.h"

#include "nsIFileStreams.h"

#include "nsIInputStream.h"

#include "mozilla/ErrorResult.h"

#include "nsID.h"

#include "nsString.h"

#include "nsFmtString.h"

#include "mozilla/Logging.h"

#include "mozilla/Services.h"

#include "mozilla/dom/WindowGlobalParent.h"

#include "nsComponentManagerUtils.h"

#include "nsIMLModelHub.h"

#include "nsIMLModelResolver.h"

#include "nsIObserverService.h"

#include "nsIWritablePropertyBag2.h"

#include "nsServiceManagerUtils.h"

#include "prio.h"

#include "private/pprio.h"

#ifdef XP_WIN

#  include <windows.h>

#endif

namespace mozilla::hwinference {

extern LazyLogModule gHWInferenceLog;

#define LOGE(...) MOZ_LOG_FMT(gHWInferenceLog, LogLevel::Error, __VA_ARGS__)

#define LOGD(...) MOZ_LOG_FMT(gHWInferenceLog, LogLevel::Debug, __VA_ARGS__)

#define LOGV(...) MOZ_LOG_FMT(gHWInferenceLog, LogLevel::Verbose, __VA_ARGS__)

StaticRefPtr<HWInferenceParent> HWInferenceParent::sInstance;

static StaticAutoPtr<nsTHashSet<nsCString>> sMockInstalledModels;

// The mock hub's contents live only as long as browser.ml.modelHub.testing is

// on, so a test that pushes that pref starts from an empty hub rather than

// inheriting whatever an earlier test in the same run installed.

static void ClearMockInstalledModels(const char*, void*) {

  if (sMockInstalledModels) {

    sMockInstalledModels->Clear();

static nsCString MockModelKey(const nsACString& aModel,

                              const nsACString& aRevision,

                              const nsACString& aFilename) {

  return nsFmtCString("{}/{}/{}", aModel, aRevision, aFilename);

// Expands aId to a concrete ModelHub artifact via the resolver registered for

// aTask (contract id "@mozilla.org/ml/model-resolver;1?task=<task>"). Returns

// that resolver, so a caller needing more of it (e.g. AuthorizeDownload) does

// not have to look it up again, or nullptr if aTask has no resolver or aId is

// not one of its ids.

static already_AddRefed<nsIMLModelResolver> ResolveModelId(

    const nsACString& aTask, const nsACString& aId, nsCString& aEngine,

    nsCString& aModel, nsCString& aRevision, nsCString& aFilename) {

  nsFmtCString contractId("@mozilla.org/ml/model-resolver;1?task={}", aTask);

  nsCOMPtr<nsIMLModelResolver> resolver = do_GetService(contractId.get());

  if (!resolver) {

    LOGE("ResolveModelId - no resolver registered for task {}", aTask);

    return nullptr;

  nsresult rv = resolver->Resolve(aId, aEngine, aModel, aRevision, aFilename);

  if (NS_FAILED(rv)) {

    LOGE("ResolveModelId - id {} not recognized for task {}", aId, aTask);

    return nullptr;

  return resolver.forget();

// Reports a download's progress and its outcome: ModelHub always drives both

// together, and the completion side needs to emit a final progress

// notification, so this is a single object implementing both interfaces.

// Progress is broadcast as "ml-model-download-progress", tagged with the

// download's progress token so an observer can tell downloads apart.

class ModelDownloadCallbacks final

    : public nsIMLModelDownloadProgressCallback,

      public nsIMLModelDownloadCompletionCallback {

 public:

  NS_DECL_ISUPPORTS

  ModelDownloadCallbacks(const nsACString& aModel,

                         const nsAString& aProgressToken,

                         HWInferenceParent::InstallModelResolver&& aResolver)

      : mModel(aModel),

        mProgressToken(aProgressToken),

        mResolver(std::move(aResolver)) {}

  NS_IMETHOD OnProgress(int32_t aProgress, int64_t aCurrentLoaded,

                        int64_t aTotalLoaded, int64_t aTotal) override {

    LOGV("{} - model={} progress={}% current={} total loaded={} total={}",

         __func__, mModel, aProgress, aCurrentLoaded, aTotalLoaded, aTotal);

    // aProgress is already a whole percentage (0-100), reported for every

    // chunk received, which for a model that can be hundreds of megabytes is

    // far more often than it actually changes.

    if (aProgress == mLastNotifiedProgress) {

      return NS_OK;

    mLastNotifiedProgress = aProgress;

    Notify(aProgress, aCurrentLoaded, aTotalLoaded, aTotal, false, true);

    return NS_OK;

  NS_IMETHOD OnSuccess(const nsAString& aModel,

                       const nsAString& aRevision) override {

    LOGD("{} - model={} revision={}", __func__, NS_ConvertUTF16toUTF8(aModel),

         NS_ConvertUTF16toUTF8(aRevision));

    Notify(100, 0, 0, 0, true, true);

    mResolver(ModelInstallResult::Installed);

    return NS_OK;

  NS_IMETHOD OnError(const nsAString& aError) override {

    LOGE("{} - Error when downloading {}", __func__,

         NS_ConvertUTF16toUTF8(aError));

    Notify(0, 0, 0, 0, true, false);

    mResolver(ModelInstallResult::Failed);

    return NS_OK;

 private:

  ~ModelDownloadCallbacks() = default;

  void Notify(int32_t aProgress, int64_t aCurrentLoaded, int64_t aTotalLoaded,

              int64_t aTotal, bool aDone, bool aOk) {

    nsCOMPtr<nsIObserverService> obs = services::GetObserverService();

    if (!obs) {

      return;

    nsCOMPtr<nsIWritablePropertyBag2> props =

        do_CreateInstance("@mozilla.org/hash-property-bag;1");

    props->SetPropertyAsAString(u"token"_ns, mProgressToken);

    props->SetPropertyAsInt32(u"progress"_ns, aProgress);

    props->SetPropertyAsInt64(u"currentLoaded"_ns, aCurrentLoaded);

    props->SetPropertyAsInt64(u"totalLoaded"_ns, aTotalLoaded);

    props->SetPropertyAsInt64(u"total"_ns, aTotal);

    props->SetPropertyAsBool(u"done"_ns, aDone);

    props->SetPropertyAsBool(u"ok"_ns, aOk);

    obs->NotifyObservers(props, "ml-model-download-progress", nullptr);

  nsCString mModel;

  nsString mProgressToken;

  HWInferenceParent::InstallModelResolver mResolver;

  int32_t mLastNotifiedProgress = -1;

};

NS_IMPL_ISUPPORTS(ModelDownloadCallbacks, nsIMLModelDownloadProgressCallback,

                  nsIMLModelDownloadCompletionCallback)

/* static */

RefPtr<HWInferenceParent> HWInferenceParent::GetSingleton() {

  AssertIsOnMainThread();

  // Evict an instance bound to a process that is no longer the current one.

  // PHWInference is separate from PUtilityProcess, so it keeps reporting

  // CanSend() for a main-thread dispatch after the peer died, and handing it

  // out in that window would have StartUtility resolve on a doomed actor.

  // Comparing the bound process also covers process death, not just

  // CleanShutdown.

  if (sInstance && sInstance->mUtilityParent) {

    RefPtr<ipc::UtilityProcessManager> upm =

        ipc::UtilityProcessManager::GetIfExists();

    if (!upm || upm->GetProcessParent(ipc::SandboxingKind::HW_INFERENCE) !=

                    sInstance->mUtilityParent) {

      LOGD("{} - evicting instance bound to a gone process", __func__);

      RefPtr<HWInferenceParent> stale = sInstance;

      sInstance = nullptr;

      // Synchronously runs ActorDestroy, so CanSend() is false on return.

      stale->Close();

  if (!sInstance) {

    sInstance = new HWInferenceParent();

    ClearOnShutdown(&sInstance);

  return sInstance;

/* static */

void HWInferenceParent::StartContentSpeechRecognition(

    Endpoint<PSpeechRecognitionParent>&& aEndpoint,

    dom::ContentParentId aChildId) {

  RefPtr<HWInferenceParent> self = GetSingleton();

  self->WhenReady()->Then(

      GetMainThreadSerialEventTarget(), __func__,

      [self, endpoint = std::move(aEndpoint), aChildId]() mutable {

        if (!self->SendNewContentSpeechRecognition(std::move(endpoint),

                                                   aChildId)) {

          LOGD("Failed to send endpoint to utility process");

},

      []() {

        LOGD("HWInference never came up: dropping the speech endpoint");

});

void HWInferenceParent::ActorDestroy(ActorDestroyReason aReason) {

  LOGD("{}", __func__);

  // A no-op once bound: let go of anyone waiting on an actor that never made it

  // to its process.

  mReadyPromise->Reject(NS_ERROR_NOT_AVAILABLE, __func__);

  mUtilityParent = nullptr;

  // Only clear ourselves: a late ActorDestroy from a superseded instance must

  // not evict the replacement created after it.

  if (sInstance == this) {

    sInstance = nullptr;

nsresult HWInferenceParent::BindToUtilityProcess(

    const RefPtr<ipc::UtilityProcessParent>& aUtilityParent) {

  LOGD("{}", __func__);

  Endpoint<hwinference::PHWInferenceParent> parentEnd;

  Endpoint<hwinference::PHWInferenceChild> childEnd;

  MOZ_ALWAYS_SUCCEEDS(PHWInference::CreateEndpoints(

      ipc::EndpointProcInfo::Current(), aUtilityParent->OtherEndpointProcInfo(),

      &parentEnd, &childEnd));

  LOGD("Sending StartHWInferenceService to utility process");

  if (!aUtilityParent->SendStartHWInferenceService(std::move(childEnd))) {

    LOGE("Failed to send StartHWInferenceService");

    MOZ_ASSERT(false, "StartHWInference service failure");

    return NS_ERROR_FAILURE;

  LOGD("StartHWInferenceService sent successfully, binding parent endpoint");

  MOZ_ALWAYS_TRUE(parentEnd.Bind(this));

  mUtilityParent = aUtilityParent;

  mReadyPromise->Resolve(true, __func__);

  return NS_OK;

mozilla::ipc::IPCResult HWInferenceParent::RecvIsModelAvailable(

    nsCString&& aTask, nsCString&& aId, IsModelAvailableResolver&& aResolver) {

  LOGD("{}: task={} id={}", __func__, aTask, aId);

  nsCString engine, model, revision, filename;

  nsCOMPtr<nsIMLModelResolver> resolver =

      ResolveModelId(aTask, aId, engine, model, revision, filename);

  if (!resolver) {

    aResolver(false);

    return IPC_OK();

  if (StaticPrefs::browser_ml_modelHub_testing()) {

    bool available =

        sMockInstalledModels &&

        sMockInstalledModels->Contains(MockModelKey(model, revision, filename));

    LOGD("{} - testing mock: available={}", __func__, available);

    aResolver(available);

    return IPC_OK();

  nsCOMPtr<nsIMLModelHub> modelHubService =

      do_GetService("@mozilla.org/ml-modelhub;1");

  if (!modelHubService) {

    LOGE("{} - Failed to get ModelHub XPCOM service", __func__);

    aResolver(false);

    return IPC_OK();

  RefPtr<dom::Promise> promise;

  nsresult rv = modelHubService->IsModelAvailable(

      engine, model, revision, filename, getter_AddRefs(promise));

  if (NS_FAILED(rv) || !promise) {

    LOGE("{}  ERROR: ModelHub call failed with nsresult={}", __func__, rv);

    aResolver(false);

    return IPC_OK();

  (void)promise->AddCallbacksWithCycleCollectedArgs(

      [aResolver](JSContext* aCx, JS::Handle<JS::Value> aArg,

                  ErrorResult& aRv) { aResolver(JS::ToBoolean(aArg)); },

      [aResolver](JSContext* aCx, JS::Handle<JS::Value> aArg,

                  ErrorResult& aRv) { aResolver(false); });

  return IPC_OK();

mozilla::ipc::IPCResult HWInferenceParent::RecvIsModelInstalled(

    nsCString&& aTask, nsCString&& aId, IsModelInstalledResolver&& aResolver) {

  LOGD("{}: task={} id={}", __func__, aTask, aId);

  nsCString engine, model, revision, filename;

  nsCOMPtr<nsIMLModelResolver> resolver =

      ResolveModelId(aTask, aId, engine, model, revision, filename);

  if (!resolver) {

    aResolver(false);

    return IPC_OK();

  if (StaticPrefs::browser_ml_modelHub_testing()) {

    bool installed =

        sMockInstalledModels &&

        sMockInstalledModels->Contains(MockModelKey(model, revision, filename));

    LOGD("{} - testing mock: installed={}", __func__, installed);

    aResolver(installed);

    return IPC_OK();

  nsCOMPtr<nsIMLModelHub> modelHubService =

      do_GetService("@mozilla.org/ml-modelhub;1");

  if (!modelHubService) {

    LOGE("{} - Failed to get ModelHub XPCOM service", __func__);

    aResolver(false);

    return IPC_OK();

  RefPtr<dom::Promise> promise;

  nsresult rv = modelHubService->IsModelInstalled(

      engine, model, revision, filename, getter_AddRefs(promise));

  if (NS_FAILED(rv) || !promise) {

    LOGE("{}  ERROR: ModelHub call failed with nsresult={}", __func__, rv);

    aResolver(false);

    return IPC_OK();

  (void)promise->AddCallbacksWithCycleCollectedArgs(

      [aResolver](JSContext* aCx, JS::Handle<JS::Value> aArg,

                  ErrorResult& aRv) { aResolver(JS::ToBoolean(aArg)); },

      [aResolver](JSContext* aCx, JS::Handle<JS::Value> aArg,

                  ErrorResult& aRv) { aResolver(false); });

  return IPC_OK();

// Performs the actual model download (or testing-mock install) and resolves

// aResolver with the outcome. Honors the testing mock. Only reached after the

// task's resolver has authorized the download.

static void PerformModelInstall(

    const nsCString& aEngine, const nsCString& aTask, const nsCString& aModel,

    const nsCString& aRevision, const nsCString& aFilename,

    const nsString& aProgressToken,

    HWInferenceParent::InstallModelResolver&& aResolver) {

  if (StaticPrefs::browser_ml_modelHub_testing()) {

    if (!sMockInstalledModels) {

      sMockInstalledModels = new nsTHashSet<nsCString>();

      ClearOnShutdown(&sMockInstalledModels);

      Preferences::RegisterCallback(ClearMockInstalledModels,

                                    "browser.ml.modelHub.testing");

    sMockInstalledModels->Insert(MockModelKey(aModel, aRevision, aFilename));

    LOGD("PerformModelInstall - testing mock: installed {}",

         MockModelKey(aModel, aRevision, aFilename));

    aResolver(ModelInstallResult::Installed);

    return;

  nsCOMPtr<nsIMLModelHub> modelHubService =

      do_GetService("@mozilla.org/ml-modelhub;1");

  if (!modelHubService) {

    LOGE("PerformModelInstall - Failed to get ModelHub XPCOM service");

    aResolver(ModelInstallResult::Failed);

    return;

  nsTArray<nsCString> files;

  files.AppendElement(aFilename);

  auto callbacks = MakeRefPtr<ModelDownloadCallbacks>(aModel, aProgressToken,

                                                      std::move(aResolver));

  nsString downloadSessionId;

  nsresult rv = modelHubService->DownloadModel(

      aEngine, aTask, aModel, aRevision, files, aProgressToken, callbacks,

      callbacks, downloadSessionId);

  if (NS_FAILED(rv) || downloadSessionId.IsEmpty()) {

    LOGE(

        "PerformModelInstall - ERROR: ModelHub DownloadModel call failed "

        "with nsresult={}",

        rv);

    callbacks->OnError(u"Failed to start download"_ns);

    return;

  LOGD(

      "PerformModelInstall - download started successfully with session ID: {}",

      NS_ConvertUTF16toUTF8(downloadSessionId));

// Bridges nsIMLModelResolver::AuthorizeDownload's decision back to the pending

// InstallModel: on allow it performs the download, on deny it resolves the

// install false.

class ModelDownloadAuthorizationCallback final

    : public nsIMLModelDownloadAuthorizationCallback {

 public:

  NS_DECL_ISUPPORTS

  ModelDownloadAuthorizationCallback(

      const nsACString& aEngine, const nsACString& aTask,

      const nsACString& aModel, const nsACString& aRevision,

      const nsACString& aFilename, const nsAString& aProgressToken,

      HWInferenceParent::InstallModelResolver&& aResolver)

      : mEngine(aEngine),

        mTask(aTask),

        mModel(aModel),

        mRevision(aRevision),

        mFilename(aFilename),

        mProgressToken(aProgressToken),

        mResolver(std::move(aResolver)) {}

  NS_IMETHOD Resolve(bool aAllow) override {

    if (!mResolver) {

      return NS_OK;

    auto resolver = std::move(mResolver);

    mResolver = nullptr;

    if (!aAllow) {

      LOGD("ModelDownloadAuthorizationCallback - download of {} not authorized",

           mModel);

      resolver(ModelInstallResult::Denied);

      return NS_OK;

    PerformModelInstall(mEngine, mTask, mModel, mRevision, mFilename,

                        mProgressToken, std::move(resolver));

    return NS_OK;

 private:

  ~ModelDownloadAuthorizationCallback() {

    if (mResolver) {

      mResolver(ModelInstallResult::Failed);

  nsCString mEngine;

  nsCString mTask;

  nsCString mModel;

  nsCString mRevision;

  nsCString mFilename;

  nsString mProgressToken;

  HWInferenceParent::InstallModelResolver mResolver;

};

NS_IMPL_ISUPPORTS(ModelDownloadAuthorizationCallback,

                  nsIMLModelDownloadAuthorizationCallback)

ipc::IPCResult HWInferenceParent::RecvInstallModel(

    nsCString&& aTask, nsCString&& aId, uint64_t aInnerWindowId,

    const dom::ContentParentId& aContentId, InstallModelResolver&& aResolver) {

  LOGD("{} task={} id={}", __func__, aTask, aId);

  nsCString engine, model, revision, filename;

  nsCOMPtr<nsIMLModelResolver> resolver =

      ResolveModelId(aTask, aId, engine, model, revision, filename);

  if (!resolver) {

    aResolver(ModelInstallResult::Failed);

    return IPC_OK();

  // A privileged-chrome request sends a 0 content id: nothing to validate,

  // and the resolver gets a null window.

  RefPtr<dom::WindowGlobalParent> window =

      dom::WindowGlobalParent::GetByInnerWindowId(aInnerWindowId);

  if (aContentId != 0 && (!window || window->ContentParentId() != aContentId)) {

    LOGE("{} - window {} not owned by requester {}", __func__, aInnerWindowId,

         uint64_t(aContentId));

    aResolver(ModelInstallResult::Failed);

    return IPC_OK();

  // The mock lives only here, so install and availability agree on what has

  // been "downloaded". Outside testing, the resolver skips installed models.

  if (StaticPrefs::browser_ml_modelHub_testing() && sMockInstalledModels &&

      sMockInstalledModels->Contains(MockModelKey(model, revision, filename))) {

    LOGD("{} - testing mock: already installed", __func__);

    aResolver(ModelInstallResult::Installed);

    return IPC_OK();

  // Tags this download's "ml-model-download-progress" notifications, and is

  // what a consumer hands back to stop it. Created here so that nothing

  // outside the parent gets to choose it.

  nsString progressToken;

  AppendUTF8toUTF16(

      nsDependentCString(nsIDToCString(nsID::GenerateUUID()).get()),

      progressToken);

  auto callback = MakeRefPtr<ModelDownloadAuthorizationCallback>(

      engine, aTask, model, revision, filename, progressToken,

      std::move(aResolver));

  resolver->AuthorizeDownload(model, revision, filename, window, progressToken,

                              callback);

  return IPC_OK();

static nsresult BlobJSObjectToFileDescriptor(JSContext* aCx,

                                             JS::Handle<JS::Value> aValue,

                                             ipc::FileDescriptor* aDesc) {

  if (!aValue.isObject()) {

    return NS_ERROR_UNEXPECTED;

  RefPtr<dom::Blob> blob;

  nsresult rv = UNWRAP_OBJECT(Blob, &aValue.toObject(), blob);

  if (NS_FAILED(rv)) {

    LOGE("BlobJSObjectToFileDescriptor - ERROR: Failed to unwrap Blob: {}", rv);

    return rv;

  ErrorResult errorResult;

  nsCOMPtr<nsIInputStream> stream;

  blob->CreateInputStream(getter_AddRefs(stream), errorResult);

  if (errorResult.Failed()) {

    LOGE(

        "BlobJSObjectToFileDescriptor - ERROR: Failed to create input stream "

        "from blob");

    return NS_ERROR_UNEXPECTED;

  nsCOMPtr<nsIFileMetadata> fileMetadata = do_QueryInterface(stream);

  if (!fileMetadata) {

    LOGE(

        "BlobJSObjectToFileDescriptor - ERROR: Stream doesn't support "

        "nsIFileMetadata");

    return NS_ERROR_UNEXPECTED;

  PRFileDesc* fileDesc;

  nsresult getRv = fileMetadata->GetFileDescriptor(&fileDesc);

  if (NS_FAILED(getRv)) {

    LOGE("BlobJSObjectToFileDescriptor - ERROR: GetFileDescriptor failed: {}",

         getRv);

    return getRv;

  ipc::FileDescriptor fd(ipc::FileDescriptor::PlatformHandleType(

      PR_FileDesc2NativeHandle(fileDesc)));

  if (!fd.IsValid()) {

    LOGE("BlobJSObjectToFileDescriptor - ERROR: Failed to get native handle");

    return NS_ERROR_UNEXPECTED;

  *aDesc = std::move(fd);

  return NS_OK;

ipc::IPCResult HWInferenceParent::RecvGetModelFile(

    nsCString&& aTask, nsCString&& aId, GetModelFileResolver&& aResolver) {

  LOGD("{} task={} id={}", __func__, aTask.get(), aId.get());

  nsCString engine, model, revision, filename;

  nsCOMPtr<nsIMLModelResolver> resolver =

      ResolveModelId(aTask, aId, engine, model, revision, filename);

  if (!resolver) {

    GetModelError error;

    error.errorCode() = NS_ERROR_NOT_AVAILABLE;

    aResolver(GetModelFileResult(error));

    return IPC_OK();

  nsCOMPtr<nsIMLModelHub> modelHubService =

      do_GetService("@mozilla.org/ml-modelhub;1");

  if (!modelHubService) {

    LOGE("{} - ERROR: Failed to get ModelHub XPCOM service", __func__);

    GetModelError error;

    error.errorCode() = NS_ERROR_FAILURE;

    aResolver(GetModelFileResult(error));

    return IPC_OK();

  RefPtr<dom::Promise> promise;

  nsresult rv = modelHubService->GetModelBlob(

      engine, aTask, model, revision, filename, getter_AddRefs(promise));

  if (NS_FAILED(rv)) {

    LOGE("{} - ERROR: GetModelBlob call failed with rv={}", __func__, rv);

    GetModelError error;

    error.errorCode() = rv;

    aResolver(GetModelFileResult(error));

    return IPC_OK();

  promise->AddCallbacksWithCycleCollectedArgs(

      [aResolver](JSContext* aCx, JS::Handle<JS::Value> aValue,

                  ErrorResult& aRv) {

        GetModelFileSuccess success;

        nsresult rv = BlobJSObjectToFileDescriptor(aCx, aValue, &success.fd());

        if (NS_FAILED(rv)) {

          aResolver(GetModelFileResult(GetModelError(rv)));

          return;

        MOZ_ASSERT(success.fd().IsValid());

        aResolver(GetModelFileResult(std::move(success)));

},

      [aResolver](JSContext* aCx, JS::Handle<JS::Value> aValue,

                  ErrorResult& aRv) {

        LOGE("RecvGetModelFile - ERROR: promise rejected in RecvGetModelFile");

        GetModelError error;

        error.errorCode() = NS_ERROR_FAILURE;

        aResolver(GetModelFileResult(error));

});

  return IPC_OK();

}  // namespace mozilla::hwinference

#undef LOGD

#undef LOGV

#undef LOGE