xpconnect/loader/mozJSComponentLoader.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/Attributes.h"
#include "mozilla/Utf8.h"  // mozilla::Utf8Unit

#include <cstdarg>

#include "mozilla/Logging.h"
#ifdef ANDROID
#  include <android/log.h>
#endif
#ifdef XP_WIN
#  include <windows.h>
#endif

#include "jsapi.h"
#include "js/Array.h"  // JS::GetArrayLength, JS::IsArrayObject
#include "js/CharacterEncoding.h"
#include "js/CompilationAndEvaluation.h"
#include "js/CompileOptions.h"         // JS::CompileOptions
#include "js/friend/JSMEnvironment.h"  // JS::ExecuteInJSMEnvironment, JS::GetJSMEnvironmentOfScriptedCaller, JS::NewJSMEnvironment
#include "js/Object.h"                 // JS::GetCompartment
#include "js/Printf.h"
#include "js/PropertySpec.h"
#include "js/SourceText.h"  // JS::SourceText
#include "nsCOMPtr.h"
#include "nsDirectoryServiceDefs.h"
#include "nsDirectoryServiceUtils.h"
#include "nsExceptionHandler.h"
#include "nsIComponentManager.h"
#include "mozilla/Module.h"
#include "nsIFile.h"
#include "mozJSComponentLoader.h"
#include "mozJSLoaderUtils.h"
#include "nsIFileURL.h"
#include "nsIJARURI.h"
#include "nsIChannel.h"
#include "nsNetUtil.h"
#include "nsJSPrincipals.h"
#include "nsJSUtils.h"
#include "xpcprivate.h"
#include "xpcpublic.h"
#include "nsContentUtils.h"
#include "nsReadableUtils.h"
#include "nsXULAppAPI.h"
#include "WrapperFactory.h"

#include "AutoMemMap.h"
#include "ScriptPreloader-inl.h"

#include "mozilla/scache/StartupCache.h"
#include "mozilla/scache/StartupCacheUtils.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/MacroForEach.h"
#include "mozilla/Preferences.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/ProfilerMarkers.h"
#include "mozilla/ResultExtensions.h"
#include "mozilla/ScriptPreloader.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/dom/AutoEntryScript.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/ResultExtensions.h"
#include "mozilla/UniquePtrExtensions.h"
#include "mozilla/Unused.h"

using namespace mozilla;
using namespace mozilla::scache;
using namespace mozilla::loader;
using namespace xpc;
using namespace JS;

#define JS_CACHE_PREFIX(aType) "jsloader/" aType

/**
 * Buffer sizes for serialization and deserialization of scripts.
 * FIXME: bug #411579 (tune this macro!) Last updated: Jan 2008
 */
#define XPC_SERIALIZATION_BUFFER_SIZE (64 * 1024)
#define XPC_DESERIALIZATION_BUFFER_SIZE (12 * 8192)

// MOZ_LOG=JSComponentLoader:5
static LazyLogModule gJSCLLog("JSComponentLoader");

#define LOG(args) MOZ_LOG(gJSCLLog, mozilla::LogLevel::Debug, args)

// Components.utils.import error messages
#define ERROR_SCOPE_OBJ "%s - Second argument must be an object."
#define ERROR_NO_TARGET_OBJECT "%s - Couldn't find target object for import."
#define ERROR_NOT_PRESENT "%s - EXPORTED_SYMBOLS is not present."
#define ERROR_NOT_AN_ARRAY "%s - EXPORTED_SYMBOLS is not an array."
#define ERROR_GETTING_ARRAY_LENGTH \
  "%s - Error getting array length of EXPORTED_SYMBOLS."
#define ERROR_ARRAY_ELEMENT "%s - EXPORTED_SYMBOLS[%d] is not a string."
#define ERROR_GETTING_SYMBOL "%s - Could not get symbol '%s'."
#define ERROR_SETTING_SYMBOL "%s - Could not set symbol '%s' on target object."
#define ERROR_UNINITIALIZED_SYMBOL \
  "%s - Symbol '%s' accessed before initialization. Cyclic import?"

static bool Dump(JSContext* cx, unsigned argc, Value* vp) {
  if (!nsJSUtils::DumpEnabled()) {
    return true;
  }

  CallArgs args = CallArgsFromVp(argc, vp);

  if (args.length() == 0) {
    return true;
  }

  RootedString str(cx, JS::ToString(cx, args[0]));
  if (!str) {
    return false;
  }

  JS::UniqueChars utf8str = JS_EncodeStringToUTF8(cx, str);
  if (!utf8str) {
    return false;
  }

  MOZ_LOG(nsContentUtils::DOMDumpLog(), mozilla::LogLevel::Debug,
          ("[Backstage.Dump] %s", utf8str.get()));
#ifdef ANDROID
  __android_log_print(ANDROID_LOG_INFO, "Gecko", "%s", utf8str.get());
#endif
#ifdef XP_WIN
  if (IsDebuggerPresent()) {
    nsAutoJSString wstr;
    if (!wstr.init(cx, str)) {
      return false;
    }
    OutputDebugStringW(wstr.get());
  }
#endif
  fputs(utf8str.get(), stdout);
  fflush(stdout);
  return true;
}

static bool Debug(JSContext* cx, unsigned argc, Value* vp) {
#ifdef DEBUG
  return Dump(cx, argc, vp);
#else
  return true;
#endif
}

static const JSFunctionSpec gGlobalFun[] = {
    JS_FN("dump", Dump, 1, 0), JS_FN("debug", Debug, 1, 0),
    JS_FN("atob", Atob, 1, 0), JS_FN("btoa", Btoa, 1, 0), JS_FS_END};

class MOZ_STACK_CLASS JSCLContextHelper {
 public:
  explicit JSCLContextHelper(JSContext* aCx);
  ~JSCLContextHelper();

  void reportErrorAfterPop(UniqueChars&& buf);

 private:
  JSContext* mContext;
  UniqueChars mBuf;

  // prevent copying and assignment
  JSCLContextHelper(const JSCLContextHelper&) = delete;
  const JSCLContextHelper& operator=(const JSCLContextHelper&) = delete;
};

static nsresult MOZ_FORMAT_PRINTF(2, 3)
    ReportOnCallerUTF8(JSContext* callerContext, const char* format, ...) {
  if (!callerContext) {
    return NS_ERROR_FAILURE;
  }

  va_list ap;
  va_start(ap, format);

  UniqueChars buf = JS_vsmprintf(format, ap);
  if (!buf) {
    va_end(ap);
    return NS_ERROR_OUT_OF_MEMORY;
  }

  JS_ReportErrorUTF8(callerContext, "%s", buf.get());

  va_end(ap);
  return NS_OK;
}

NS_IMPL_ISUPPORTS(mozJSComponentLoader, nsIMemoryReporter)

mozJSComponentLoader::mozJSComponentLoader()
    : mModules(16),
      mImports(16),
      mInProgressImports(16),
      mLocations(16),
      mInitialized(false),
      mLoaderGlobal(dom::RootingCx()) {
  MOZ_ASSERT(!sSelf, "mozJSComponentLoader should be a singleton");
}

#define ENSURE_DEP(name)          \
  {                               \
    nsresult rv = Ensure##name(); \
    NS_ENSURE_SUCCESS(rv, rv);    \
  }
#define ENSURE_DEPS(...) MOZ_FOR_EACH(ENSURE_DEP, (), (__VA_ARGS__));
#define BEGIN_ENSURE(self, ...) \
  {                             \
    if (m##self) return NS_OK;  \
    ENSURE_DEPS(__VA_ARGS__);   \
  }

class MOZ_STACK_CLASS ComponentLoaderInfo {
 public:
  explicit ComponentLoaderInfo(const nsACString& aLocation)
      : mLocation(aLocation) {}

  nsIIOService* IOService() {
    MOZ_ASSERT(mIOService);
    return mIOService;
  }
  nsresult EnsureIOService() {
    if (mIOService) {
      return NS_OK;
    }
    nsresult rv;
    mIOService = do_GetIOService(&rv);
    return rv;
  }

  nsIURI* URI() {
    MOZ_ASSERT(mURI);
    return mURI;
  }
  nsresult EnsureURI() {
    BEGIN_ENSURE(URI, IOService);
    return mIOService->NewURI(mLocation, nullptr, nullptr,
                              getter_AddRefs(mURI));
  }

  nsIChannel* ScriptChannel() {
    MOZ_ASSERT(mScriptChannel);
    return mScriptChannel;
  }
  nsresult EnsureScriptChannel() {
    BEGIN_ENSURE(ScriptChannel, IOService, URI);
    return NS_NewChannel(
        getter_AddRefs(mScriptChannel), mURI,
        nsContentUtils::GetSystemPrincipal(),
        nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
        nsIContentPolicy::TYPE_SCRIPT,
        nullptr,  // nsICookieJarSettings
        nullptr,  // aPerformanceStorage
        nullptr,  // aLoadGroup
        nullptr,  // aCallbacks
        nsIRequest::LOAD_NORMAL, mIOService);
  }

  nsIURI* ResolvedURI() {
    MOZ_ASSERT(mResolvedURI);
    return mResolvedURI;
  }
  nsresult EnsureResolvedURI() {
    BEGIN_ENSURE(ResolvedURI, URI);
    return ResolveURI(mURI, getter_AddRefs(mResolvedURI));
  }

  const nsACString& Key() { return mLocation; }

  [[nodiscard]] nsresult GetLocation(nsCString& aLocation) {
    nsresult rv = EnsureURI();
    NS_ENSURE_SUCCESS(rv, rv);
    return mURI->GetSpec(aLocation);
  }

 private:
  const nsACString& mLocation;
  nsCOMPtr<nsIIOService> mIOService;
  nsCOMPtr<nsIURI> mURI;
  nsCOMPtr<nsIChannel> mScriptChannel;
  nsCOMPtr<nsIURI> mResolvedURI;
};

template <typename... Args>
static nsresult ReportOnCallerUTF8(JSCLContextHelper& helper,
                                   const char* format,
                                   ComponentLoaderInfo& info, Args... args) {
  nsCString location;
  MOZ_TRY(info.GetLocation(location));

  UniqueChars buf = JS_smprintf(format, location.get(), args...);
  if (!buf) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  helper.reportErrorAfterPop(std::move(buf));
  return NS_ERROR_FAILURE;
}

#undef BEGIN_ENSURE
#undef ENSURE_DEPS
#undef ENSURE_DEP

mozJSComponentLoader::~mozJSComponentLoader() {
  MOZ_ASSERT(!mInitialized,
             "UnloadModules() was not explicitly called before cleaning up "
             "mozJSComponentLoader");

  if (mInitialized) {
    UnloadModules();
  }

  sSelf = nullptr;
}

StaticRefPtr<mozJSComponentLoader> mozJSComponentLoader::sSelf;

// For terrible compatibility reasons, we need to consider both the global
// lexical environment and the global of modules when searching for exported
// symbols.
static JSObject* ResolveModuleObjectProperty(JSContext* aCx,
                                             HandleObject aModObj,
                                             const char* name) {
  if (JS_HasExtensibleLexicalEnvironment(aModObj)) {
    RootedObject lexical(aCx, JS_ExtensibleLexicalEnvironment(aModObj));
    bool found;
    if (!JS_HasOwnProperty(aCx, lexical, name, &found)) {
      return nullptr;
    }
    if (found) {
      return lexical;
    }
  }
  return aModObj;
}

const mozilla::Module* mozJSComponentLoader::LoadModule(FileLocation& aFile) {
  if (!NS_IsMainThread()) {
    MOZ_ASSERT(false, "Don't use JS components off the main thread");
    return nullptr;
  }

  nsCOMPtr<nsIFile> file = aFile.GetBaseFile();

  nsCString spec;
  aFile.GetURIString(spec);
  ComponentLoaderInfo info(spec);
  nsresult rv = info.EnsureURI();
  NS_ENSURE_SUCCESS(rv, nullptr);

  mInitialized = true;

  AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING("mozJSComponentLoader::LoadModule",
                                        OTHER, spec);
  AUTO_PROFILER_MARKER_TEXT("JS XPCOM", JS, MarkerStack::Capture(), spec);

  ModuleEntry* mod;
  if (mModules.Get(spec, &mod)) {
    return mod;
  }

  dom::AutoJSAPI jsapi;
  jsapi.Init();
  JSContext* cx = jsapi.cx();

  auto entry = MakeUnique<ModuleEntry>(RootingContext::get(cx));
  RootedValue exn(cx);
  rv = ObjectForLocation(info, file, &entry->obj, &entry->thisObjectKey,
                         &entry->location, /* aPropagateExceptions */ false,
                         &exn);
  NS_ENSURE_SUCCESS(rv, nullptr);

  nsCOMPtr<nsIComponentManager> cm;
  rv = NS_GetComponentManager(getter_AddRefs(cm));
  if (NS_FAILED(rv)) {
    return nullptr;
  }

  JSAutoRealm ar(cx, entry->obj);
  RootedObject entryObj(cx, entry->obj);

  RootedObject NSGetFactoryHolder(
      cx, ResolveModuleObjectProperty(cx, entryObj, "NSGetFactory"));
  RootedValue NSGetFactory_val(cx);
  if (!NSGetFactoryHolder ||
      !JS_GetProperty(cx, NSGetFactoryHolder, "NSGetFactory",
                      &NSGetFactory_val) ||
      NSGetFactory_val.isUndefined()) {
    return nullptr;
  }

  if (JS_TypeOfValue(cx, NSGetFactory_val) != JSTYPE_FUNCTION) {
    /*
     * spec's encoding is ASCII unless it's zip file, otherwise it's
     * random encoding.  Latin1 variant is safe for random encoding.
     */
    JS_ReportErrorLatin1(
        cx, "%s has NSGetFactory property that is not a function", spec.get());
    return nullptr;
  }

  RootedObject jsGetFactoryObj(cx);
  if (!JS_ValueToObject(cx, NSGetFactory_val, &jsGetFactoryObj) ||
      !jsGetFactoryObj) {
    /* XXX report error properly */
    return nullptr;
  }

  rv = nsXPConnect::XPConnect()->WrapJS(cx, jsGetFactoryObj,
                                        NS_GET_IID(xpcIJSGetFactory),
                                        getter_AddRefs(entry->getfactoryobj));
  if (NS_FAILED(rv)) {
    /* XXX report error properly */
#ifdef DEBUG
    fprintf(stderr, "mJCL: couldn't get nsIModule from jsval\n");
#endif
    return nullptr;
  }

#if defined(NIGHTLY_BUILD) || defined(DEBUG)
  if (Preferences::GetBool("browser.startup.record", false)) {
    entry->importStack = xpc_PrintJSStack(cx, false, false, false).get();
  }
#endif

  // Cache this module for later
  mModules.InsertOrUpdate(spec, entry.get());

  // The hash owns the ModuleEntry now, forget about it
  return entry.release();
}

void mozJSComponentLoader::FindTargetObject(JSContext* aCx,
                                            MutableHandleObject aTargetObject) {
  aTargetObject.set(JS::GetJSMEnvironmentOfScriptedCaller(aCx));

  // The above could fail if the scripted caller is not a component/JSM (it
  // could be a DOM scope, for instance).
  //
  // If the target object was not in the JSM shared global, return the global
  // instead. This is needed when calling the subscript loader within a frame
  // script, since it the FrameScript NSVO will have been found.
  if (!aTargetObject ||
      !IsLoaderGlobal(JS::GetNonCCWObjectGlobal(aTargetObject))) {
    aTargetObject.set(JS::GetScriptedCallerGlobal(aCx));

    // Return nullptr if the scripted caller is in a different compartment.
    if (JS::GetCompartment(aTargetObject) != js::GetContextCompartment(aCx)) {
      aTargetObject.set(nullptr);
    }
  }
}

void mozJSComponentLoader::InitStatics() {
  MOZ_ASSERT(!sSelf);
  sSelf = new mozJSComponentLoader();
  RegisterWeakMemoryReporter(sSelf);
}

void mozJSComponentLoader::Unload() {
  if (sSelf) {
    sSelf->UnloadModules();
  }
}

void mozJSComponentLoader::Shutdown() {
  MOZ_ASSERT(sSelf);
  UnregisterWeakMemoryReporter(sSelf);
  sSelf = nullptr;
}

// This requires that the keys be strings and the values be pointers.
template <class Key, class Data, class UserData, class Converter>
static size_t SizeOfTableExcludingThis(
    const nsBaseHashtable<Key, Data, UserData, Converter>& aTable,
    MallocSizeOf aMallocSizeOf) {
  size_t n = aTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
  for (const auto& entry : aTable) {
    n += entry.GetKey().SizeOfExcludingThisIfUnshared(aMallocSizeOf);
    n += entry.GetData()->SizeOfIncludingThis(aMallocSizeOf);
  }
  return n;
}

size_t mozJSComponentLoader::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
  size_t n = aMallocSizeOf(this);
  n += SizeOfTableExcludingThis(mModules, aMallocSizeOf);
  n += SizeOfTableExcludingThis(mImports, aMallocSizeOf);
  n += mLocations.ShallowSizeOfExcludingThis(aMallocSizeOf);
  n += SizeOfTableExcludingThis(mInProgressImports, aMallocSizeOf);
  return n;
}

// Memory report paths are split on '/', with each component displayed as a
// separate layer of a visual tree. Any slashes which are meant to belong to a
// particular path component, rather than be used to build a hierarchy,
// therefore need to be replaced with backslashes, which are displayed as
// slashes in the UI.
//
// If `aAnonymize` is true, this function also attempts to translate any file:
// URLs to replace the path of the GRE directory with a placeholder containing
// no private information, and strips all other file: URIs of everything upto
// their last `/`.
static nsAutoCString MangleURL(const char* aURL, bool aAnonymize) {
  nsAutoCString url(aURL);

  if (aAnonymize) {
    static nsCString greDirURI;
    if (greDirURI.IsEmpty()) {
      nsCOMPtr<nsIFile> file;
      Unused << NS_GetSpecialDirectory(NS_GRE_DIR, getter_AddRefs(file));
      if (file) {
        nsCOMPtr<nsIURI> uri;
        NS_NewFileURI(getter_AddRefs(uri), file);
        if (uri) {
          uri->GetSpec(greDirURI);
          RunOnShutdown([&]() { greDirURI.Truncate(0); });
        }
      }
    }

    url.ReplaceSubstring(greDirURI, "<GREDir>/"_ns);

    if (FindInReadable("file:"_ns, url)) {
      if (StringBeginsWith(url, "jar:file:"_ns)) {
        int32_t idx = url.RFindChar('!');
        url = "jar:file://<anonymized>!"_ns + Substring(url, idx);
      } else {
        int32_t idx = url.RFindChar('/');
        url = "file://<anonymized>/"_ns + Substring(url, idx);
      }
    }
  }

  url.ReplaceChar('/', '\\');
  return url;
}

NS_IMETHODIMP
mozJSComponentLoader::CollectReports(nsIHandleReportCallback* aHandleReport,
                                     nsISupports* aData, bool aAnonymize) {
  for (const auto& entry : mImports.Values()) {
    nsAutoCString path("js-component-loader/modules/");
    path.Append(MangleURL(entry->location, aAnonymize));

    aHandleReport->Callback(""_ns, path, KIND_NONHEAP, UNITS_COUNT, 1,
                            "Loaded JS modules"_ns, aData);
  }

  for (const auto& entry : mModules.Values()) {
    nsAutoCString path("js-component-loader/components/");
    path.Append(MangleURL(entry->location, aAnonymize));

    aHandleReport->Callback(""_ns, path, KIND_NONHEAP, UNITS_COUNT, 1,
                            "Loaded JS components"_ns, aData);
  }

  return NS_OK;
}

void mozJSComponentLoader::CreateLoaderGlobal(JSContext* aCx,
                                              const nsACString& aLocation,
                                              MutableHandleObject aGlobal) {
  auto backstagePass = MakeRefPtr<BackstagePass>();
  RealmOptions options;

  options.creationOptions().setNewCompartmentInSystemZone();
  xpc::SetPrefableRealmOptions(options);

  // Defer firing OnNewGlobalObject until after the __URI__ property has
  // been defined so the JS debugger can tell what module the global is
  // for
  RootedObject global(aCx);
  nsresult rv = xpc::InitClassesWithNewWrappedGlobal(
      aCx, static_cast<nsIGlobalObject*>(backstagePass),
      nsContentUtils::GetSystemPrincipal(), xpc::DONT_FIRE_ONNEWGLOBALHOOK,
      options, &global);
  NS_ENSURE_SUCCESS_VOID(rv);

  NS_ENSURE_TRUE_VOID(global);

  backstagePass->SetGlobalObject(global);

  JSAutoRealm ar(aCx, global);
  if (!JS_DefineFunctions(aCx, global, gGlobalFun)) {
    return;
  }

  // Set the location information for the new global, so that tools like
  // about:memory may use that information
  xpc::SetLocationForGlobal(global, aLocation);

  aGlobal.set(global);
}

JSObject* mozJSComponentLoader::GetSharedGlobal(JSContext* aCx) {
  if (!mLoaderGlobal) {
    JS::RootedObject globalObj(aCx);
    CreateLoaderGlobal(aCx, "shared JSM global"_ns, &globalObj);

    // If we fail to create a module global this early, we're not going to
    // get very far, so just bail out now.
    MOZ_RELEASE_ASSERT(globalObj);
    mLoaderGlobal = globalObj;

    // AutoEntryScript required to invoke debugger hook, which is a
    // Gecko-specific concept at present.
    dom::AutoEntryScript aes(globalObj, "component loader report global");
    JS_FireOnNewGlobalObject(aes.cx(), globalObj);
  }

  return mLoaderGlobal;
}

JSObject* mozJSComponentLoader::PrepareObjectForLocation(
    JSContext* aCx, nsIFile* aComponentFile, nsIURI* aURI, bool* aRealFile) {
  nsAutoCString nativePath;
  NS_ENSURE_SUCCESS(aURI->GetSpec(nativePath), nullptr);

  RootedObject globalObj(aCx, GetSharedGlobal(aCx));

  // |thisObj| is the object we set properties on for a particular .jsm.
  RootedObject thisObj(aCx, globalObj);
  NS_ENSURE_TRUE(thisObj, nullptr);

  JSAutoRealm ar(aCx, thisObj);

  thisObj = JS::NewJSMEnvironment(aCx);
  NS_ENSURE_TRUE(thisObj, nullptr);

  *aRealFile = false;

  // need to be extra careful checking for URIs pointing to files
  // EnsureFile may not always get called, especially on resource URIs
  // so we need to call GetFile to make sure this is a valid file
  {
    // Create an extra scope so that ~nsCOMPtr will run before the returned
    // JSObject* is placed on the stack, since otherwise a GC in the destructor
    // would invalidate the return value.
    nsresult rv = NS_OK;
    nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(aURI, &rv);
    nsCOMPtr<nsIFile> testFile;
    if (NS_SUCCEEDED(rv)) {
      fileURL->GetFile(getter_AddRefs(testFile));
    }

    if (testFile) {
      *aRealFile = true;

      if (XRE_IsParentProcess()) {
        RootedObject locationObj(aCx);

        rv = nsXPConnect::XPConnect()->WrapNative(aCx, thisObj, aComponentFile,
                                                  NS_GET_IID(nsIFile),
                                                  locationObj.address());
        NS_ENSURE_SUCCESS(rv, nullptr);
        NS_ENSURE_TRUE(locationObj, nullptr);

        if (!JS_DefineProperty(aCx, thisObj, "__LOCATION__", locationObj, 0)) {
          return nullptr;
        }
      }
    }
  }

  // Expose the URI from which the script was imported through a special
  // variable that we insert into the JSM.
  RootedString exposedUri(
      aCx, JS_NewStringCopyN(aCx, nativePath.get(), nativePath.Length()));
  NS_ENSURE_TRUE(exposedUri, nullptr);

  if (!JS_DefineProperty(aCx, thisObj, "__URI__", exposedUri, 0)) {
    return nullptr;
  }

  return thisObj;
}

static mozilla::Result<nsCString, nsresult> ReadScript(
    ComponentLoaderInfo& aInfo) {
  MOZ_TRY(aInfo.EnsureScriptChannel());

  nsCOMPtr<nsIInputStream> scriptStream;
  MOZ_TRY(NS_MaybeOpenChannelUsingOpen(aInfo.ScriptChannel(),
                                       getter_AddRefs(scriptStream)));

  uint64_t len64;
  uint32_t bytesRead;

  MOZ_TRY(scriptStream->Available(&len64));
  NS_ENSURE_TRUE(len64 < UINT32_MAX, Err(NS_ERROR_FILE_TOO_BIG));
  NS_ENSURE_TRUE(len64, Err(NS_ERROR_FAILURE));
  uint32_t len = (uint32_t)len64;

  /* malloc an internal buf the size of the file */
  nsCString str;
  if (!str.SetLength(len, fallible)) {
    return Err(NS_ERROR_OUT_OF_MEMORY);
  }

  /* read the file in one swoop */
  MOZ_TRY(scriptStream->Read(str.BeginWriting(), len, &bytesRead));
  if (bytesRead != len) {
    return Err(NS_BASE_STREAM_OSERROR);
  }

  return std::move(str);
}

nsresult mozJSComponentLoader::ObjectForLocation(
    ComponentLoaderInfo& aInfo, nsIFile* aComponentFile,
    MutableHandleObject aObject, MutableHandleScript aTableScript,
    char** aLocation, bool aPropagateExceptions,
    MutableHandleValue aException) {
  MOZ_ASSERT(NS_IsMainThread(), "Must be on main thread.");

  dom::AutoJSAPI jsapi;
  jsapi.Init();
  JSContext* cx = jsapi.cx();

  bool realFile = false;
  nsresult rv = aInfo.EnsureURI();
  NS_ENSURE_SUCCESS(rv, rv);
  RootedObject obj(
      cx, PrepareObjectForLocation(cx, aComponentFile, aInfo.URI(), &realFile));
  NS_ENSURE_TRUE(obj, NS_ERROR_FAILURE);
  MOZ_ASSERT(!JS_IsGlobalObject(obj));

  JSAutoRealm ar(cx, obj);

  RootedScript script(cx);

  nsAutoCString nativePath;
  rv = aInfo.URI()->GetSpec(nativePath);
  NS_ENSURE_SUCCESS(rv, rv);

  // Before compiling the script, first check to see if we have it in
  // the startupcache.  Note: as a rule, startupcache errors are not fatal
  // to loading the script, since we can always slow-load.

  bool writeToCache = false;
  StartupCache* cache = StartupCache::GetSingleton();

  aInfo.EnsureResolvedURI();

  nsAutoCString cachePath(JS_CACHE_PREFIX("non-syntactic"));
  rv = PathifyURI(aInfo.ResolvedURI(), cachePath);
  NS_ENSURE_SUCCESS(rv, rv);

  CompileOptions options(cx);
  ScriptPreloader::FillCompileOptionsForCachedScript(options);
  options.setFileAndLine(nativePath.get(), 1);
  options.setForceStrictMode();
  options.setNonSyntacticScope(true);

  script =
      ScriptPreloader::GetSingleton().GetCachedScript(cx, options, cachePath);
  if (!script && cache) {
    ReadCachedScript(cache, cachePath, cx, options, &script);
  }

  if (script) {
    LOG(("Successfully loaded %s from startupcache\n", nativePath.get()));
  } else if (cache) {
    // This is ok, it just means the script is not yet in the
    // cache. Could mean that the cache was corrupted and got removed,
    // but either way we're going to write this out.
    writeToCache = true;
    // ReadCachedScript may have set a pending exception.
    JS_ClearPendingException(cx);
  }

  if (!script) {
    // The script wasn't in the cache , so compile it now.
    LOG(("Slow loading %s\n", nativePath.get()));

    // If we can no longer write to caches, we should stop using lazy sources
    // and instead let normal syntax parsing occur. This can occur in content
    // processes after the ScriptPreloader is flushed where we can read but no
    // longer write.
    if (!cache && !ScriptPreloader::GetSingleton().Active()) {
      options.setSourceIsLazy(false);
    }

    if (realFile) {
      AutoMemMap map;
      MOZ_TRY(map.init(aComponentFile));

      // Note: exceptions will get handled further down;
      // don't early return for them here.
      auto buf = map.get<char>();

      JS::SourceText<mozilla::Utf8Unit> srcBuf;
      if (srcBuf.init(cx, buf.get(), map.size(),
                      JS::SourceOwnership::Borrowed)) {
        script = Compile(cx, options, srcBuf);
      } else {
        MOZ_ASSERT(!script);
      }
    } else {
      nsCString str;
      MOZ_TRY_VAR(str, ReadScript(aInfo));

      JS::SourceText<mozilla::Utf8Unit> srcBuf;
      if (srcBuf.init(cx, str.get(), str.Length(),
                      JS::SourceOwnership::Borrowed)) {
        script = Compile(cx, options, srcBuf);
      } else {
        MOZ_ASSERT(!script);
      }
    }
    // Propagate the exception, if one exists. Also, don't leave the stale
    // exception on this context.
    if (!script && aPropagateExceptions && jsapi.HasException()) {
      if (!jsapi.StealException(aException)) {
        return NS_ERROR_OUT_OF_MEMORY;
      }
    }
  }

  if (!script) {
    return NS_ERROR_FAILURE;
  }

  MOZ_ASSERT_IF(ScriptPreloader::GetSingleton().Active(), options.sourceIsLazy);
  ScriptPreloader::GetSingleton().NoteScript(nativePath, cachePath, script);

  if (writeToCache) {
    MOZ_ASSERT(options.sourceIsLazy);

    // We successfully compiled the script, so cache it.
    rv = WriteCachedScript(cache, cachePath, cx, script);

    // Don't treat failure to write as fatal, since we might be working
    // with a read-only cache.
    if (NS_SUCCEEDED(rv)) {
      LOG(("Successfully wrote to cache\n"));
    } else {
      LOG(("Failed to write to cache\n"));
    }
  }

  // Assign aObject here so that it's available to recursive imports.
  // See bug 384168.
  aObject.set(obj);

  aTableScript.set(script);

  {  // Scope for AutoEntryScript
    AutoAllowLegacyScriptExecution exemption;

    // We're going to run script via JS_ExecuteScript, so we need an
    // AutoEntryScript. This is Gecko-specific and not in any spec.
    dom::AutoEntryScript aes(CurrentGlobalOrNull(cx),
                             "component loader load module");
    JSContext* aescx = aes.cx();

    bool executeOk = false;
    if (JS_IsGlobalObject(obj)) {
      JS::RootedValue rval(cx);
      executeOk = JS::CloneAndExecuteScript(aescx, script, &rval);
    } else {
      executeOk = JS::ExecuteInJSMEnvironment(aescx, script, obj);
    }

    if (!executeOk) {
      if (aPropagateExceptions && aes.HasException()) {
        // Ignore return value because we're returning an error code
        // anyway.
        Unused << aes.StealException(aException);
      }
      aObject.set(nullptr);
      aTableScript.set(nullptr);
      return NS_ERROR_FAILURE;
    }
  }

  /* Freed when we remove from the table. */
  *aLocation = ToNewCString(nativePath, mozilla::fallible);
  if (!*aLocation) {
    aObject.set(nullptr);
    aTableScript.set(nullptr);
    return NS_ERROR_OUT_OF_MEMORY;
  }

  return NS_OK;
}

void mozJSComponentLoader::UnloadModules() {
  mInitialized = false;

  if (mLoaderGlobal) {
    MOZ_ASSERT(JS_HasExtensibleLexicalEnvironment(mLoaderGlobal));
    JS::RootedObject lexicalEnv(dom::RootingCx(),
                                JS_ExtensibleLexicalEnvironment(mLoaderGlobal));
    JS_SetAllNonReservedSlotsToUndefined(lexicalEnv);
    JS_SetAllNonReservedSlotsToUndefined(mLoaderGlobal);
    mLoaderGlobal = nullptr;
  }

  mInProgressImports.Clear();
  mImports.Clear();
  mLocations.Clear();

  for (auto iter = mModules.Iter(); !iter.Done(); iter.Next()) {
    iter.Data()->Clear();
    iter.Remove();
  }
}

nsresult mozJSComponentLoader::ImportInto(const nsACString& registryLocation,
                                          HandleValue targetValArg,
                                          JSContext* cx, uint8_t optionalArgc,
                                          MutableHandleValue retval) {
  MOZ_ASSERT(nsContentUtils::IsCallerChrome());

  RootedValue targetVal(cx, targetValArg);
  RootedObject targetObject(cx, nullptr);

  if (optionalArgc) {
    // The caller passed in the optional second argument. Get it.
    if (targetVal.isObject()) {
      // If we're passing in something like a content DOM window, chances
      // are the caller expects the properties to end up on the object
      // proper and not on the Xray holder. This is dubious, but can be used
      // during testing. Given that dumb callers can already leak JSMs into
      // content by passing a raw content JS object (where Xrays aren't
      // possible), we aim for consistency here. Waive xray.
      if (WrapperFactory::IsXrayWrapper(&targetVal.toObject()) &&
          !WrapperFactory::WaiveXrayAndWrap(cx, &targetVal)) {
        return NS_ERROR_FAILURE;
      }
      targetObject = &targetVal.toObject();
    } else if (!targetVal.isNull()) {
      // If targetVal isNull(), we actually want to leave targetObject null.
      // Not doing so breaks |make package|.
      return ReportOnCallerUTF8(cx, ERROR_SCOPE_OBJ,
                                PromiseFlatCString(registryLocation).get());
    }
  } else {
    FindTargetObject(cx, &targetObject);
    if (!targetObject) {
      return ReportOnCallerUTF8(cx, ERROR_NO_TARGET_OBJECT,
                                PromiseFlatCString(registryLocation).get());
    }
  }

  js::AssertSameCompartment(cx, targetObject);

  RootedObject global(cx);
  nsresult rv = ImportInto(registryLocation, targetObject, cx, &global);

  if (global) {
    if (!JS_WrapObject(cx, &global)) {
      NS_ERROR("can't wrap return value");
      return NS_ERROR_FAILURE;
    }

    retval.setObject(*global);
  }
  return rv;
}

nsresult mozJSComponentLoader::IsModuleLoaded(const nsACString& aLocation,
                                              bool* retval) {
  MOZ_ASSERT(nsContentUtils::IsCallerChrome());

  mInitialized = true;
  ComponentLoaderInfo info(aLocation);
  *retval = !!mImports.Get(info.Key());
  return NS_OK;
}

void mozJSComponentLoader::GetLoadedModules(
    nsTArray<nsCString>& aLoadedModules) {
  aLoadedModules.SetCapacity(mImports.Count());
  for (const auto& data : mImports.Values()) {
    aLoadedModules.AppendElement(data->location);
  }
}

void mozJSComponentLoader::GetLoadedComponents(
    nsTArray<nsCString>& aLoadedComponents) {
  aLoadedComponents.SetCapacity(mModules.Count());
  for (const auto& data : mModules.Values()) {
    aLoadedComponents.AppendElement(data->location);
  }
}

nsresult mozJSComponentLoader::GetModuleImportStack(const nsACString& aLocation,
                                                    nsACString& retval) {
#ifdef STARTUP_RECORDER_ENABLED
  MOZ_ASSERT(nsContentUtils::IsCallerChrome());
  MOZ_ASSERT(mInitialized);

  ComponentLoaderInfo info(aLocation);

  ModuleEntry* mod;
  if (!mImports.Get(info.Key(), &mod)) {
    return NS_ERROR_FAILURE;
  }

  retval = mod->importStack;
  return NS_OK;
#else
  return NS_ERROR_NOT_IMPLEMENTED;
#endif
}

nsresult mozJSComponentLoader::GetComponentLoadStack(
    const nsACString& aLocation, nsACString& retval) {
#ifdef STARTUP_RECORDER_ENABLED
  MOZ_ASSERT(nsContentUtils::IsCallerChrome());
  MOZ_ASSERT(mInitialized);

  ComponentLoaderInfo info(aLocation);
  nsresult rv = info.EnsureURI();
  NS_ENSURE_SUCCESS(rv, rv);

  ModuleEntry* mod;
  if (!mModules.Get(info.Key(), &mod)) {
    return NS_ERROR_FAILURE;
  }

  retval = mod->importStack;
  return NS_OK;
#else
  return NS_ERROR_NOT_IMPLEMENTED;
#endif
}

static JSObject* ResolveModuleObjectPropertyById(JSContext* aCx,
                                                 HandleObject aModObj,
                                                 HandleId id) {
  if (JS_HasExtensibleLexicalEnvironment(aModObj)) {
    RootedObject lexical(aCx, JS_ExtensibleLexicalEnvironment(aModObj));
    bool found;
    if (!JS_HasOwnPropertyById(aCx, lexical, id, &found)) {
      return nullptr;
    }
    if (found) {
      return lexical;
    }
  }
  return aModObj;
}

nsresult mozJSComponentLoader::ImportInto(const nsACString& aLocation,
                                          HandleObject targetObj, JSContext* cx,
                                          MutableHandleObject vp) {
  vp.set(nullptr);

  JS::RootedObject exports(cx);
  MOZ_TRY(Import(cx, aLocation, vp, &exports, !targetObj));

  if (targetObj) {
    JS::Rooted<JS::IdVector> ids(cx, JS::IdVector(cx));
    if (!JS_Enumerate(cx, exports, &ids)) {
      return NS_ERROR_OUT_OF_MEMORY;
    }

    JS::RootedValue value(cx);
    JS::RootedId id(cx);
    for (jsid idVal : ids) {
      id = idVal;
      if (!JS_GetPropertyById(cx, exports, id, &value) ||
          !JS_SetPropertyById(cx, targetObj, id, value)) {
        return NS_ERROR_FAILURE;
      }
    }
  }

  return NS_OK;
}

nsresult mozJSComponentLoader::ExtractExports(
    JSContext* aCx, ComponentLoaderInfo& aInfo, ModuleEntry* aMod,
    JS::MutableHandleObject aExports) {
  // cxhelper must be created before jsapi, so that jsapi is destroyed and
  // pops any context it has pushed before we report to the caller context.
  JSCLContextHelper cxhelper(aCx);

  // Even though we are calling JS_SetPropertyById on targetObj, we want
  // to ensure that we never run script here, so we use an AutoJSAPI and
  // not an AutoEntryScript.
  dom::AutoJSAPI jsapi;
  jsapi.Init();
  JSContext* cx = jsapi.cx();
  JSAutoRealm ar(cx, aMod->obj);

  RootedValue symbols(cx);
  {
    RootedObject obj(
        cx, ResolveModuleObjectProperty(cx, aMod->obj, "EXPORTED_SYMBOLS"));
    if (!obj || !JS_GetProperty(cx, obj, "EXPORTED_SYMBOLS", &symbols)) {
      return ReportOnCallerUTF8(cxhelper, ERROR_NOT_PRESENT, aInfo);
    }
  }

  bool isArray;
  if (!JS::IsArrayObject(cx, symbols, &isArray)) {
    return NS_ERROR_FAILURE;
  }
  if (!isArray) {
    return ReportOnCallerUTF8(cxhelper, ERROR_NOT_AN_ARRAY, aInfo);
  }

  RootedObject symbolsObj(cx, &symbols.toObject());

  // Iterate over symbols array, installing symbols on targetObj:

  uint32_t symbolCount = 0;
  if (!JS::GetArrayLength(cx, symbolsObj, &symbolCount)) {
    return ReportOnCallerUTF8(cxhelper, ERROR_GETTING_ARRAY_LENGTH, aInfo);
  }

#ifdef DEBUG
  nsAutoCString logBuffer;
#endif

  aExports.set(JS_NewPlainObject(cx));
  if (!aExports) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  bool missing = false;

  RootedValue value(cx);
  RootedId symbolId(cx);
  RootedObject symbolHolder(cx);
  for (uint32_t i = 0; i < symbolCount; ++i) {
    if (!JS_GetElement(cx, symbolsObj, i, &value) || !value.isString() ||
        !JS_ValueToId(cx, value, &symbolId)) {
      return ReportOnCallerUTF8(cxhelper, ERROR_ARRAY_ELEMENT, aInfo, i);
    }

    symbolHolder = ResolveModuleObjectPropertyById(cx, aMod->obj, symbolId);
    if (!symbolHolder ||
        !JS_GetPropertyById(cx, symbolHolder, symbolId, &value)) {
      RootedString symbolStr(cx, JSID_TO_STRING(symbolId));
      JS::UniqueChars bytes = JS_EncodeStringToUTF8(cx, symbolStr);
      if (!bytes) {
        return NS_ERROR_FAILURE;
      }
      return ReportOnCallerUTF8(cxhelper, ERROR_GETTING_SYMBOL, aInfo,
                                bytes.get());
    }

    // It's possible |value| is the uninitialized lexical MagicValue when
    // there's a cyclic import: const obj = ChromeUtils.import("parent.jsm").
    if (value.isMagic(JS_UNINITIALIZED_LEXICAL)) {
      RootedString symbolStr(cx, JSID_TO_STRING(symbolId));
      JS::UniqueChars bytes = JS_EncodeStringToUTF8(cx, symbolStr);
      if (!bytes) {
        return NS_ERROR_FAILURE;
      }
      return ReportOnCallerUTF8(cxhelper, ERROR_UNINITIALIZED_SYMBOL, aInfo,
                                bytes.get());
    }

    if (value.isUndefined()) {
      missing = true;
    }

    if (!JS_SetPropertyById(cx, aExports, symbolId, value)) {
      RootedString symbolStr(cx, JSID_TO_STRING(symbolId));
      JS::UniqueChars bytes = JS_EncodeStringToUTF8(cx, symbolStr);
      if (!bytes) {
        return NS_ERROR_FAILURE;
      }
      return ReportOnCallerUTF8(cxhelper, ERROR_GETTING_SYMBOL, aInfo,
                                bytes.get());
    }
#ifdef DEBUG
    if (i == 0) {
      logBuffer.AssignLiteral("Installing symbols [ ");
    }
    JS::UniqueChars bytes =
        JS_EncodeStringToLatin1(cx, JSID_TO_STRING(symbolId));
    if (!!bytes) {
      logBuffer.Append(bytes.get());
    }
    logBuffer.Append(' ');
    if (i == symbolCount - 1) {
      nsCString location;
      MOZ_TRY(aInfo.GetLocation(location));
      LOG(("%s] from %s\n", logBuffer.get(), location.get()));
    }
#endif
  }

  // Don't cache the exports object if any of its exported symbols are
  // missing. If the module hasn't finished loading yet, they may be
  // defined the next time we try to import it.
  if (!missing) {
    aMod->exports = aExports;
  }
  return NS_OK;
}

nsresult mozJSComponentLoader::Import(JSContext* aCx,
                                      const nsACString& aLocation,
                                      JS::MutableHandleObject aModuleGlobal,
                                      JS::MutableHandleObject aModuleExports,
                                      bool aIgnoreExports) {
  mInitialized = true;

  AUTO_PROFILER_MARKER_TEXT(
      "ChromeUtils.import", JS,
      MarkerOptions(MarkerStack::Capture(),
                    MarkerInnerWindowIdFromJSContext(aCx)),
      aLocation);

  ComponentLoaderInfo info(aLocation);

  nsresult rv;
  ModuleEntry* mod;
  UniquePtr<ModuleEntry> newEntry;
  if (!mImports.Get(info.Key(), &mod) &&
      !mInProgressImports.Get(info.Key(), &mod)) {
    // We're trying to import a new JSM, but we're late in shutdown and this
    // will likely not succeed and might even crash, so fail here.
    if (PastShutdownPhase(ShutdownPhase::XPCOMShutdownFinal)) {
      return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
    }

    newEntry = MakeUnique<ModuleEntry>(RootingContext::get(aCx));

    // Note: This implies EnsureURI().
    MOZ_TRY(info.EnsureResolvedURI());

    // get the JAR if there is one
    nsCOMPtr<nsIJARURI> jarURI;
    jarURI = do_QueryInterface(info.ResolvedURI(), &rv);
    nsCOMPtr<nsIFileURL> baseFileURL;
    if (NS_SUCCEEDED(rv)) {
      nsCOMPtr<nsIURI> baseURI;
      while (jarURI) {
        jarURI->GetJARFile(getter_AddRefs(baseURI));
        jarURI = do_QueryInterface(baseURI, &rv);
      }
      baseFileURL = do_QueryInterface(baseURI, &rv);
      NS_ENSURE_SUCCESS(rv, rv);
    } else {
      baseFileURL = do_QueryInterface(info.ResolvedURI(), &rv);
      NS_ENSURE_SUCCESS(rv, rv);
    }

    nsCOMPtr<nsIFile> sourceFile;
    rv = baseFileURL->GetFile(getter_AddRefs(sourceFile));
    NS_ENSURE_SUCCESS(rv, rv);

    rv = info.ResolvedURI()->GetSpec(newEntry->resolvedURL);
    NS_ENSURE_SUCCESS(rv, rv);

    nsCString* existingPath;
    if (mLocations.Get(newEntry->resolvedURL, &existingPath) &&
        *existingPath != info.Key()) {
      return NS_ERROR_UNEXPECTED;
    }

    mLocations.InsertOrUpdate(newEntry->resolvedURL,
                              MakeUnique<nsCString>(info.Key()));

    RootedValue exception(aCx);
    {
      mInProgressImports.InsertOrUpdate(info.Key(), newEntry.get());
      auto cleanup =
          MakeScopeExit([&]() { mInProgressImports.Remove(info.Key()); });

      rv = ObjectForLocation(info, sourceFile, &newEntry->obj,
                             &newEntry->thisObjectKey, &newEntry->location,
                             true, &exception);
    }

    if (NS_FAILED(rv)) {
      mLocations.Remove(newEntry->resolvedURL);
      if (!exception.isUndefined()) {
        // An exception was thrown during compilation. Propagate it
        // out to our caller so they can report it.
        if (!JS_WrapValue(aCx, &exception)) {
          return NS_ERROR_OUT_OF_MEMORY;
        }
        JS_SetPendingException(aCx, exception);
        return NS_ERROR_FAILURE;
      }

      // Something failed, but we don't know what it is, guess.
      return NS_ERROR_FILE_NOT_FOUND;
    }

#ifdef STARTUP_RECORDER_ENABLED
    if (Preferences::GetBool("browser.startup.record", false)) {
      newEntry->importStack = xpc_PrintJSStack(aCx, false, false, false).get();
    }
#endif

    mod = newEntry.get();
  }

  MOZ_ASSERT(mod->obj, "Import table contains entry with no object");
  aModuleGlobal.set(mod->obj);

  JS::RootedObject exports(aCx, mod->exports);
  if (!exports && !aIgnoreExports) {
    MOZ_TRY(ExtractExports(aCx, info, mod, &exports));
  }

  if (exports && !JS_WrapObject(aCx, &exports)) {
    mLocations.Remove(newEntry->resolvedURL);
    return NS_ERROR_FAILURE;
  }
  aModuleExports.set(exports);

  // Cache this module for later
  if (newEntry) {
    mImports.InsertOrUpdate(info.Key(), std::move(newEntry));
  }

  return NS_OK;
}

nsresult mozJSComponentLoader::Unload(const nsACString& aLocation) {
  if (!mInitialized) {
    return NS_OK;
  }

  ComponentLoaderInfo info(aLocation);

  ModuleEntry* mod;
  if (mImports.Get(info.Key(), &mod)) {
    mLocations.Remove(mod->resolvedURL);
    mImports.Remove(info.Key());
  }

  // If this is the last module to be unloaded, we will leak mLoaderGlobal
  // until UnloadModules is called. So be it.

  return NS_OK;
}

size_t mozJSComponentLoader::ModuleEntry::SizeOfIncludingThis(
    MallocSizeOf aMallocSizeOf) const {
  size_t n = aMallocSizeOf(this);
  n += aMallocSizeOf(location);

  return n;
}

/* static */
already_AddRefed<nsIFactory> mozJSComponentLoader::ModuleEntry::GetFactory(
    const mozilla::Module& module, const mozilla::Module::CIDEntry& entry) {
  const ModuleEntry& self = static_cast<const ModuleEntry&>(module);
  MOZ_ASSERT(self.getfactoryobj, "Handing out an uninitialized module?");

  nsCOMPtr<nsIFactory> f;
  nsresult rv = self.getfactoryobj->Get(*entry.cid, getter_AddRefs(f));
  if (NS_FAILED(rv)) {
    return nullptr;
  }

  return f.forget();
}

//----------------------------------------------------------------------

JSCLContextHelper::JSCLContextHelper(JSContext* aCx)
    : mContext(aCx), mBuf(nullptr) {}

JSCLContextHelper::~JSCLContextHelper() {
  if (mBuf) {
    JS_ReportErrorUTF8(mContext, "%s", mBuf.get());
  }
}

void JSCLContextHelper::reportErrorAfterPop(UniqueChars&& buf) {
  MOZ_ASSERT(!mBuf, "Already called reportErrorAfterPop");
  mBuf = std::move(buf);
}