summaryrefslogtreecommitdiffstats
path: root/xpcom/components
diff options
context:
space:
mode:
Diffstat (limited to 'xpcom/components')
-rw-r--r--xpcom/components/GenericFactory.cpp18
-rw-r--r--xpcom/components/GenericFactory.h38
-rw-r--r--xpcom/components/ManifestParser.cpp678
-rw-r--r--xpcom/components/ManifestParser.h23
-rw-r--r--xpcom/components/Module.h76
-rw-r--r--xpcom/components/ModuleUtils.h81
-rw-r--r--xpcom/components/StaticComponents.cpp.in410
-rw-r--r--xpcom/components/StaticComponents.h284
-rw-r--r--xpcom/components/components.conf23
-rw-r--r--xpcom/components/gen_static_components.py1206
-rw-r--r--xpcom/components/moz.build85
-rw-r--r--xpcom/components/nsCategoryCache.cpp162
-rw-r--r--xpcom/components/nsCategoryCache.h123
-rw-r--r--xpcom/components/nsCategoryManager.cpp692
-rw-r--r--xpcom/components/nsCategoryManager.h145
-rw-r--r--xpcom/components/nsCategoryManagerUtils.h14
-rw-r--r--xpcom/components/nsComponentManager.cpp1575
-rw-r--r--xpcom/components/nsComponentManager.h218
-rw-r--r--xpcom/components/nsComponentManagerUtils.cpp259
-rw-r--r--xpcom/components/nsComponentManagerUtils.h170
-rw-r--r--xpcom/components/nsICategoryManager.idl137
-rw-r--r--xpcom/components/nsIClassInfo.idl74
-rw-r--r--xpcom/components/nsIComponentManager.idl117
-rw-r--r--xpcom/components/nsIComponentRegistrar.idl100
-rw-r--r--xpcom/components/nsIFactory.idl27
-rw-r--r--xpcom/components/nsIServiceManager.idl70
-rw-r--r--xpcom/components/nsServiceManagerUtils.h56
-rw-r--r--xpcom/components/test/python.ini4
-rw-r--r--xpcom/components/test/test_gen_static_components.py150
29 files changed, 7015 insertions, 0 deletions
diff --git a/xpcom/components/GenericFactory.cpp b/xpcom/components/GenericFactory.cpp
new file mode 100644
index 0000000000..5eb88e8ba4
--- /dev/null
+++ b/xpcom/components/GenericFactory.cpp
@@ -0,0 +1,18 @@
+/* -*- 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/GenericFactory.h"
+
+namespace mozilla {
+
+NS_IMPL_ISUPPORTS(GenericFactory, nsIFactory)
+
+NS_IMETHODIMP
+GenericFactory::CreateInstance(REFNSIID aIID, void** aResult) {
+ return mCtor(aIID, aResult);
+}
+
+} // namespace mozilla
diff --git a/xpcom/components/GenericFactory.h b/xpcom/components/GenericFactory.h
new file mode 100644
index 0000000000..3fb2186e12
--- /dev/null
+++ b/xpcom/components/GenericFactory.h
@@ -0,0 +1,38 @@
+/* -*- 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/. */
+
+#ifndef mozilla_GenericFactory_h
+#define mozilla_GenericFactory_h
+
+#include "nsIFactory.h"
+
+namespace mozilla {
+
+/**
+ * A generic factory which uses a constructor function to create instances.
+ * This class is intended for use by the component manager and the generic
+ * module.
+ */
+class GenericFactory final : public nsIFactory {
+ ~GenericFactory() = default;
+
+ public:
+ typedef nsresult (*ConstructorProcPtr)(const nsIID& aIID, void** aResult);
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIFACTORY
+
+ explicit GenericFactory(ConstructorProcPtr aCtor) : mCtor(aCtor) {
+ NS_ASSERTION(mCtor, "GenericFactory with no constructor");
+ }
+
+ private:
+ ConstructorProcPtr mCtor;
+};
+
+} // namespace mozilla
+
+#endif // mozilla_GenericFactory_h
diff --git a/xpcom/components/ManifestParser.cpp b/xpcom/components/ManifestParser.cpp
new file mode 100644
index 0000000000..88ee06d78d
--- /dev/null
+++ b/xpcom/components/ManifestParser.cpp
@@ -0,0 +1,678 @@
+/* -*- 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/ArrayUtils.h"
+#include "mozilla/Printf.h"
+#include "mozilla/UniquePtr.h"
+
+#include "ManifestParser.h"
+
+#include <string.h>
+
+#include "prio.h"
+#if defined(XP_WIN)
+# include <windows.h>
+#elif defined(MOZ_WIDGET_COCOA)
+# include <CoreServices/CoreServices.h>
+# include "nsCocoaFeatures.h"
+#elif defined(MOZ_WIDGET_GTK)
+# include <gtk/gtk.h>
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+# include "AndroidBuild.h"
+# include "mozilla/java/GeckoAppShellWrappers.h"
+#endif
+
+#ifdef MOZ_BACKGROUNDTASKS
+# include "mozilla/BackgroundTasks.h"
+#endif
+
+#include "mozilla/Services.h"
+
+#include "nsCRT.h"
+#include "nsConsoleMessage.h"
+#include "nsTextFormatter.h"
+#include "nsVersionComparator.h"
+#include "nsXPCOMCIDInternal.h"
+
+#include "nsIConsoleService.h"
+#include "nsIScriptError.h"
+#include "nsIXULAppInfo.h"
+#include "nsIXULRuntime.h"
+
+using namespace mozilla;
+
+struct ManifestDirective {
+ const char* directive;
+ int argc;
+
+ bool ischrome;
+
+ // The contentaccessible flags only apply to content/resource directives.
+ bool contentflags;
+
+ // Function to handle this directive. This isn't a union because C++ still
+ // hasn't learned how to initialize unions in a sane way.
+ void (nsComponentManagerImpl::*mgrfunc)(
+ nsComponentManagerImpl::ManifestProcessingContext& aCx, int aLineNo,
+ char* const* aArgv);
+ void (nsChromeRegistry::*regfunc)(
+ nsChromeRegistry::ManifestProcessingContext& aCx, int aLineNo,
+ char* const* aArgv, int aFlags);
+};
+static const ManifestDirective kParsingTable[] = {
+ // clang-format off
+ {
+ "manifest", 1, true, false,
+ &nsComponentManagerImpl::ManifestManifest, nullptr,
+ },
+ {
+ "category", 3, false, false,
+ &nsComponentManagerImpl::ManifestCategory, nullptr,
+ },
+ {
+ "content", 2, true, true,
+ nullptr, &nsChromeRegistry::ManifestContent,
+ },
+ {
+ "locale", 3, true, false,
+ nullptr, &nsChromeRegistry::ManifestLocale,
+ },
+ {
+ "skin", 3, true, false,
+ nullptr, &nsChromeRegistry::ManifestSkin,
+ },
+ {
+ // NB: note that while skin manifests can use this, they are only allowed
+ // to use it for chrome://../skin/ URLs
+ "override", 2, true, false,
+ nullptr, &nsChromeRegistry::ManifestOverride,
+ },
+ {
+ "resource", 2, false, true,
+ nullptr, &nsChromeRegistry::ManifestResource,
+ }
+ // clang-format on
+};
+
+static const char kWhitespace[] = "\t ";
+
+static bool IsNewline(char aChar) { return aChar == '\n' || aChar == '\r'; }
+
+void LogMessage(const char* aMsg, ...) {
+ MOZ_ASSERT(nsComponentManagerImpl::gComponentManager);
+
+ nsCOMPtr<nsIConsoleService> console =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ if (!console) {
+ return;
+ }
+
+ va_list args;
+ va_start(args, aMsg);
+ SmprintfPointer formatted(mozilla::Vsmprintf(aMsg, args));
+ va_end(args);
+
+ nsCOMPtr<nsIConsoleMessage> error =
+ new nsConsoleMessage(NS_ConvertUTF8toUTF16(formatted.get()));
+ console->LogMessage(error);
+}
+
+void LogMessageWithContext(FileLocation& aFile, uint32_t aLineNumber,
+ const char* aMsg, ...) {
+ va_list args;
+ va_start(args, aMsg);
+ SmprintfPointer formatted(mozilla::Vsmprintf(aMsg, args));
+ va_end(args);
+ if (!formatted) {
+ return;
+ }
+
+ MOZ_ASSERT(nsComponentManagerImpl::gComponentManager);
+
+ nsCString file;
+ aFile.GetURIString(file);
+
+ nsCOMPtr<nsIScriptError> error = do_CreateInstance(NS_SCRIPTERROR_CONTRACTID);
+ if (!error) {
+ // This can happen early in component registration. Fall back to a
+ // generic console message.
+ LogMessage("Warning: in '%s', line %i: %s", file.get(), aLineNumber,
+ formatted.get());
+ return;
+ }
+
+ nsCOMPtr<nsIConsoleService> console =
+ do_GetService(NS_CONSOLESERVICE_CONTRACTID);
+ if (!console) {
+ return;
+ }
+
+ nsresult rv = error->Init(
+ NS_ConvertUTF8toUTF16(formatted.get()), NS_ConvertUTF8toUTF16(file),
+ u""_ns, aLineNumber, 0, nsIScriptError::warningFlag,
+ "chrome registration"_ns, false /* from private window */,
+ true /* from chrome context */);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ console->LogMessage(error);
+}
+
+/**
+ * Check for a modifier flag of the following forms:
+ * "flag" (same as "true")
+ * "flag=yes|true|1"
+ * "flag="no|false|0"
+ * @param aFlag The flag to compare.
+ * @param aData The tokenized data to check; this is lowercased
+ * before being passed in.
+ * @param aResult If the flag is found, the value is assigned here.
+ * @return Whether the flag was handled.
+ */
+static bool CheckFlag(const nsAString& aFlag, const nsAString& aData,
+ bool& aResult) {
+ if (!StringBeginsWith(aData, aFlag)) {
+ return false;
+ }
+
+ if (aFlag.Length() == aData.Length()) {
+ // the data is simply "flag", which is the same as "flag=yes"
+ aResult = true;
+ return true;
+ }
+
+ if (aData.CharAt(aFlag.Length()) != '=') {
+ // the data is "flag2=", which is not anything we care about
+ return false;
+ }
+
+ if (aData.Length() == aFlag.Length() + 1) {
+ aResult = false;
+ return true;
+ }
+
+ switch (aData.CharAt(aFlag.Length() + 1)) {
+ case '1':
+ case 't': // true
+ case 'y': // yes
+ aResult = true;
+ return true;
+
+ case '0':
+ case 'f': // false
+ case 'n': // no
+ aResult = false;
+ return true;
+ }
+
+ return false;
+}
+
+enum TriState { eUnspecified, eBad, eOK };
+
+/**
+ * Check for a modifier flag of the following form:
+ * "flag=string"
+ * "flag!=string"
+ * @param aFlag The flag to compare.
+ * @param aData The tokenized data to check; this is lowercased
+ * before being passed in.
+ * @param aValue The value that is expected.
+ * @param aResult If this is "ok" when passed in, this is left alone.
+ * Otherwise if the flag is found it is set to eBad or eOK.
+ * @return Whether the flag was handled.
+ */
+static bool CheckStringFlag(const nsAString& aFlag, const nsAString& aData,
+ const nsAString& aValue, TriState& aResult) {
+ if (aData.Length() < aFlag.Length() + 1) {
+ return false;
+ }
+
+ if (!StringBeginsWith(aData, aFlag)) {
+ return false;
+ }
+
+ bool comparison = true;
+ if (aData[aFlag.Length()] != '=') {
+ if (aData[aFlag.Length()] == '!' && aData.Length() >= aFlag.Length() + 2 &&
+ aData[aFlag.Length() + 1] == '=') {
+ comparison = false;
+ } else {
+ return false;
+ }
+ }
+
+ if (aResult != eOK) {
+ nsDependentSubstring testdata =
+ Substring(aData, aFlag.Length() + (comparison ? 1 : 2));
+ if (testdata.Equals(aValue)) {
+ aResult = comparison ? eOK : eBad;
+ } else {
+ aResult = comparison ? eBad : eOK;
+ }
+ }
+
+ return true;
+}
+
+static bool CheckOsFlag(const nsAString& aFlag, const nsAString& aData,
+ const nsAString& aValue, TriState& aResult) {
+ bool result = CheckStringFlag(aFlag, aData, aValue, aResult);
+#if defined(XP_UNIX) && !defined(XP_DARWIN) && !defined(ANDROID)
+ if (result && aResult == eBad) {
+ result = CheckStringFlag(aFlag, aData, u"likeunix"_ns, aResult);
+ }
+#endif
+ return result;
+}
+
+/**
+ * Check for a modifier flag of the following form:
+ * "flag=version"
+ * "flag<=version"
+ * "flag<version"
+ * "flag>=version"
+ * "flag>version"
+ * @param aFlag The flag to compare.
+ * @param aData The tokenized data to check; this is lowercased
+ * before being passed in.
+ * @param aValue The value that is expected. If this is empty then no
+ * comparison will match.
+ * @param aResult If this is eOK when passed in, this is left alone.
+ * Otherwise if the flag is found it is set to eBad or eOK.
+ * @return Whether the flag was handled.
+ */
+
+#define COMPARE_EQ 1 << 0
+#define COMPARE_LT 1 << 1
+#define COMPARE_GT 1 << 2
+
+static bool CheckVersionFlag(const nsString& aFlag, const nsString& aData,
+ const nsString& aValue, TriState& aResult) {
+ if (aData.Length() < aFlag.Length() + 2) {
+ return false;
+ }
+
+ if (!StringBeginsWith(aData, aFlag)) {
+ return false;
+ }
+
+ if (aValue.Length() == 0) {
+ if (aResult != eOK) {
+ aResult = eBad;
+ }
+ return true;
+ }
+
+ uint32_t comparison;
+ nsAutoString testdata;
+
+ switch (aData[aFlag.Length()]) {
+ case '=':
+ comparison = COMPARE_EQ;
+ testdata = Substring(aData, aFlag.Length() + 1);
+ break;
+
+ case '<':
+ if (aData[aFlag.Length() + 1] == '=') {
+ comparison = COMPARE_EQ | COMPARE_LT;
+ testdata = Substring(aData, aFlag.Length() + 2);
+ } else {
+ comparison = COMPARE_LT;
+ testdata = Substring(aData, aFlag.Length() + 1);
+ }
+ break;
+
+ case '>':
+ if (aData[aFlag.Length() + 1] == '=') {
+ comparison = COMPARE_EQ | COMPARE_GT;
+ testdata = Substring(aData, aFlag.Length() + 2);
+ } else {
+ comparison = COMPARE_GT;
+ testdata = Substring(aData, aFlag.Length() + 1);
+ }
+ break;
+
+ default:
+ return false;
+ }
+
+ if (testdata.Length() == 0) {
+ return false;
+ }
+
+ if (aResult != eOK) {
+ int32_t c = mozilla::CompareVersions(NS_ConvertUTF16toUTF8(aValue).get(),
+ NS_ConvertUTF16toUTF8(testdata).get());
+ if ((c == 0 && comparison & COMPARE_EQ) ||
+ (c < 0 && comparison & COMPARE_LT) ||
+ (c > 0 && comparison & COMPARE_GT)) {
+ aResult = eOK;
+ } else {
+ aResult = eBad;
+ }
+ }
+
+ return true;
+}
+
+// In-place conversion of ascii characters to lower case
+static void ToLowerCase(char* aToken) {
+ for (; *aToken; ++aToken) {
+ *aToken = NS_ToLower(*aToken);
+ }
+}
+
+namespace {
+
+struct CachedDirective {
+ int lineno;
+ char* argv[4];
+};
+
+} // namespace
+
+void ParseManifest(NSLocationType aType, FileLocation& aFile, char* aBuf,
+ bool aChromeOnly) {
+ nsComponentManagerImpl::ManifestProcessingContext mgrcx(aType, aFile,
+ aChromeOnly);
+ nsChromeRegistry::ManifestProcessingContext chromecx(aType, aFile);
+ nsresult rv;
+
+ constexpr auto kContentAccessible = u"contentaccessible"_ns;
+ constexpr auto kRemoteEnabled = u"remoteenabled"_ns;
+ constexpr auto kRemoteRequired = u"remoterequired"_ns;
+ constexpr auto kApplication = u"application"_ns;
+ constexpr auto kAppVersion = u"appversion"_ns;
+ constexpr auto kGeckoVersion = u"platformversion"_ns;
+ constexpr auto kOs = u"os"_ns;
+ constexpr auto kOsVersion = u"osversion"_ns;
+ constexpr auto kABI = u"abi"_ns;
+ constexpr auto kProcess = u"process"_ns;
+#if defined(MOZ_WIDGET_ANDROID)
+ constexpr auto kTablet = u"tablet"_ns;
+#endif
+ // You might expect this to be guarded by MOZ_BACKGROUNDTASKS, but it's not
+ // possible to have conditional manifest contents, so we need to recognize and
+ // discard these tokens even when MOZ_BACKGROUNDTASKS is not set.
+ constexpr auto kBackgroundTask = u"backgroundtask"_ns;
+
+ constexpr auto kMain = u"main"_ns;
+ constexpr auto kContent = u"content"_ns;
+
+ // Obsolete
+ constexpr auto kXPCNativeWrappers = u"xpcnativewrappers"_ns;
+
+ nsAutoString appID;
+ nsAutoString appVersion;
+ nsAutoString geckoVersion;
+ nsAutoString osTarget;
+ nsAutoString abi;
+ nsAutoString process;
+
+ nsCOMPtr<nsIXULAppInfo> xapp(do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
+ if (xapp) {
+ nsAutoCString s;
+ rv = xapp->GetID(s);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(s, appID);
+ }
+
+ rv = xapp->GetVersion(s);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(s, appVersion);
+ }
+
+ rv = xapp->GetPlatformVersion(s);
+ if (NS_SUCCEEDED(rv)) {
+ CopyUTF8toUTF16(s, geckoVersion);
+ }
+
+ nsCOMPtr<nsIXULRuntime> xruntime(do_QueryInterface(xapp));
+ if (xruntime) {
+ rv = xruntime->GetOS(s);
+ if (NS_SUCCEEDED(rv)) {
+ ToLowerCase(s);
+ CopyUTF8toUTF16(s, osTarget);
+ }
+
+ rv = xruntime->GetXPCOMABI(s);
+ if (NS_SUCCEEDED(rv) && osTarget.Length()) {
+ ToLowerCase(s);
+ CopyUTF8toUTF16(s, abi);
+ abi.Insert(char16_t('_'), 0);
+ abi.Insert(osTarget, 0);
+ }
+ }
+ }
+
+ nsAutoString osVersion;
+#if defined(XP_WIN)
+# pragma warning(push)
+# pragma warning(disable : 4996) // VC12+ deprecates GetVersionEx
+ OSVERSIONINFO info = {sizeof(OSVERSIONINFO)};
+ if (GetVersionEx(&info)) {
+ nsTextFormatter::ssprintf(osVersion, u"%ld.%ld", info.dwMajorVersion,
+ info.dwMinorVersion);
+ }
+# pragma warning(pop)
+#elif defined(MOZ_WIDGET_COCOA)
+ SInt32 majorVersion = nsCocoaFeatures::macOSVersionMajor();
+ SInt32 minorVersion = nsCocoaFeatures::macOSVersionMinor();
+ nsTextFormatter::ssprintf(osVersion, u"%ld.%ld", majorVersion, minorVersion);
+#elif defined(MOZ_WIDGET_GTK)
+ nsTextFormatter::ssprintf(osVersion, u"%ld.%ld", gtk_major_version,
+ gtk_minor_version);
+#elif defined(MOZ_WIDGET_ANDROID)
+ bool isTablet = false;
+ if (jni::IsAvailable()) {
+ jni::String::LocalRef release = java::sdk::Build::VERSION::RELEASE();
+ osVersion.Assign(release->ToString());
+ isTablet = java::GeckoAppShell::IsTablet();
+ }
+#endif
+
+ if (XRE_IsContentProcess()) {
+ process = kContent;
+ } else {
+ process = kMain;
+ }
+
+ char* token;
+ char* newline = aBuf;
+ uint32_t line = 0;
+
+ // outer loop tokenizes by newline
+ while (*newline) {
+ while (*newline && IsNewline(*newline)) {
+ ++newline;
+ ++line;
+ }
+ if (!*newline) {
+ break;
+ }
+
+ token = newline;
+ while (*newline && !IsNewline(*newline)) {
+ ++newline;
+ }
+
+ if (*newline) {
+ *newline = '\0';
+ ++newline;
+ }
+ ++line;
+
+ if (*token == '#') { // ignore lines that begin with # as comments
+ continue;
+ }
+
+ char* whitespace = token;
+ token = nsCRT::strtok(whitespace, kWhitespace, &whitespace);
+ if (!token) {
+ continue;
+ }
+
+ const ManifestDirective* directive = nullptr;
+ for (const ManifestDirective* d = kParsingTable;
+ d < ArrayEnd(kParsingTable); ++d) {
+ if (!strcmp(d->directive, token)) {
+ directive = d;
+ break;
+ }
+ }
+
+ if (!directive) {
+ LogMessageWithContext(
+ aFile, line, "Ignoring unrecognized chrome manifest directive '%s'.",
+ token);
+ continue;
+ }
+
+ if (!directive->ischrome && NS_BOOTSTRAPPED_LOCATION == aType) {
+ LogMessageWithContext(
+ aFile, line,
+ "Bootstrapped manifest not allowed to use '%s' directive.", token);
+ continue;
+ }
+
+ NS_ASSERTION(directive->argc < 4, "Need to reset argv array length");
+ char* argv[4];
+ for (int i = 0; i < directive->argc; ++i) {
+ argv[i] = nsCRT::strtok(whitespace, kWhitespace, &whitespace);
+ }
+
+ if (!argv[directive->argc - 1]) {
+ LogMessageWithContext(aFile, line,
+ "Not enough arguments for chrome manifest "
+ "directive '%s', expected %i.",
+ token, directive->argc);
+ continue;
+ }
+
+ bool ok = true;
+ TriState stAppVersion = eUnspecified;
+ TriState stGeckoVersion = eUnspecified;
+ TriState stApp = eUnspecified;
+ TriState stOsVersion = eUnspecified;
+ TriState stOs = eUnspecified;
+ TriState stABI = eUnspecified;
+ TriState stProcess = eUnspecified;
+#if defined(MOZ_WIDGET_ANDROID)
+ TriState stTablet = eUnspecified;
+#endif
+#ifdef MOZ_BACKGROUNDTASKS
+ // When in background task mode, default to not registering
+ // category directivies unless backgroundtask=1 is specified.
+ TriState stBackgroundTask = (BackgroundTasks::IsBackgroundTaskMode() &&
+ strcmp("category", directive->directive) == 0)
+ ? eBad
+ : eUnspecified;
+#endif
+ int flags = 0;
+
+ while ((token = nsCRT::strtok(whitespace, kWhitespace, &whitespace)) &&
+ ok) {
+ ToLowerCase(token);
+ NS_ConvertASCIItoUTF16 wtoken(token);
+
+ if (CheckStringFlag(kApplication, wtoken, appID, stApp) ||
+ CheckOsFlag(kOs, wtoken, osTarget, stOs) ||
+ CheckStringFlag(kABI, wtoken, abi, stABI) ||
+ CheckStringFlag(kProcess, wtoken, process, stProcess) ||
+ CheckVersionFlag(kOsVersion, wtoken, osVersion, stOsVersion) ||
+ CheckVersionFlag(kAppVersion, wtoken, appVersion, stAppVersion) ||
+ CheckVersionFlag(kGeckoVersion, wtoken, geckoVersion,
+ stGeckoVersion)) {
+ continue;
+ }
+
+#if defined(MOZ_WIDGET_ANDROID)
+ bool tablet = false;
+ if (CheckFlag(kTablet, wtoken, tablet)) {
+ stTablet = (tablet == isTablet) ? eOK : eBad;
+ continue;
+ }
+#endif
+
+ // You might expect this to be guarded by MOZ_BACKGROUNDTASKS, it's not
+ // possible to have conditional manifest contents.
+ bool flag;
+ if (CheckFlag(kBackgroundTask, wtoken, flag)) {
+#if defined(MOZ_BACKGROUNDTASKS)
+ // Background task mode is active: filter.
+ stBackgroundTask =
+ (flag == BackgroundTasks::IsBackgroundTaskMode()) ? eOK : eBad;
+#endif /* defined(MOZ_BACKGROUNDTASKS) */
+ continue;
+ }
+
+ if (directive->contentflags) {
+ bool flag;
+ if (CheckFlag(kContentAccessible, wtoken, flag)) {
+ if (flag) flags |= nsChromeRegistry::CONTENT_ACCESSIBLE;
+ continue;
+ }
+ if (CheckFlag(kRemoteEnabled, wtoken, flag)) {
+ if (flag) flags |= nsChromeRegistry::REMOTE_ALLOWED;
+ continue;
+ }
+ if (CheckFlag(kRemoteRequired, wtoken, flag)) {
+ if (flag) flags |= nsChromeRegistry::REMOTE_REQUIRED;
+ continue;
+ }
+ }
+
+ bool xpcNativeWrappers = true; // Dummy for CheckFlag.
+ if (CheckFlag(kXPCNativeWrappers, wtoken, xpcNativeWrappers)) {
+ LogMessageWithContext(
+ aFile, line, "Ignoring obsolete chrome registration modifier '%s'.",
+ token);
+ continue;
+ }
+
+ LogMessageWithContext(
+ aFile, line, "Unrecognized chrome manifest modifier '%s'.", token);
+ ok = false;
+ }
+
+ if (!ok || stApp == eBad || stAppVersion == eBad ||
+ stGeckoVersion == eBad || stOs == eBad || stOsVersion == eBad ||
+#ifdef MOZ_WIDGET_ANDROID
+ stTablet == eBad ||
+#endif
+#ifdef MOZ_BACKGROUNDTASKS
+ stBackgroundTask == eBad ||
+#endif
+ stABI == eBad || stProcess == eBad) {
+ continue;
+ }
+
+ if (directive->regfunc) {
+ if (GeckoProcessType_Default != XRE_GetProcessType()) {
+ continue;
+ }
+
+ if (!nsChromeRegistry::gChromeRegistry) {
+ nsCOMPtr<nsIChromeRegistry> cr = mozilla::services::GetChromeRegistry();
+ if (!nsChromeRegistry::gChromeRegistry) {
+ LogMessageWithContext(aFile, line,
+ "Chrome registry isn't available yet.");
+ continue;
+ }
+ }
+
+ (nsChromeRegistry::gChromeRegistry->*(directive->regfunc))(chromecx, line,
+ argv, flags);
+ } else if (directive->ischrome || !aChromeOnly) {
+ (nsComponentManagerImpl::gComponentManager->*(directive->mgrfunc))(
+ mgrcx, line, argv);
+ }
+ }
+}
diff --git a/xpcom/components/ManifestParser.h b/xpcom/components/ManifestParser.h
new file mode 100644
index 0000000000..e66cb58bcb
--- /dev/null
+++ b/xpcom/components/ManifestParser.h
@@ -0,0 +1,23 @@
+/* -*- 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/. */
+
+#ifndef ManifestParser_h
+#define ManifestParser_h
+
+#include "nsComponentManager.h"
+#include "nsChromeRegistry.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/FileLocation.h"
+
+void ParseManifest(NSLocationType aType, mozilla::FileLocation& aFile,
+ char* aBuf, bool aChromeOnly);
+
+void LogMessage(const char* aMsg, ...) MOZ_FORMAT_PRINTF(1, 2);
+
+void LogMessageWithContext(mozilla::FileLocation& aFile, uint32_t aLineNumber,
+ const char* aMsg, ...) MOZ_FORMAT_PRINTF(3, 4);
+
+#endif // ManifestParser_h
diff --git a/xpcom/components/Module.h b/xpcom/components/Module.h
new file mode 100644
index 0000000000..044626b1ab
--- /dev/null
+++ b/xpcom/components/Module.h
@@ -0,0 +1,76 @@
+/* -*- 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/. */
+
+#ifndef mozilla_Module_h
+#define mozilla_Module_h
+
+#include "nscore.h"
+
+namespace mozilla {
+
+namespace Module {
+/**
+ * This selector allows components to be marked so that they're only loaded
+ * into certain kinds of processes. Selectors can be combined.
+ */
+// Note: This must be kept in sync with the selector matching in
+// nsComponentManager.cpp.
+enum ProcessSelector {
+ ANY_PROCESS = 0x0,
+ MAIN_PROCESS_ONLY = 0x1,
+ CONTENT_PROCESS_ONLY = 0x2,
+
+ /**
+ * By default, modules are not loaded in the GPU, VR, Socket, RDD, Utility
+ * and IPDLUnitTest processes, even if ANY_PROCESS is specified. This flag
+ * enables a module in the relevant process.
+ *
+ * NOTE: IPDLUnitTest does not have its own flag, and will only load a
+ * module if it is enabled in all processes.
+ */
+ ALLOW_IN_GPU_PROCESS = 0x4,
+ ALLOW_IN_VR_PROCESS = 0x8,
+ ALLOW_IN_SOCKET_PROCESS = 0x10,
+ ALLOW_IN_RDD_PROCESS = 0x20,
+ ALLOW_IN_UTILITY_PROCESS = 0x30,
+ ALLOW_IN_GPU_AND_MAIN_PROCESS = ALLOW_IN_GPU_PROCESS | MAIN_PROCESS_ONLY,
+ ALLOW_IN_GPU_AND_VR_PROCESS = ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS,
+ ALLOW_IN_GPU_AND_SOCKET_PROCESS =
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_SOCKET_PROCESS,
+ ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS =
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS | ALLOW_IN_SOCKET_PROCESS,
+ ALLOW_IN_RDD_AND_SOCKET_PROCESS =
+ ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS,
+ ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS =
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS,
+ ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS =
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS,
+ ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS =
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_VR_PROCESS |
+ ALLOW_IN_SOCKET_PROCESS,
+ ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS =
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_VR_PROCESS |
+ ALLOW_IN_SOCKET_PROCESS | ALLOW_IN_UTILITY_PROCESS
+};
+
+static constexpr size_t kMaxProcessSelector =
+ size_t(ProcessSelector::ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS);
+
+/**
+ * This allows category entries to be marked so that they are or are
+ * not loaded when in backgroundtask mode.
+ */
+// Note: This must be kept in sync with the selector matching in
+// StaticComponents.cpp.in.
+enum BackgroundTasksSelector {
+ NO_TASKS = 0x0,
+ ALL_TASKS = 0xFFFF,
+};
+}; // namespace Module
+
+} // namespace mozilla
+
+#endif // mozilla_Module_h
diff --git a/xpcom/components/ModuleUtils.h b/xpcom/components/ModuleUtils.h
new file mode 100644
index 0000000000..92ec8aa173
--- /dev/null
+++ b/xpcom/components/ModuleUtils.h
@@ -0,0 +1,81 @@
+/* -*- 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/. */
+
+#ifndef mozilla_GenericModule_h
+#define mozilla_GenericModule_h
+
+#include <type_traits>
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Module.h"
+
+#define NS_GENERIC_FACTORY_CONSTRUCTOR(_InstanceClass) \
+ static nsresult _InstanceClass##Constructor(REFNSIID aIID, void** aResult) { \
+ RefPtr<_InstanceClass> inst; \
+ \
+ *aResult = nullptr; \
+ \
+ inst = new _InstanceClass(); \
+ return inst->QueryInterface(aIID, aResult); \
+ }
+
+#define NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(_InstanceClass, _InitMethod) \
+ static nsresult _InstanceClass##Constructor(REFNSIID aIID, void** aResult) { \
+ nsresult rv; \
+ \
+ RefPtr<_InstanceClass> inst; \
+ \
+ *aResult = nullptr; \
+ \
+ inst = new _InstanceClass(); \
+ rv = inst->_InitMethod(); \
+ if (NS_SUCCEEDED(rv)) { \
+ rv = inst->QueryInterface(aIID, aResult); \
+ } \
+ \
+ return rv; \
+ }
+
+namespace mozilla {
+namespace detail {
+
+template <typename T>
+struct RemoveAlreadyAddRefed {
+ using Type = T;
+};
+
+template <typename T>
+struct RemoveAlreadyAddRefed<already_AddRefed<T>> {
+ using Type = T;
+};
+
+} // namespace detail
+} // namespace mozilla
+
+// 'Constructor' that uses an existing getter function that gets a singleton.
+#define NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(_InstanceClass, _GetterProc) \
+ static nsresult _InstanceClass##Constructor(REFNSIID aIID, void** aResult) { \
+ RefPtr<_InstanceClass> inst; \
+ \
+ *aResult = nullptr; \
+ \
+ using T = \
+ mozilla::detail::RemoveAlreadyAddRefed<decltype(_GetterProc())>::Type; \
+ static_assert( \
+ std::is_same_v<already_AddRefed<T>, decltype(_GetterProc())>, \
+ "Singleton constructor must return already_AddRefed"); \
+ static_assert( \
+ std::is_base_of<_InstanceClass, T>::value, \
+ "Singleton constructor must return correct already_AddRefed"); \
+ inst = _GetterProc(); \
+ if (nullptr == inst) { \
+ return NS_ERROR_OUT_OF_MEMORY; \
+ } \
+ return inst->QueryInterface(aIID, aResult); \
+ }
+
+#endif // mozilla_GenericModule_h
diff --git a/xpcom/components/StaticComponents.cpp.in b/xpcom/components/StaticComponents.cpp.in
new file mode 100644
index 0000000000..7f3fee6859
--- /dev/null
+++ b/xpcom/components/StaticComponents.cpp.in
@@ -0,0 +1,410 @@
+/* -*- 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 "StaticComponents.h"
+
+#include "mozilla/ArrayUtils.h"
+#ifdef MOZ_BACKGROUNDTASKS
+# include "mozilla/BackgroundTasks.h"
+#endif
+#include "mozilla/PerfectHash.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozJSModuleLoader.h"
+#include "nsCOMPtr.h"
+#include "nsComponentManager.h"
+#include "nsContentUtils.h"
+#include "nsIFactory.h"
+#include "nsISupports.h"
+#include "nsIXPConnect.h"
+#include "nsString.h"
+#include "nsStringEnumerator.h"
+#include "nsTArray.h"
+#include "xptdata.h"
+#include "xptinfo.h"
+#include "js/PropertyAndElement.h" // JS_GetProperty
+
+// Cleanup pollution from zipstruct.h
+#undef UNSUPPORTED
+
+// Public includes
+//# @includes@
+
+// Relative includes
+//# @relative_includes@
+
+//# @decls@
+
+namespace mozilla {
+
+using dom::AutoJSAPI;
+
+namespace xpcom {
+
+static constexpr uint32_t kNoContractID = 0xffffffff;
+
+namespace {
+// Template helpers for constructor function sanity checks.
+template <typename T>
+struct RemoveAlreadyAddRefed {
+ using Type = T;
+};
+
+template <typename T>
+struct RemoveAlreadyAddRefed<already_AddRefed<T>> {
+ using Type = T;
+};
+} // anonymous namespace
+
+
+uint8_t gInvalidContracts[kContractCount / 8 + 1];
+
+static StaticRefPtr<nsISupports> gServiceInstances[kStaticModuleCount];
+
+uint8_t gInitCalled[kModuleInitCount / 8 + 1];
+
+static const char gStrings[] =
+//# @strings@
+ "";
+
+const StaticCategory gStaticCategories[kStaticCategoryCount] = {
+//# @categories@
+};
+const StaticCategoryEntry gStaticCategoryEntries[] = {
+//# @category_entries@
+};
+
+const nsXPTInterface gInterfaces[] = {
+//# @interfaces@
+};
+
+const StringOffset gComponentJSMs[] = {
+//# @component_jsms@
+};
+
+const StringOffset gComponentESModules[] = {
+//# @component_esmodules@
+};
+
+/**
+ * Returns a nsCString corresponding to the given entry in the `gStrings` string
+ * table. The resulting nsCString points directly to static storage, and does
+ * not incur any memory allocation overhead.
+ */
+static inline nsCString GetString(const StringOffset& aOffset) {
+ const char* str = &gStrings[aOffset.mOffset];
+ nsCString result;
+ result.AssignLiteral(str, strlen(str));
+ return result;
+}
+
+nsCString ContractEntry::ContractID() const {
+ return GetString(mContractID);
+}
+
+bool ContractEntry::Matches(const nsACString& aContractID) const {
+ return aContractID == ContractID() && Module().Active();
+}
+
+enum class ComponentType { JSM, ESM };
+
+template <ComponentType type>
+static nsresult ConstructJSMOrESMComponent(const nsACString& aURI,
+ const char* aConstructor,
+ nsISupports** aResult) {
+ if (!nsComponentManagerImpl::JSLoaderReady()) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ AutoJSAPI jsapi;
+ MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope()));
+ JSContext* cx = jsapi.cx();
+
+ JS::Rooted<JSObject*> exports(cx);
+ if constexpr (type == ComponentType::JSM) {
+ JS::Rooted<JSObject*> global(cx);
+ MOZ_TRY(mozJSModuleLoader::Get()->Import(cx, aURI, &global, &exports));
+ } else {
+ MOZ_TRY(mozJSModuleLoader::Get()->ImportESModule(cx, aURI, &exports));
+ }
+
+ JS::Rooted<JS::Value> ctor(cx);
+ if (!JS_GetProperty(cx, exports, aConstructor, &ctor) ||
+ !ctor.isObject()) {
+ return NS_ERROR_XPC_JSOBJECT_HAS_NO_FUNCTION_NAMED;
+ }
+
+ JS::Rooted<JSObject*> inst(cx);
+ if (!JS::Construct(cx, ctor, JS::HandleValueArray::empty(), &inst)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return nsContentUtils::XPConnect()->WrapJS(cx, inst, NS_GET_IID(nsISupports),
+ (void**)aResult);
+}
+
+static nsresult ConstructJSMComponent(const nsACString& aURI,
+ const char* aConstructor,
+ nsISupports** aResult) {
+ return ConstructJSMOrESMComponent<ComponentType::JSM>(
+ aURI, aConstructor, aResult);
+}
+
+static nsresult ConstructESModuleComponent(const nsACString& aURI,
+ const char* aConstructor,
+ nsISupports** aResult) {
+ return ConstructJSMOrESMComponent<ComponentType::ESM>(
+ aURI, aConstructor, aResult);
+}
+
+//# @module_cid_table@
+
+//# @module_contract_id_table@
+
+//# @js_services_table@
+
+//# @protocol_handlers_table@
+
+static inline bool CalledInit(size_t aIdx) {
+ return GetBit(gInitCalled, aIdx);
+}
+
+static nsresult CallInitFunc(size_t aIdx) {
+ if (CalledInit(aIdx)) {
+ return NS_OK;
+ }
+
+ nsresult rv = NS_OK;
+ switch (aIdx) {
+//# @init_funcs@
+ }
+
+ SetBit(gInitCalled, aIdx);
+
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+ return rv;
+}
+
+static void CallUnloadFuncs() {
+//# @unload_funcs@
+}
+
+nsresult CreateInstanceImpl(ModuleID aID, const nsIID& aIID, void** aResult) {
+ // The full set of constructors for all static modules.
+ // This switch statement will be compiled to a relative address jump table
+ // with no runtime relocations and a single indirect jump.
+ switch (aID) {
+//# @constructors@
+ }
+
+ MOZ_ASSERT_UNREACHABLE("Constructor didn't return");
+ return NS_ERROR_FAILURE;
+}
+
+
+namespace {
+
+class StaticModuleFactory final : public nsIFactory {
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIFACTORY
+
+ explicit StaticModuleFactory(ModuleID aID) : mID(aID) {}
+
+private:
+ ~StaticModuleFactory() = default;
+
+ const ModuleID mID;
+};
+
+NS_IMPL_ISUPPORTS(StaticModuleFactory, nsIFactory)
+
+NS_IMETHODIMP StaticModuleFactory::CreateInstance(const nsIID& aIID,
+ void** aResult) {
+ return CreateInstanceImpl(mID, aIID, aResult);
+}
+
+} // anonymous namespace
+
+
+already_AddRefed<nsIFactory> StaticModule::GetFactory() const {
+ return do_AddRef(new StaticModuleFactory(ID()));
+}
+
+bool StaticModule::Active() const {
+ return FastProcessSelectorMatches(mProcessSelector);
+}
+
+bool StaticModule::Overridable() const {
+ return mContractID.mOffset != kNoContractID;
+}
+
+nsCString StaticModule::ContractID() const {
+ MOZ_ASSERT(Overridable());
+ return GetString(mContractID);
+}
+
+nsresult StaticModule::CreateInstance(const nsIID& aIID, void** aResult) const {
+ return CreateInstanceImpl(ID(), aIID, aResult);
+}
+
+GetServiceHelper StaticModule::GetService() const {
+ return { ID(), nullptr };
+}
+
+GetServiceHelper StaticModule::GetService(nsresult* aRv) const {
+ return { ID(), aRv };
+}
+
+
+nsISupports* StaticModule::ServiceInstance() const {
+ return gServiceInstances[Idx()];
+}
+
+void StaticModule::SetServiceInstance(
+ already_AddRefed<nsISupports> aInst) const {
+ gServiceInstances[Idx()] = aInst;
+}
+
+
+nsCString StaticCategoryEntry::Entry() const {
+ return GetString(mEntry);
+}
+
+nsCString StaticCategoryEntry::Value() const {
+ return GetString(mValue);
+}
+
+bool StaticCategoryEntry::Active() const {
+ if (!FastProcessSelectorMatches(mProcessSelector)) {
+ return false;
+ }
+#ifdef MOZ_BACKGROUNDTASKS
+ if (MOZ_UNLIKELY(BackgroundTasks::IsBackgroundTaskMode())) {
+ return mBackgroundTasksSelector != Module::BackgroundTasksSelector::NO_TASKS;
+ }
+#endif /* MOZ_BACKGROUNDTASKS */
+ return true;
+}
+
+nsCString StaticCategory::Name() const {
+ return GetString(mName);
+}
+
+nsCString JSServiceEntry::Name() const {
+ return GetString(mName);
+}
+
+JSServiceEntry::InterfaceList JSServiceEntry::Interfaces() const {
+ InterfaceList iids;
+ iids.SetCapacity(mInterfaceCount);
+
+ for (size_t i = 0; i < mInterfaceCount; i++) {
+ nsXPTInterface ifaceID = gInterfaces[mInterfaceOffset.mOffset + i];
+ iids.AppendElement(&nsXPTInterfaceInfo::Get(ifaceID)->IID());
+ }
+ return iids;
+}
+
+
+/* static */
+const JSServiceEntry* JSServiceEntry::Lookup(const nsACString& aName) {
+ return LookupJSService(aName);
+}
+
+nsCString StaticProtocolHandler::Scheme() const {
+ return GetString(mScheme);
+}
+
+/* static */
+const StaticProtocolHandler* StaticProtocolHandler::Lookup(const nsACString& aScheme) {
+ return LookupProtocolHandler(aScheme);
+}
+
+/* static */ const StaticModule* StaticComponents::LookupByCID(
+ const nsID& aCID) {
+ return ModuleByCID(aCID);
+}
+
+/* static */ const StaticModule* StaticComponents::LookupByContractID(
+ const nsACString& aContractID) {
+ if (const ContractEntry* entry = LookupContractID(aContractID)) {
+ if (!entry->Invalid()) {
+ return &entry->Module();
+ }
+ }
+ return nullptr;
+}
+
+/* static */ bool StaticComponents::InvalidateContractID(
+ const nsACString& aContractID, bool aInvalid) {
+ if (const ContractEntry* entry = LookupContractID(aContractID)) {
+ entry->SetInvalid(aInvalid);
+ return true;
+ }
+ return false;
+}
+
+/* static */ already_AddRefed<nsIUTF8StringEnumerator>
+StaticComponents::GetComponentJSMs() {
+ auto jsms = MakeUnique<nsTArray<nsCString>>(MOZ_ARRAY_LENGTH(gComponentJSMs));
+
+ for (const auto& entry : gComponentJSMs) {
+ jsms->AppendElement(GetString(entry));
+ }
+
+ nsCOMPtr<nsIUTF8StringEnumerator> result;
+ MOZ_ALWAYS_SUCCEEDS(NS_NewAdoptingUTF8StringEnumerator(getter_AddRefs(result),
+ jsms.release()));
+ return result.forget();
+}
+
+/* static */ already_AddRefed<nsIUTF8StringEnumerator>
+StaticComponents::GetComponentESModules() {
+ auto esModules = MakeUnique<nsTArray<nsCString>>(MOZ_ARRAY_LENGTH(gComponentESModules));
+
+ for (const auto& entry : gComponentESModules) {
+ esModules->AppendElement(GetString(entry));
+ }
+
+ nsCOMPtr<nsIUTF8StringEnumerator> result;
+ MOZ_ALWAYS_SUCCEEDS(NS_NewAdoptingUTF8StringEnumerator(getter_AddRefs(result),
+ esModules.release()));
+ return result.forget();
+}
+
+/* static */ Span<const JSServiceEntry> StaticComponents::GetJSServices() {
+ return { gJSServices, ArrayLength(gJSServices) };
+}
+
+/* static */ void StaticComponents::Shutdown() {
+ CallUnloadFuncs();
+}
+
+/* static */ const nsID& Components::GetCID(ModuleID aID) {
+ return gStaticModules[size_t(aID)].CID();
+}
+
+nsresult GetServiceHelper::operator()(const nsIID& aIID, void** aResult) const {
+ nsresult rv =
+ nsComponentManagerImpl::gComponentManager->GetService(mId, aIID, aResult);
+ return SetResult(rv);
+}
+
+nsresult CreateInstanceHelper::operator()(const nsIID& aIID,
+ void** aResult) const {
+ const auto& entry = gStaticModules[size_t(mId)];
+ if (!entry.Active()) {
+ return SetResult(NS_ERROR_FACTORY_NOT_REGISTERED);
+ }
+
+ nsresult rv = entry.CreateInstance(aIID, aResult);
+ return SetResult(rv);
+}
+
+} // namespace xpcom
+} // namespace mozilla
diff --git a/xpcom/components/StaticComponents.h b/xpcom/components/StaticComponents.h
new file mode 100644
index 0000000000..ac4095f2f3
--- /dev/null
+++ b/xpcom/components/StaticComponents.h
@@ -0,0 +1,284 @@
+/* -*- 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/. */
+
+#ifndef StaticComponents_h
+#define StaticComponents_h
+
+#include "mozilla/AlreadyAddRefed.h"
+#include "mozilla/Module.h"
+#include "mozilla/Span.h"
+#include "nsID.h"
+#include "nsStringFwd.h"
+#include "nscore.h"
+
+#include "mozilla/Components.h"
+#include "StaticComponentData.h"
+
+class nsIFactory;
+class nsIUTF8StringEnumerator;
+class nsISupports;
+template <typename T, size_t N>
+class AutoTArray;
+
+namespace mozilla {
+namespace xpcom {
+
+struct ContractEntry;
+struct StaticModule;
+
+struct StaticCategoryEntry;
+struct StaticCategory;
+
+struct StaticProtocolHandler;
+
+extern const StaticModule gStaticModules[kStaticModuleCount];
+
+extern const ContractEntry gContractEntries[kContractCount];
+extern uint8_t gInvalidContracts[kContractCount / 8 + 1];
+
+extern const StaticCategory gStaticCategories[kStaticCategoryCount];
+extern const StaticCategoryEntry gStaticCategoryEntries[];
+
+extern const StaticProtocolHandler
+ gStaticProtocolHandlers[kStaticProtocolHandlerCount];
+
+template <size_t N>
+static inline bool GetBit(const uint8_t (&aBits)[N], size_t aBit) {
+ static constexpr size_t width = sizeof(aBits[0]) * 8;
+
+ size_t idx = aBit / width;
+ MOZ_ASSERT(idx < N);
+ return aBits[idx] & (1 << (aBit % width));
+}
+
+template <size_t N>
+static inline void SetBit(uint8_t (&aBits)[N], size_t aBit,
+ bool aValue = true) {
+ static constexpr size_t width = sizeof(aBits[0]) * 8;
+
+ size_t idx = aBit / width;
+ MOZ_ASSERT(idx < N);
+ if (aValue) {
+ aBits[idx] |= 1 << (aBit % width);
+ } else {
+ aBits[idx] &= ~(1 << (aBit % width));
+ }
+}
+
+/**
+ * Represents a string entry in the static string table. Can be converted to a
+ * nsCString using GetString() in StaticComponents.cpp.
+ *
+ * This is a struct rather than a pure offset primarily for the purposes of type
+ * safety, but also so that it can easily be extended to include a static length
+ * in the future, if efficiency concerns warrant it.
+ */
+struct StringOffset final {
+ uint32_t mOffset;
+};
+
+/**
+ * Represents an offset into the interfaces table.
+ */
+struct InterfaceOffset final {
+ uint16_t mOffset;
+};
+
+/**
+ * Represents a static component entry defined in a `Classes` list in an XPCOM
+ * manifest. Handles creating instances of and caching service instances for
+ * that class.
+ */
+struct StaticModule {
+ nsID mCID;
+ StringOffset mContractID;
+ Module::ProcessSelector mProcessSelector;
+
+ const nsID& CID() const { return mCID; }
+
+ ModuleID ID() const { return ModuleID(this - gStaticModules); }
+
+ /**
+ * Returns this entry's index in the gStaticModules array.
+ */
+ size_t Idx() const { return size_t(ID()); }
+
+ /**
+ * Returns true if this component's corresponding contract ID is expected to
+ * be overridden at runtime. If so, it should always be looked up by its
+ * ContractID() when retrieving its service instance.
+ */
+ bool Overridable() const;
+
+ /**
+ * If this entry is overridable, returns its associated contract ID string.
+ * The component should always be looked up by this contract ID when
+ * retrieving its service instance.
+ *
+ * Note: This may *only* be called if Overridable() returns true.
+ */
+ nsCString ContractID() const;
+
+ /**
+ * Returns true if this entry is active. Typically this will only return false
+ * if the entry's process selector does not match this process.
+ */
+ bool Active() const;
+
+ already_AddRefed<nsIFactory> GetFactory() const;
+
+ nsresult CreateInstance(const nsIID& aIID, void** aResult) const;
+
+ GetServiceHelper GetService() const;
+ GetServiceHelper GetService(nsresult*) const;
+
+ nsISupports* ServiceInstance() const;
+ void SetServiceInstance(already_AddRefed<nsISupports> aInst) const;
+};
+
+/**
+ * Represents a static mapping between a contract ID string and a StaticModule
+ * entry.
+ */
+struct ContractEntry final {
+ StringOffset mContractID;
+ ModuleID mModuleID;
+
+ size_t Idx() const { return this - gContractEntries; }
+
+ nsCString ContractID() const;
+
+ const StaticModule& Module() const {
+ return gStaticModules[size_t(mModuleID)];
+ }
+
+ /**
+ * Returns true if this entry's underlying module is active, and its contract
+ * ID matches the given contract ID string. This is used by the PerfectHash
+ * function to determine whether to return a result for this entry.
+ */
+ bool Matches(const nsACString& aContractID) const;
+
+ /**
+ * Returns true if this entry has been invalidated, and should be ignored.
+ *
+ * Contract IDs may be overwritten at runtime. When that happens for a static
+ * contract ID, we mark its entry invalid, and ignore it thereafter.
+ */
+ bool Invalid() const { return GetBit(gInvalidContracts, Idx()); }
+
+ /**
+ * Marks this entry invalid (or unsets the invalid bit if aInvalid is false),
+ * after which it will be ignored in contract ID lookup attempts. See
+ * `Invalid()` above.
+ */
+ void SetInvalid(bool aInvalid = true) const {
+ return SetBit(gInvalidContracts, Idx(), aInvalid);
+ }
+};
+
+/**
+ * Represents a declared category manager entry declared in an XPCOM manifest.
+ *
+ * The entire set of static category entries is read at startup and loaded into
+ * the category manager's dynamic hash tables, so there is memory and
+ * initialization overhead for each entry in these tables. This may be further
+ * optimized in the future to reduce some of that overhead.
+ */
+struct StaticCategoryEntry final {
+ StringOffset mEntry;
+ StringOffset mValue;
+ Module::BackgroundTasksSelector mBackgroundTasksSelector;
+ Module::ProcessSelector mProcessSelector;
+
+ nsCString Entry() const;
+ nsCString Value() const;
+ bool Active() const;
+};
+
+struct StaticCategory final {
+ StringOffset mName;
+ uint16_t mStart;
+ uint16_t mCount;
+
+ nsCString Name() const;
+
+ const StaticCategoryEntry* begin() const {
+ return &gStaticCategoryEntries[mStart];
+ }
+ const StaticCategoryEntry* end() const {
+ return &gStaticCategoryEntries[mStart + mCount];
+ }
+};
+
+struct JSServiceEntry final {
+ using InterfaceList = AutoTArray<const nsIID*, 4>;
+
+ static const JSServiceEntry* Lookup(const nsACString& aName);
+
+ StringOffset mName;
+ ModuleID mModuleID;
+
+ InterfaceOffset mInterfaceOffset;
+
+ uint8_t mInterfaceCount;
+
+ nsCString Name() const;
+
+ const StaticModule& Module() const {
+ return gStaticModules[size_t(mModuleID)];
+ }
+
+ InterfaceList Interfaces() const;
+};
+
+struct StaticProtocolHandler final {
+ static const StaticProtocolHandler* Lookup(const nsACString& aScheme);
+ static const StaticProtocolHandler& Default() {
+ return gStaticProtocolHandlers[kDefaultProtocolHandlerIndex];
+ }
+
+ StringOffset mScheme;
+ uint32_t mProtocolFlags;
+ int32_t mDefaultPort;
+ ModuleID mModuleID;
+ bool mHasDynamicFlags;
+
+ nsCString Scheme() const;
+
+ const StaticModule& Module() const {
+ return gStaticModules[size_t(mModuleID)];
+ }
+};
+
+class StaticComponents final {
+ public:
+ static const StaticModule* LookupByCID(const nsID& aCID);
+
+ static const StaticModule* LookupByContractID(const nsACString& aContractID);
+
+ /**
+ * Marks a static contract ID entry invalid (or unsets the invalid bit if
+ * aInvalid is false). See `CategoryEntry::Invalid()`.
+ */
+ static bool InvalidateContractID(const nsACString& aContractID,
+ bool aInvalid = true);
+
+ static already_AddRefed<nsIUTF8StringEnumerator> GetComponentJSMs();
+ static already_AddRefed<nsIUTF8StringEnumerator> GetComponentESModules();
+
+ static Span<const JSServiceEntry> GetJSServices();
+
+ /**
+ * Calls any module unload from manifests whose components have been loaded.
+ */
+ static void Shutdown();
+};
+
+} // namespace xpcom
+} // namespace mozilla
+
+#endif // defined StaticComponents_h
diff --git a/xpcom/components/components.conf b/xpcom/components/components.conf
new file mode 100644
index 0000000000..73cc177e8d
--- /dev/null
+++ b/xpcom/components/components.conf
@@ -0,0 +1,23 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+Classes = [
+ {
+ 'js_name': 'catMan',
+ 'cid': '{16d222a6-1dd2-11b2-b693-f38b02c021b2}',
+ 'contract_ids': ['@mozilla.org/categorymanager;1'],
+ 'interfaces': ['nsICategoryManager'],
+ 'legacy_constructor': 'nsCategoryManager::Create',
+ 'headers': ['/xpcom/components/nsCategoryManager.h'],
+ 'processes': ProcessSelector.ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS,
+ },
+ {
+ 'cid': '{91775d60-d5dc-11d2-92fb-00e09805570f}',
+ 'legacy_constructor': 'nsComponentManagerImpl::Create',
+ 'headers': ['/xpcom/components/nsComponentManager.h'],
+ 'processes': ProcessSelector.ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS,
+ },
+]
diff --git a/xpcom/components/gen_static_components.py b/xpcom/components/gen_static_components.py
new file mode 100644
index 0000000000..3d73eda603
--- /dev/null
+++ b/xpcom/components/gen_static_components.py
@@ -0,0 +1,1206 @@
+import json
+import os
+import re
+import struct
+from collections import defaultdict
+from uuid import UUID
+
+import buildconfig
+from mozbuild.util import FileAvoidWrite
+from perfecthash import PerfectHash
+
+NO_CONTRACT_ID = 0xFFFFFFFF
+
+PHF_SIZE = 512
+
+TINY_PHF_SIZE = 16
+
+# In tests, we might not have a (complete) buildconfig.
+ENDIAN = (
+ "<" if buildconfig.substs.get("TARGET_ENDIANNESS", "little") == "little" else ">"
+)
+
+
+# Represents a UUID in the format used internally by Gecko, and supports
+# serializing it in that format to both C++ source and raw byte arrays.
+class UUIDRepr(object):
+ def __init__(self, uuid):
+ self.uuid = uuid
+
+ fields = uuid.fields
+
+ self.a = fields[0]
+ self.b = fields[1]
+ self.c = fields[2]
+
+ d = list(fields[3:5])
+ for i in range(0, 6):
+ d.append(fields[5] >> (8 * (5 - i)) & 0xFF)
+
+ self.d = tuple(d)
+
+ def __str__(self):
+ return str(self.uuid)
+
+ @property
+ def bytes(self):
+ return struct.pack(ENDIAN + "IHHBBBBBBBB", self.a, self.b, self.c, *self.d)
+
+ def to_cxx(self):
+ rest = ", ".join("0x%02x" % b for b in self.d)
+
+ return "{ 0x%x, 0x%x, 0x%x, { %s } }" % (self.a, self.b, self.c, rest)
+
+
+# Corresponds to the Module::ProcessSelector enum in Module.h. The actual
+# values don't matter, since the code generator emits symbolic constants for
+# these values, but we use the same values as the enum constants for clarity.
+class ProcessSelector:
+ ANY_PROCESS = 0x0
+ MAIN_PROCESS_ONLY = 0x1
+ CONTENT_PROCESS_ONLY = 0x2
+ ALLOW_IN_GPU_PROCESS = 0x4
+ ALLOW_IN_VR_PROCESS = 0x8
+ ALLOW_IN_SOCKET_PROCESS = 0x10
+ ALLOW_IN_RDD_PROCESS = 0x20
+ ALLOW_IN_UTILITY_PROCESS = 0x30
+ ALLOW_IN_GPU_AND_MAIN_PROCESS = ALLOW_IN_GPU_PROCESS | MAIN_PROCESS_ONLY
+ ALLOW_IN_GPU_AND_SOCKET_PROCESS = ALLOW_IN_GPU_PROCESS | ALLOW_IN_SOCKET_PROCESS
+ ALLOW_IN_GPU_AND_VR_PROCESS = ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS
+ ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS = (
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_VR_PROCESS | ALLOW_IN_SOCKET_PROCESS
+ )
+ ALLOW_IN_RDD_AND_SOCKET_PROCESS = ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS
+ ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS = (
+ ALLOW_IN_GPU_PROCESS | ALLOW_IN_RDD_PROCESS | ALLOW_IN_SOCKET_PROCESS
+ )
+ ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS = (
+ ALLOW_IN_GPU_PROCESS
+ | ALLOW_IN_RDD_PROCESS
+ | ALLOW_IN_SOCKET_PROCESS
+ | ALLOW_IN_UTILITY_PROCESS
+ )
+ ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS = (
+ ALLOW_IN_GPU_PROCESS
+ | ALLOW_IN_RDD_PROCESS
+ | ALLOW_IN_VR_PROCESS
+ | ALLOW_IN_SOCKET_PROCESS
+ )
+ ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS = (
+ ALLOW_IN_GPU_PROCESS
+ | ALLOW_IN_RDD_PROCESS
+ | ALLOW_IN_VR_PROCESS
+ | ALLOW_IN_SOCKET_PROCESS
+ | ALLOW_IN_UTILITY_PROCESS
+ )
+
+
+# Maps ProcessSelector constants to the name of the corresponding
+# Module::ProcessSelector enum value.
+PROCESSES = {
+ ProcessSelector.ANY_PROCESS: "ANY_PROCESS",
+ ProcessSelector.MAIN_PROCESS_ONLY: "MAIN_PROCESS_ONLY",
+ ProcessSelector.CONTENT_PROCESS_ONLY: "CONTENT_PROCESS_ONLY",
+ ProcessSelector.ALLOW_IN_GPU_PROCESS: "ALLOW_IN_GPU_PROCESS",
+ ProcessSelector.ALLOW_IN_VR_PROCESS: "ALLOW_IN_VR_PROCESS",
+ ProcessSelector.ALLOW_IN_SOCKET_PROCESS: "ALLOW_IN_SOCKET_PROCESS",
+ ProcessSelector.ALLOW_IN_RDD_PROCESS: "ALLOW_IN_RDD_PROCESS",
+ ProcessSelector.ALLOW_IN_GPU_AND_MAIN_PROCESS: "ALLOW_IN_GPU_AND_MAIN_PROCESS",
+ ProcessSelector.ALLOW_IN_GPU_AND_SOCKET_PROCESS: "ALLOW_IN_GPU_AND_SOCKET_PROCESS",
+ ProcessSelector.ALLOW_IN_GPU_AND_VR_PROCESS: "ALLOW_IN_GPU_AND_VR_PROCESS",
+ ProcessSelector.ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS: "ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS",
+ ProcessSelector.ALLOW_IN_RDD_AND_SOCKET_PROCESS: "ALLOW_IN_RDD_AND_SOCKET_PROCESS",
+ ProcessSelector.ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS: "ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS",
+ ProcessSelector.ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS: "ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS", # NOQA: E501
+ ProcessSelector.ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS: "ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS", # NOQA: E501
+ ProcessSelector.ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS: "ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS", # NOQA: E501
+}
+
+
+# Emits the C++ symbolic constant corresponding to a ProcessSelector constant.
+def lower_processes(processes):
+ return "Module::ProcessSelector::%s" % PROCESSES[processes]
+
+
+# Emits the C++ symbolic constant for a ModuleEntry's ModuleID enum entry.
+def lower_module_id(module):
+ return "ModuleID::%s" % module.name
+
+
+# Corresponds to the Module::BackgroundTasksSelector enum in Module.h. The
+# actual values don't matter, since the code generator emits symbolic constants
+# for these values, but we use the same values as the enum constants for
+# clarity.
+class BackgroundTasksSelector:
+ NO_TASKS = 0x0
+ ALL_TASKS = 0xFFFF
+
+
+# Maps BackgroundTasksSelector constants to the name of the corresponding
+# Module::BackgroundTasksSelector enum value.
+BACKGROUNDTASKS = {
+ BackgroundTasksSelector.ALL_TASKS: "ALL_TASKS",
+ BackgroundTasksSelector.NO_TASKS: "NO_TASKS",
+}
+
+
+# Emits the C++ symbolic constant corresponding to a BackgroundTasks constant.
+def lower_backgroundtasks(backgroundtasks):
+ return "Module::BackgroundTasksSelector::%s" % BACKGROUNDTASKS[backgroundtasks]
+
+
+# Represents a static string table, indexed by offset. This allows us to
+# reference strings from static data structures without requiring runtime
+# relocations.
+class StringTable(object):
+ def __init__(self):
+ self.entries = {}
+ self.entry_list = []
+ self.size = 0
+
+ self._serialized = False
+
+ # Returns the index of the given string in the `entry_list` array. If
+ # no entry for the string exists, it first creates one.
+ def get_idx(self, string):
+ idx = self.entries.get(string, None)
+ if idx is not None:
+ return idx
+
+ assert not self._serialized
+
+ assert len(string) == len(string.encode("utf-8"))
+
+ idx = self.size
+ self.size += len(string) + 1
+
+ self.entries[string] = idx
+ self.entry_list.append(string)
+ return idx
+
+ # Returns the C++ code representing string data of this string table, as a
+ # single string literal. This must only be called after the last call to
+ # `get_idx()` or `entry_to_cxx()` for this instance.
+ def to_cxx(self):
+ self._serialized = True
+
+ lines = []
+
+ idx = 0
+ for entry in self.entry_list:
+ str_ = entry.replace("\\", "\\\\").replace('"', r"\"").replace("\n", r"\n")
+
+ lines.append(' /* 0x%x */ "%s\\0"\n' % (idx, str_))
+
+ idx += len(entry) + 1
+
+ return "".join(lines)
+
+ # Returns a `StringEntry` struct initializer for the string table entry
+ # corresponding to the given string. If no matching entry exists, it is
+ # first created.
+ def entry_to_cxx(self, string):
+ idx = self.get_idx(string)
+ return "{ 0x%x } /* %s */" % (idx, pretty_string(string))
+
+
+strings = StringTable()
+
+interfaces = []
+
+
+# Represents a C++ namespace, containing a set of classes and potentially
+# sub-namespaces. This is used to generate pre-declarations for incomplete
+# types referenced in XPCOM manifests.
+class Namespace(object):
+ def __init__(self, name=None):
+ self.name = name
+ self.classes = set()
+ self.namespaces = {}
+
+ # Returns a Namespace object for the sub-namespace with the given name.
+ def sub(self, name):
+ assert name not in self.classes
+
+ if name not in self.namespaces:
+ self.namespaces[name] = Namespace(name)
+ return self.namespaces[name]
+
+ # Generates C++ code to pre-declare all classes in this namespace and all
+ # of its sub-namespaces.
+ def to_cxx(self):
+ res = ""
+ if self.name:
+ res += "namespace %s {\n" % self.name
+
+ for clas in sorted(self.classes):
+ res += "class %s;\n" % clas
+
+ for ns in sorted(self.namespaces.keys()):
+ res += self.namespaces[ns].to_cxx()
+
+ if self.name:
+ res += "} // namespace %s\n" % self.name
+
+ return res
+
+
+# Represents a component defined in an XPCOM manifest's `Classes` array.
+class ModuleEntry(object):
+ next_anon_id = 0
+
+ def __init__(self, data, init_idx):
+ self.cid = UUIDRepr(UUID(data["cid"]))
+ self.contract_ids = data.get("contract_ids", [])
+ self.type = data.get("type", "nsISupports")
+ self.categories = data.get("categories", {})
+ self.processes = data.get("processes", 0)
+ self.headers = data.get("headers", [])
+
+ self.js_name = data.get("js_name", None)
+ self.interfaces = data.get("interfaces", [])
+
+ if len(self.interfaces) > 255:
+ raise Exception(
+ "JS service %s may not have more than 255 " "interfaces" % self.js_name
+ )
+
+ self.interfaces_offset = len(interfaces)
+ for iface in self.interfaces:
+ interfaces.append(iface)
+
+ # If the manifest declares Init or Unload functions, this contains its
+ # index, as understood by the `CallInitFunc()` function.
+ #
+ # If it contains any value other than `None`, a corresponding
+ # `CallInitFunc(init_idx)` call will be genrated before calling this
+ # module's constructor.
+ self.init_idx = init_idx
+
+ self.constructor = data.get("constructor", None)
+ self.legacy_constructor = data.get("legacy_constructor", None)
+ self.init_method = data.get("init_method", [])
+
+ self.jsm = data.get("jsm", None)
+ self.esModule = data.get("esModule", None)
+
+ self.external = data.get(
+ "external", not (self.headers or self.legacy_constructor)
+ )
+ self.singleton = data.get("singleton", False)
+ self.overridable = data.get("overridable", False)
+
+ self.protocol_config = data.get("protocol_config", None)
+
+ if "name" in data:
+ self.anonymous = False
+ self.name = data["name"]
+ else:
+ self.anonymous = True
+ self.name = "Anonymous%03d" % ModuleEntry.next_anon_id
+ ModuleEntry.next_anon_id += 1
+
+ def error(str_):
+ raise Exception(
+ "Error defining component %s (%s): %s"
+ % (str(self.cid), ", ".join(map(repr, self.contract_ids)), str_)
+ )
+
+ if self.jsm:
+ if not self.constructor:
+ error("JavaScript components must specify a constructor")
+
+ for prop in ("init_method", "legacy_constructor", "headers"):
+ if getattr(self, prop):
+ error(
+ "JavaScript components may not specify a '%s' "
+ "property" % prop
+ )
+ elif self.esModule:
+ if not self.constructor:
+ error("JavaScript components must specify a constructor")
+
+ for prop in ("init_method", "legacy_constructor", "headers"):
+ if getattr(self, prop):
+ error(
+ "JavaScript components may not specify a '%s' "
+ "property" % prop
+ )
+ elif self.external:
+ if self.constructor or self.legacy_constructor:
+ error(
+ "Externally-constructed components may not specify "
+ "'constructor' or 'legacy_constructor' properties"
+ )
+ if self.init_method:
+ error(
+ "Externally-constructed components may not specify "
+ "'init_method' properties"
+ )
+ if self.type == "nsISupports":
+ error(
+ "Externally-constructed components must specify a type "
+ "other than nsISupports"
+ )
+
+ if self.constructor and self.legacy_constructor:
+ error(
+ "The 'constructor' and 'legacy_constructor' properties "
+ "are mutually exclusive"
+ )
+
+ if self.overridable and not self.contract_ids:
+ error("Overridable components must specify at least one contract " "ID")
+
+ @property
+ def contract_id(self):
+ return self.contract_ids[0]
+
+ # Generates the C++ code for a StaticModule struct initializer
+ # representing this component.
+ def to_cxx(self):
+ contract_id = (
+ strings.entry_to_cxx(self.contract_id)
+ if self.overridable
+ else "{ 0x%x }" % NO_CONTRACT_ID
+ )
+
+ return """
+ /* {name} */ {{
+ /* {{{cid_string}}} */
+ {cid},
+ {contract_id},
+ {processes},
+ }}""".format(
+ name=self.name,
+ cid=self.cid.to_cxx(),
+ cid_string=str(self.cid),
+ contract_id=contract_id,
+ processes=lower_processes(self.processes),
+ )
+
+ # Generates the C++ code for a JSServiceEntry representing this module.
+ def lower_js_service(self):
+ return """
+ {{
+ {js_name},
+ ModuleID::{name},
+ {{ {iface_offset} }},
+ {iface_count}
+ }}""".format(
+ js_name=strings.entry_to_cxx(self.js_name),
+ name=self.name,
+ iface_offset=self.interfaces_offset,
+ iface_count=len(self.interfaces),
+ )
+
+ # Generates the C++ code necessary to construct an instance of this
+ # component.
+ #
+ # This code lives in a function with the following arguments:
+ #
+ # - aIID: The `const nsIID&` interface ID that the resulting instance
+ # will be queried to.
+ #
+ # - aResult: The `void**` pointer in which to store the result.
+ #
+ # And which returns an `nsresult` indicating success or failure.
+ def lower_constructor(self):
+ res = ""
+
+ if self.init_idx is not None:
+ res += " MOZ_TRY(CallInitFunc(%d));\n" % self.init_idx
+
+ if self.legacy_constructor:
+ res += (
+ " return /* legacy */ %s(aIID, aResult);\n"
+ % self.legacy_constructor
+ )
+ return res
+
+ if self.jsm:
+ res += (
+ " nsCOMPtr<nsISupports> inst;\n"
+ " MOZ_TRY(ConstructJSMComponent(nsLiteralCString(%s),\n"
+ " %s,\n"
+ " getter_AddRefs(inst)));"
+ "\n" % (json.dumps(self.jsm), json.dumps(self.constructor))
+ )
+ elif self.esModule:
+ res += (
+ " nsCOMPtr<nsISupports> inst;\n"
+ " MOZ_TRY(ConstructESModuleComponent(nsLiteralCString(%s),\n"
+ " %s,\n"
+ " getter_AddRefs(inst)));"
+ "\n" % (json.dumps(self.esModule), json.dumps(self.constructor))
+ )
+ elif self.external:
+ res += (
+ " nsCOMPtr<nsISupports> inst = "
+ "mozCreateComponent<%s>();\n" % self.type
+ )
+ # The custom constructor may return null, so check before calling
+ # any methods.
+ res += " NS_ENSURE_TRUE(inst, NS_ERROR_FAILURE);\n"
+ else:
+ res += " RefPtr<%s> inst = " % self.type
+
+ if not self.constructor:
+ res += "new %s();\n" % self.type
+ else:
+ res += "%s();\n" % self.constructor
+ # The `new` operator is infallible, so we don't need to worry
+ # about it returning null, but custom constructors may, so
+ # check before calling any methods.
+ res += " NS_ENSURE_TRUE(inst, NS_ERROR_OUT_OF_MEMORY);\n"
+
+ # Check that the constructor function returns an appropriate
+ # `already_AddRefed` value for our declared type.
+ res += """
+ using T =
+ RemoveAlreadyAddRefed<decltype(%(constructor)s())>::Type;
+ static_assert(
+ std::is_same_v<already_AddRefed<T>, decltype(%(constructor)s())>,
+ "Singleton constructor must return already_AddRefed");
+ static_assert(
+ std::is_base_of<%(type)s, T>::value,
+ "Singleton constructor must return correct already_AddRefed");
+
+""" % {
+ "type": self.type,
+ "constructor": self.constructor,
+ }
+
+ if self.init_method:
+ res += " MOZ_TRY(inst->%s());\n" % self.init_method
+
+ res += " return inst->QueryInterface(aIID, aResult);\n"
+
+ return res
+
+ # Generates the C++ code for the `mozilla::components::<name>` entry
+ # corresponding to this component. This may not be called for modules
+ # without an explicit `name` (in which cases, `self.anonymous` will be
+ # true).
+ def lower_getters(self):
+ assert not self.anonymous
+
+ substs = {
+ "name": self.name,
+ "id": "::mozilla::xpcom::ModuleID::%s" % self.name,
+ }
+
+ res = (
+ """
+namespace %(name)s {
+static inline const nsID& CID() {
+ return ::mozilla::xpcom::Components::GetCID(%(id)s);
+}
+
+static inline ::mozilla::xpcom::GetServiceHelper Service(nsresult* aRv = nullptr) {
+ return {%(id)s, aRv};
+}
+"""
+ % substs
+ )
+
+ if not self.singleton:
+ res += (
+ """
+static inline ::mozilla::xpcom::CreateInstanceHelper Create(nsresult* aRv = nullptr) {
+ return {%(id)s, aRv};
+}
+"""
+ % substs
+ )
+
+ res += (
+ """\
+} // namespace %(name)s
+"""
+ % substs
+ )
+
+ return res
+
+ # Generates the rust code for the `xpcom::components::<name>` entry
+ # corresponding to this component. This may not be called for modules
+ # without an explicit `name` (in which cases, `self.anonymous` will be
+ # true).
+ def lower_getters_rust(self):
+ assert not self.anonymous
+
+ substs = {
+ "name": self.name,
+ "id": "super::ModuleID::%s" % self.name,
+ }
+
+ res = (
+ """
+#[allow(non_snake_case)]
+pub mod %(name)s {
+ /// Get the singleton service instance for this component.
+ pub fn service<T: crate::XpCom>() -> Result<crate::RefPtr<T>, nserror::nsresult> {
+ let mut ga = crate::GetterAddrefs::<T>::new();
+ let rv = unsafe { super::Gecko_GetServiceByModuleID(%(id)s, &T::IID, ga.void_ptr()) };
+ if rv.failed() {
+ return Err(rv);
+ }
+ ga.refptr().ok_or(nserror::NS_ERROR_NO_INTERFACE)
+ }
+"""
+ % substs
+ )
+
+ if not self.singleton:
+ res += (
+ """
+ /// Create a new instance of this component.
+ pub fn create<T: crate::XpCom>() -> Result<crate::RefPtr<T>, nserror::nsresult> {
+ let mut ga = crate::GetterAddrefs::<T>::new();
+ let rv = unsafe { super::Gecko_CreateInstanceByModuleID(%(id)s, &T::IID, ga.void_ptr()) };
+ if rv.failed() {
+ return Err(rv);
+ }
+ ga.refptr().ok_or(nserror::NS_ERROR_NO_INTERFACE)
+ }
+"""
+ % substs
+ )
+
+ res += """\
+}
+"""
+
+ return res
+
+
+# Returns a quoted string literal representing the given raw string, with
+# certain special characters replaced so that it can be used in a C++-style
+# (/* ... */) comment.
+def pretty_string(string):
+ return json.dumps(string).replace("*/", r"*\/").replace("/*", r"/\*")
+
+
+# Represents a static contract ID entry, corresponding to a C++ ContractEntry
+# struct, mapping a contract ID to a static module entry.
+class ContractEntry(object):
+ def __init__(self, contract, module):
+ self.contract = contract
+ self.module = module
+
+ def to_cxx(self):
+ return """
+ {{
+ {contract},
+ {module_id},
+ }}""".format(
+ contract=strings.entry_to_cxx(self.contract),
+ module_id=lower_module_id(self.module),
+ )
+
+
+# Represents a static ProtocolHandler entry, corresponding to a C++
+# ProtocolEntry struct, mapping a scheme to a static module entry and metadata.
+class ProtocolHandler(object):
+ def __init__(self, config, module):
+ def error(str_):
+ raise Exception(
+ "Error defining protocol handler %s (%s): %s"
+ % (str(module.cid), ", ".join(map(repr, module.contract_ids)), str_)
+ )
+
+ self.module = module
+ self.scheme = config.get("scheme", None)
+ if self.scheme is None:
+ error("No scheme defined for protocol component")
+ self.flags = config.get("flags", None)
+ if self.flags is None:
+ error("No flags defined for protocol component")
+ self.default_port = config.get("default_port", -1)
+ self.has_dynamic_flags = config.get("has_dynamic_flags", False)
+
+ def to_cxx(self):
+ return """
+ {{
+ .mScheme = {scheme},
+ .mProtocolFlags = {flags},
+ .mDefaultPort = {default_port},
+ .mModuleID = {module_id},
+ .mHasDynamicFlags = {has_dynamic_flags},
+ }}
+ """.format(
+ scheme=strings.entry_to_cxx(self.scheme),
+ module_id=lower_module_id(self.module),
+ flags=" | ".join("nsIProtocolHandler::%s" % flag for flag in self.flags),
+ default_port=self.default_port,
+ has_dynamic_flags="true" if self.has_dynamic_flags else "false",
+ )
+
+
+# Generates the C++ code for the StaticCategoryEntry and StaticCategory
+# structs for all category entries declared in XPCOM manifests.
+def gen_categories(substs, categories):
+ cats = []
+ ents = []
+
+ count = 0
+ for category, entries in sorted(categories.items()):
+
+ def k(entry):
+ return tuple(entry[0]["name"]) + entry[1:]
+
+ entries.sort(key=k)
+
+ cats.append(
+ " { %s,\n"
+ " %d, %d },\n" % (strings.entry_to_cxx(category), count, len(entries))
+ )
+ count += len(entries)
+
+ ents.append(" /* %s */\n" % pretty_string(category))
+ for entry, value, processes in entries:
+ name = entry["name"]
+ backgroundtasks = entry.get(
+ "backgroundtasks", BackgroundTasksSelector.NO_TASKS
+ )
+
+ ents.append(
+ " { %s,\n"
+ " %s,\n"
+ " %s,\n"
+ " %s },\n"
+ % (
+ strings.entry_to_cxx(name),
+ strings.entry_to_cxx(value),
+ lower_backgroundtasks(backgroundtasks),
+ lower_processes(processes),
+ )
+ )
+ ents.append("\n")
+ ents.pop()
+
+ substs["category_count"] = len(cats)
+ substs["categories"] = "".join(cats)
+ substs["category_entries"] = "".join(ents)
+
+
+# Generates the C++ code for all Init and Unload functions declared in XPCOM
+# manifests. These form the bodies of the `CallInitFunc()` and `CallUnload`
+# functions in StaticComponents.cpp.
+def gen_module_funcs(substs, funcs):
+ inits = []
+ unloads = []
+
+ template = """\
+ case %d:
+ %s
+ break;
+"""
+
+ for i, (init, unload) in enumerate(funcs):
+ init_code = "%s();" % init if init else "/* empty */"
+ inits.append(template % (i, init_code))
+
+ if unload:
+ unloads.append(
+ """\
+ if (CalledInit(%d)) {
+ %s();
+ }
+"""
+ % (i, unload)
+ )
+
+ substs["init_funcs"] = "".join(inits)
+ substs["unload_funcs"] = "".join(unloads)
+ substs["init_count"] = len(funcs)
+
+
+def gen_interfaces(ifaces):
+ res = []
+ for iface in ifaces:
+ res.append(" nsXPTInterface::%s,\n" % iface)
+ return "".join(res)
+
+
+# Generates class pre-declarations for any types referenced in `Classes` array
+# entries which do not have corresponding `headers` entries to fully declare
+# their types.
+def gen_decls(types):
+ root_ns = Namespace()
+
+ for type_ in sorted(types):
+ parts = type_.split("::")
+
+ ns = root_ns
+ for part in parts[:-1]:
+ ns = ns.sub(part)
+ ns.classes.add(parts[-1])
+
+ return root_ns.to_cxx()
+
+
+# Generates the `switch` body for the `CreateInstanceImpl()` function, with a
+# `case` for each value in ModuleID to construct an instance of the
+# corresponding component.
+def gen_constructors(entries):
+ constructors = []
+ for entry in entries:
+ constructors.append(
+ """\
+ case {id}: {{
+{constructor}\
+ }}
+""".format(
+ id=lower_module_id(entry), constructor=entry.lower_constructor()
+ )
+ )
+
+ return "".join(constructors)
+
+
+# Generates the getter code for each named component entry in the
+# `mozilla::components::` namespace.
+def gen_getters(entries):
+ entries = list(entries)
+ entries.sort(key=lambda e: e.name)
+
+ return "".join(entry.lower_getters() for entry in entries if not entry.anonymous)
+
+
+# Generates the rust getter code for each named component entry in the
+# `xpcom::components::` module.
+def gen_getters_rust(entries):
+ entries = list(entries)
+ entries.sort(key=lambda e: e.name)
+
+ return "".join(
+ entry.lower_getters_rust() for entry in entries if not entry.anonymous
+ )
+
+
+def gen_includes(substs, all_headers):
+ headers = set()
+ absolute_headers = set()
+
+ for header in all_headers:
+ if header.startswith("/"):
+ absolute_headers.add(header)
+ else:
+ headers.add(header)
+
+ includes = ['#include "%s"' % header for header in sorted(headers)]
+ substs["includes"] = "\n".join(includes) + "\n"
+
+ relative_includes = [
+ '#include "../..%s"' % header for header in sorted(absolute_headers)
+ ]
+ substs["relative_includes"] = "\n".join(relative_includes) + "\n"
+
+
+def to_category_list(val):
+ # Entries can be bare strings (like `"m-browser"`), lists of bare strings,
+ # or dictionaries (like `{"name": "m-browser", "backgroundtasks":
+ # BackgroundTasksSelector.ALL_TASKS}`), somewhat recursively.
+
+ def ensure_dict(v):
+ # Turn `v` into `{"name": v}` if it's not already a dict.
+ if isinstance(v, dict):
+ return v
+ return {"name": v}
+
+ if isinstance(val, (list, tuple)):
+ return tuple(ensure_dict(v) for v in val)
+
+ if isinstance(val, dict):
+ # Explode `{"name": ["x", "y"], "backgroundtasks": ...}` into
+ # `[{"name": "x", "backgroundtasks": ...}, {"name": "y", "backgroundtasks": ...}]`.
+ names = val.pop("name")
+
+ vals = []
+ for entry in to_category_list(names):
+ d = dict(val)
+ d["name"] = entry["name"]
+ vals.append(d)
+
+ return tuple(vals)
+
+ return (ensure_dict(val),)
+
+
+def gen_substs(manifests):
+ module_funcs = []
+
+ headers = set()
+
+ modules = []
+ categories = defaultdict(list)
+
+ for manifest in manifests:
+ headers |= set(manifest.get("Headers", []))
+
+ init_idx = None
+ init = manifest.get("InitFunc")
+ unload = manifest.get("UnloadFunc")
+ if init or unload:
+ init_idx = len(module_funcs)
+ module_funcs.append((init, unload))
+
+ for clas in manifest["Classes"]:
+ modules.append(ModuleEntry(clas, init_idx))
+
+ for category, entries in manifest.get("Categories", {}).items():
+ for key, entry in entries.items():
+ if isinstance(entry, tuple):
+ value, process = entry
+ else:
+ value, process = entry, 0
+ categories[category].append(({"name": key}, value, process))
+
+ cids = set()
+ contracts = []
+ contract_map = {}
+ js_services = {}
+ protocol_handlers = {}
+
+ jsms = set()
+ esModules = set()
+
+ types = set()
+
+ for mod in modules:
+ headers |= set(mod.headers)
+
+ for contract_id in mod.contract_ids:
+ if contract_id in contract_map:
+ raise Exception("Duplicate contract ID: %s" % contract_id)
+
+ entry = ContractEntry(contract_id, mod)
+ contracts.append(entry)
+ contract_map[contract_id] = entry
+
+ for category, entries in mod.categories.items():
+ for entry in to_category_list(entries):
+ categories[category].append((entry, mod.contract_id, mod.processes))
+
+ if mod.type and not mod.headers:
+ types.add(mod.type)
+
+ if mod.jsm:
+ jsms.add(mod.jsm)
+
+ if mod.esModule:
+ esModules.add(mod.esModule)
+
+ if mod.js_name:
+ if mod.js_name in js_services:
+ raise Exception("Duplicate JS service name: %s" % mod.js_name)
+ js_services[mod.js_name] = mod
+
+ if mod.protocol_config:
+ handler = ProtocolHandler(mod.protocol_config, mod)
+ if handler.scheme in protocol_handlers:
+ raise Exception("Duplicate protocol handler: %s" % handler.scheme)
+ protocol_handlers[handler.scheme] = handler
+
+ if str(mod.cid) in cids:
+ raise Exception("Duplicate cid: %s" % str(mod.cid))
+ cids.add(str(mod.cid))
+
+ cid_phf = PerfectHash(modules, PHF_SIZE, key=lambda module: module.cid.bytes)
+
+ contract_phf = PerfectHash(contracts, PHF_SIZE, key=lambda entry: entry.contract)
+
+ js_services_phf = PerfectHash(
+ list(js_services.values()), PHF_SIZE, key=lambda entry: entry.js_name
+ )
+
+ protocol_handlers_phf = PerfectHash(
+ list(protocol_handlers.values()), TINY_PHF_SIZE, key=lambda entry: entry.scheme
+ )
+
+ js_services_json = {}
+ for entry in js_services.values():
+ for iface in entry.interfaces:
+ js_services_json[iface] = entry.js_name
+
+ substs = {}
+
+ gen_categories(substs, categories)
+
+ substs["module_ids"] = "".join(" %s,\n" % entry.name for entry in cid_phf.entries)
+
+ substs["module_count"] = len(modules)
+ substs["contract_count"] = len(contracts)
+ substs["protocol_handler_count"] = len(protocol_handlers)
+
+ substs["default_protocol_handler_idx"] = protocol_handlers_phf.get_index("default")
+
+ gen_module_funcs(substs, module_funcs)
+
+ gen_includes(substs, headers)
+
+ substs["component_jsms"] = (
+ "\n".join(" %s," % strings.entry_to_cxx(jsm) for jsm in sorted(jsms)) + "\n"
+ )
+ substs["component_esmodules"] = (
+ "\n".join(
+ " %s," % strings.entry_to_cxx(esModule) for esModule in sorted(esModules)
+ )
+ + "\n"
+ )
+
+ substs["interfaces"] = gen_interfaces(interfaces)
+
+ substs["decls"] = gen_decls(types)
+
+ substs["constructors"] = gen_constructors(cid_phf.entries)
+
+ substs["component_getters"] = gen_getters(cid_phf.entries)
+
+ substs["component_getters_rust"] = gen_getters_rust(cid_phf.entries)
+
+ substs["module_cid_table"] = cid_phf.cxx_codegen(
+ name="ModuleByCID",
+ entry_type="StaticModule",
+ entries_name="gStaticModules",
+ lower_entry=lambda entry: entry.to_cxx(),
+ return_type="const StaticModule*",
+ return_entry=(
+ "return entry.CID().Equals(aKey) && entry.Active()" " ? &entry : nullptr;"
+ ),
+ key_type="const nsID&",
+ key_bytes="reinterpret_cast<const char*>(&aKey)",
+ key_length="sizeof(nsID)",
+ )
+
+ substs["module_contract_id_table"] = contract_phf.cxx_codegen(
+ name="LookupContractID",
+ entry_type="ContractEntry",
+ entries_name="gContractEntries",
+ lower_entry=lambda entry: entry.to_cxx(),
+ return_type="const ContractEntry*",
+ return_entry="return entry.Matches(aKey) ? &entry : nullptr;",
+ key_type="const nsACString&",
+ key_bytes="aKey.BeginReading()",
+ key_length="aKey.Length()",
+ )
+
+ substs["js_services_table"] = js_services_phf.cxx_codegen(
+ name="LookupJSService",
+ entry_type="JSServiceEntry",
+ entries_name="gJSServices",
+ lower_entry=lambda entry: entry.lower_js_service(),
+ return_type="const JSServiceEntry*",
+ return_entry="return entry.Name() == aKey ? &entry : nullptr;",
+ key_type="const nsACString&",
+ key_bytes="aKey.BeginReading()",
+ key_length="aKey.Length()",
+ )
+
+ substs["protocol_handlers_table"] = protocol_handlers_phf.cxx_codegen(
+ name="LookupProtocolHandler",
+ entry_type="StaticProtocolHandler",
+ entries_name="gStaticProtocolHandlers",
+ lower_entry=lambda entry: entry.to_cxx(),
+ return_type="const StaticProtocolHandler*",
+ return_entry="return entry.Scheme() == aKey ? &entry : nullptr;",
+ key_type="const nsACString&",
+ key_bytes="aKey.BeginReading()",
+ key_length="aKey.Length()",
+ )
+
+ substs["js_services_json"] = json.dumps(js_services_json, sort_keys=True, indent=4)
+
+ # Do this only after everything else has been emitted so we're sure the
+ # string table is complete.
+ substs["strings"] = strings.to_cxx()
+ return substs
+
+
+# Returns true if the given build config substitution is defined and truthy.
+def defined(subst):
+ return bool(buildconfig.substs.get(subst))
+
+
+def read_manifest(filename):
+ glbl = {
+ "buildconfig": buildconfig,
+ "defined": defined,
+ "ProcessSelector": ProcessSelector,
+ "BackgroundTasksSelector": BackgroundTasksSelector,
+ }
+ code = compile(open(filename).read(), filename, "exec")
+ exec(code, glbl)
+ return glbl
+
+
+def main(fd, conf_file, template_file):
+ def open_output(filename):
+ return FileAvoidWrite(os.path.join(os.path.dirname(fd.name), filename))
+
+ conf = json.load(open(conf_file, "r"))
+
+ deps = set()
+
+ manifests = []
+ for filename in conf["manifests"]:
+ deps.add(filename)
+ manifest = read_manifest(filename)
+ manifests.append(manifest)
+ manifest.setdefault("Priority", 50)
+ manifest["__filename__"] = filename
+
+ manifests.sort(key=lambda man: (man["Priority"], man["__filename__"]))
+
+ substs = gen_substs(manifests)
+
+ def replacer(match):
+ return substs[match.group(1)]
+
+ with open_output("StaticComponents.cpp") as fh:
+ with open(template_file, "r") as tfh:
+ template = tfh.read()
+
+ fh.write(re.sub(r"//# @([a-zA-Z_]+)@\n", replacer, template))
+
+ with open_output("StaticComponentData.h") as fh:
+ fh.write(
+ """\
+/* -*- 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/. */
+
+#ifndef StaticComponentData_h
+#define StaticComponentData_h
+
+#include <stddef.h>
+
+namespace mozilla {
+namespace xpcom {
+
+static constexpr size_t kStaticModuleCount = %(module_count)d;
+
+static constexpr size_t kContractCount = %(contract_count)d;
+
+static constexpr size_t kStaticCategoryCount = %(category_count)d;
+
+static constexpr size_t kModuleInitCount = %(init_count)d;
+
+static constexpr size_t kStaticProtocolHandlerCount = %(protocol_handler_count)d;
+
+static constexpr size_t kDefaultProtocolHandlerIndex = %(default_protocol_handler_idx)d;
+
+} // namespace xpcom
+} // namespace mozilla
+
+#endif
+"""
+ % substs
+ )
+
+ with open_output("components.rs") as fh:
+ fh.write(
+ """\
+/// Unique IDs for each statically-registered module.
+#[repr(u16)]
+pub enum ModuleID {
+%(module_ids)s
+}
+
+%(component_getters_rust)s
+"""
+ % substs
+ )
+
+ fd.write(
+ """\
+/* -*- 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/. */
+
+#ifndef mozilla_Components_h
+#define mozilla_Components_h
+
+#include "nsCOMPtr.h"
+
+struct nsID;
+
+#define NS_IMPL_COMPONENT_FACTORY(iface) \\
+ template <> \\
+ already_AddRefed<nsISupports> mozCreateComponent<iface>()
+
+template <typename T>
+already_AddRefed<nsISupports> mozCreateComponent();
+
+namespace mozilla {
+namespace xpcom {
+
+enum class ModuleID : uint16_t {
+%(module_ids)s
+};
+
+// May be added as a friend function to allow constructing services via
+// private constructors and init methods.
+nsresult CreateInstanceImpl(ModuleID aID, const nsIID& aIID, void** aResult);
+
+class MOZ_STACK_CLASS StaticModuleHelper : public nsCOMPtr_helper {
+ public:
+ StaticModuleHelper(ModuleID aId, nsresult* aErrorPtr)
+ : mId(aId), mErrorPtr(aErrorPtr) {}
+
+ protected:
+ nsresult SetResult(nsresult aRv) const {
+ if (mErrorPtr) {
+ *mErrorPtr = aRv;
+ }
+ return aRv;
+ }
+
+ ModuleID mId;
+ nsresult* mErrorPtr;
+};
+
+class MOZ_STACK_CLASS GetServiceHelper final : public StaticModuleHelper {
+ public:
+ using StaticModuleHelper::StaticModuleHelper;
+
+ nsresult NS_FASTCALL operator()(const nsIID& aIID,
+ void** aResult) const override;
+};
+
+class MOZ_STACK_CLASS CreateInstanceHelper final : public StaticModuleHelper {
+ public:
+ using StaticModuleHelper::StaticModuleHelper;
+
+ nsresult NS_FASTCALL operator()(const nsIID& aIID,
+ void** aResult) const override;
+};
+
+class Components final {
+ public:
+ static const nsID& GetCID(ModuleID aID);
+};
+
+} // namespace xpcom
+
+namespace components {
+%(component_getters)s
+} // namespace components
+
+} // namespace mozilla
+
+#endif
+"""
+ % substs
+ )
+
+ with open_output("services.json") as fh:
+ fh.write(substs["js_services_json"])
+
+ return deps
diff --git a/xpcom/components/moz.build b/xpcom/components/moz.build
new file mode 100644
index 0000000000..95ee64e985
--- /dev/null
+++ b/xpcom/components/moz.build
@@ -0,0 +1,85 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+XPIDL_SOURCES += [
+ "nsICategoryManager.idl",
+ "nsIClassInfo.idl",
+ "nsIComponentManager.idl",
+ "nsIComponentRegistrar.idl",
+ "nsIFactory.idl",
+ "nsIServiceManager.idl",
+]
+
+XPIDL_MODULE = "xpcom_components"
+
+EXPORTS += [
+ "nsCategoryCache.h",
+ "nsCategoryManagerUtils.h",
+ "nsComponentManagerUtils.h",
+ "nsServiceManagerUtils.h",
+]
+
+EXPORTS.mozilla += [
+ "GenericFactory.h",
+ "Module.h",
+ "ModuleUtils.h",
+]
+
+XPCOM_MANIFESTS += [
+ "components.conf",
+]
+
+if CONFIG["COMPILE_ENVIRONMENT"]:
+ EXPORTS.mozilla += [
+ "!Components.h",
+ ]
+
+ GeneratedFile(
+ "Components.h",
+ "StaticComponentData.h",
+ "StaticComponents.cpp",
+ "services.json",
+ "components.rs",
+ script="gen_static_components.py",
+ inputs=["!manifest-lists.json", "StaticComponents.cpp.in"],
+ )
+
+UNIFIED_SOURCES += [
+ "GenericFactory.cpp",
+ "ManifestParser.cpp",
+ "nsCategoryCache.cpp",
+ "nsCategoryManager.cpp",
+ "nsComponentManager.cpp",
+ "nsComponentManagerUtils.cpp",
+]
+
+SOURCES += [
+ "!StaticComponents.cpp",
+]
+
+FINAL_LIBRARY = "xul"
+
+LOCAL_INCLUDES += [
+ "!..",
+ "../base",
+ "../build",
+ "../ds",
+ "/chrome",
+ "/js/xpconnect/loader",
+ "/layout/build",
+ "/modules/libjar",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "gtk":
+ CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+ if CONFIG["MOZ_ENABLE_DBUS"]:
+ CXXFLAGS += CONFIG["MOZ_DBUS_GLIB_CFLAGS"]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+PYTHON_UNITTEST_MANIFESTS += [
+ "test/python.ini",
+]
diff --git a/xpcom/components/nsCategoryCache.cpp b/xpcom/components/nsCategoryCache.cpp
new file mode 100644
index 0000000000..35f555fa51
--- /dev/null
+++ b/xpcom/components/nsCategoryCache.cpp
@@ -0,0 +1,162 @@
+/* -*- 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 "nsIObserverService.h"
+#include "mozilla/Services.h"
+#include "mozilla/SimpleEnumerator.h"
+
+#include "nsICategoryManager.h"
+#include "nsISupportsPrimitives.h"
+
+#include "nsXPCOMCID.h"
+
+#include "nsCategoryCache.h"
+
+using mozilla::SimpleEnumerator;
+
+nsCategoryObserver::nsCategoryObserver(const nsACString& aCategory)
+ : mCategory(aCategory),
+ mCallback(nullptr),
+ mClosure(nullptr),
+ mObserversRemoved(false) {
+ MOZ_ASSERT(NS_IsMainThread());
+ // First, enumerate the currently existing entries
+ nsCOMPtr<nsICategoryManager> catMan =
+ do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
+ if (!catMan) {
+ return;
+ }
+
+ nsCOMPtr<nsISimpleEnumerator> enumerator;
+ nsresult rv =
+ catMan->EnumerateCategory(aCategory, getter_AddRefs(enumerator));
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ for (auto& categoryEntry : SimpleEnumerator<nsICategoryEntry>(enumerator)) {
+ nsAutoCString entryValue;
+ categoryEntry->GetValue(entryValue);
+
+ if (nsCOMPtr<nsISupports> service = do_GetService(entryValue.get())) {
+ nsAutoCString entryName;
+ categoryEntry->GetEntry(entryName);
+
+ mHash.InsertOrUpdate(entryName, service);
+ }
+ }
+
+ // Now, listen for changes
+ nsCOMPtr<nsIObserverService> serv = mozilla::services::GetObserverService();
+ if (serv) {
+ serv->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+ serv->AddObserver(this, NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID, false);
+ serv->AddObserver(this, NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID, false);
+ serv->AddObserver(this, NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID, false);
+ }
+}
+
+nsCategoryObserver::~nsCategoryObserver() = default;
+
+NS_IMPL_ISUPPORTS(nsCategoryObserver, nsIObserver)
+
+void nsCategoryObserver::ListenerDied() {
+ MOZ_ASSERT(NS_IsMainThread());
+ RemoveObservers();
+ mCallback = nullptr;
+ mClosure = nullptr;
+}
+
+void nsCategoryObserver::SetListener(void(aCallback)(void*), void* aClosure) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mCallback = aCallback;
+ mClosure = aClosure;
+}
+
+void nsCategoryObserver::RemoveObservers() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mObserversRemoved) {
+ return;
+ }
+
+ if (mCallback) {
+ mCallback(mClosure);
+ }
+
+ mObserversRemoved = true;
+ nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
+ if (obsSvc) {
+ obsSvc->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+ obsSvc->RemoveObserver(this, NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID);
+ obsSvc->RemoveObserver(this, NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID);
+ obsSvc->RemoveObserver(this, NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID);
+ }
+}
+
+NS_IMETHODIMP
+nsCategoryObserver::Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aData) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
+ mHash.Clear();
+ RemoveObservers();
+
+ return NS_OK;
+ }
+
+ if (!aData ||
+ !nsDependentString(aData).Equals(NS_ConvertASCIItoUTF16(mCategory))) {
+ return NS_OK;
+ }
+
+ nsAutoCString str;
+ nsCOMPtr<nsISupportsCString> strWrapper(do_QueryInterface(aSubject));
+ if (strWrapper) {
+ strWrapper->GetData(str);
+ }
+
+ if (strcmp(aTopic, NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID) == 0) {
+ // We may get an add notification even when we already have an entry. This
+ // is due to the notification happening asynchronously, so if the entry gets
+ // added and an nsCategoryObserver gets instantiated before events get
+ // processed, we'd get the notification for an existing entry.
+ // Do nothing in that case.
+ if (mHash.GetWeak(str)) {
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsICategoryManager> catMan =
+ do_GetService(NS_CATEGORYMANAGER_CONTRACTID);
+ if (!catMan) {
+ return NS_OK;
+ }
+
+ nsCString entryValue;
+ catMan->GetCategoryEntry(mCategory, str, entryValue);
+
+ nsCOMPtr<nsISupports> service = do_GetService(entryValue.get());
+
+ if (service) {
+ mHash.InsertOrUpdate(str, service);
+ }
+ if (mCallback) {
+ mCallback(mClosure);
+ }
+ } else if (strcmp(aTopic, NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID) == 0) {
+ mHash.Remove(str);
+ if (mCallback) {
+ mCallback(mClosure);
+ }
+ } else if (strcmp(aTopic, NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID) == 0) {
+ mHash.Clear();
+ if (mCallback) {
+ mCallback(mClosure);
+ }
+ }
+ return NS_OK;
+}
diff --git a/xpcom/components/nsCategoryCache.h b/xpcom/components/nsCategoryCache.h
new file mode 100644
index 0000000000..f2d7ba32a3
--- /dev/null
+++ b/xpcom/components/nsCategoryCache.h
@@ -0,0 +1,123 @@
+/* -*- 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/. */
+
+#ifndef nsCategoryCache_h_
+#define nsCategoryCache_h_
+
+#include "mozilla/Attributes.h"
+
+#include "nsIObserver.h"
+
+#include "nsServiceManagerUtils.h"
+
+#include "nsCOMArray.h"
+#include "nsInterfaceHashtable.h"
+
+#include "nsXPCOM.h"
+#include "MainThreadUtils.h"
+
+class nsCategoryObserver final : public nsIObserver {
+ ~nsCategoryObserver();
+
+ public:
+ explicit nsCategoryObserver(const nsACString& aCategory);
+
+ void ListenerDied();
+ void SetListener(void(aCallback)(void*), void* aClosure);
+ nsInterfaceHashtable<nsCStringHashKey, nsISupports>& GetHash() {
+ return mHash;
+ }
+
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSIOBSERVER
+ private:
+ void RemoveObservers();
+
+ nsInterfaceHashtable<nsCStringHashKey, nsISupports> mHash;
+ nsCString mCategory;
+ void (*mCallback)(void*);
+ void* mClosure;
+ bool mObserversRemoved;
+};
+
+/**
+ * This is a helper class that caches services that are registered in a certain
+ * category. The intended usage is that a service stores a variable of type
+ * nsCategoryCache<nsIFoo> in a member variable, where nsIFoo is the interface
+ * that these services should implement. The constructor of this class should
+ * then get the name of the category.
+ */
+template <class T>
+class nsCategoryCache final {
+ public:
+ explicit nsCategoryCache(const char* aCategory) : mCategoryName(aCategory) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+ ~nsCategoryCache() {
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mObserver) {
+ mObserver->ListenerDied();
+ }
+ }
+
+ void GetEntries(nsCOMArray<T>& aResult) {
+ MOZ_ASSERT(NS_IsMainThread());
+ LazyInit();
+
+ AddEntries(aResult);
+ }
+
+ /**
+ * This function returns an nsCOMArray of interface pointers to the cached
+ * category enries for the requested category. This was added in order to be
+ * used in call sites where the overhead of excessive allocations can be
+ * unacceptable. See bug 1360971 for an example.
+ */
+ const nsCOMArray<T>& GetCachedEntries() {
+ MOZ_ASSERT(NS_IsMainThread());
+ LazyInit();
+
+ if (mCachedEntries.IsEmpty()) {
+ AddEntries(mCachedEntries);
+ }
+ return mCachedEntries;
+ }
+
+ private:
+ void LazyInit() {
+ // Lazy initialization, so that services in this category can't
+ // cause reentrant getService (bug 386376)
+ if (!mObserver) {
+ mObserver = new nsCategoryObserver(mCategoryName);
+ mObserver->SetListener(nsCategoryCache<T>::OnCategoryChanged, this);
+ }
+ }
+
+ void AddEntries(nsCOMArray<T>& aResult) {
+ for (nsISupports* entry : mObserver->GetHash().Values()) {
+ nsCOMPtr<T> service = do_QueryInterface(entry);
+ if (service) {
+ aResult.AppendElement(service.forget());
+ }
+ }
+ }
+
+ static void OnCategoryChanged(void* aClosure) {
+ MOZ_ASSERT(NS_IsMainThread());
+ auto self = static_cast<nsCategoryCache<T>*>(aClosure);
+ self->mCachedEntries.Clear();
+ }
+
+ private:
+ // Not to be implemented
+ nsCategoryCache(const nsCategoryCache<T>&);
+
+ nsCString mCategoryName;
+ RefPtr<nsCategoryObserver> mObserver;
+ nsCOMArray<T> mCachedEntries;
+};
+
+#endif
diff --git a/xpcom/components/nsCategoryManager.cpp b/xpcom/components/nsCategoryManager.cpp
new file mode 100644
index 0000000000..a12fd510f5
--- /dev/null
+++ b/xpcom/components/nsCategoryManager.cpp
@@ -0,0 +1,692 @@
+/* -*- 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 "nsCategoryManager.h"
+#include "nsCategoryManagerUtils.h"
+
+#include "prio.h"
+#include "prlock.h"
+#include "nsArrayEnumerator.h"
+#include "nsCOMPtr.h"
+#include "nsTHashtable.h"
+#include "nsClassHashtable.h"
+#include "nsStringEnumerator.h"
+#include "nsSupportsPrimitives.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsReadableUtils.h"
+#include "nsCRT.h"
+#include "nsPrintfCString.h"
+#include "nsQuickSort.h"
+#include "nsEnumeratorUtils.h"
+#include "nsThreadUtils.h"
+#include "mozilla/ArenaAllocatorExtensions.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/Services.h"
+#include "mozilla/SimpleEnumerator.h"
+
+#include "ManifestParser.h"
+#include "nsSimpleEnumerator.h"
+
+using namespace mozilla;
+class nsIComponentLoaderManager;
+
+/*
+ CategoryDatabase
+ contains 0 or more 1-1 mappings of string to Category
+ each Category contains 0 or more 1-1 mappings of string keys to string values
+
+ In other words, the CategoryDatabase is a tree, whose root is a hashtable.
+ Internal nodes (or Categories) are hashtables. Leaf nodes are strings.
+
+ The leaf strings are allocated in an arena, because we assume they're not
+ going to change much ;)
+*/
+
+//
+// CategoryEnumerator class
+//
+
+class CategoryEnumerator : public nsSimpleEnumerator,
+ private nsStringEnumeratorBase {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_NSISIMPLEENUMERATOR
+ NS_DECL_NSIUTF8STRINGENUMERATOR
+
+ using nsStringEnumeratorBase::GetNext;
+
+ const nsID& DefaultInterface() override {
+ return NS_GET_IID(nsISupportsCString);
+ }
+
+ static CategoryEnumerator* Create(
+ nsClassHashtable<nsDepCharHashKey, CategoryNode>& aTable);
+
+ protected:
+ CategoryEnumerator()
+ : mArray(nullptr), mCount(0), mSimpleCurItem(0), mStringCurItem(0) {}
+
+ ~CategoryEnumerator() override { delete[] mArray; }
+
+ const char** mArray;
+ uint32_t mCount;
+ uint32_t mSimpleCurItem;
+ uint32_t mStringCurItem;
+};
+
+NS_IMPL_ISUPPORTS_INHERITED(CategoryEnumerator, nsSimpleEnumerator,
+ nsIUTF8StringEnumerator, nsIStringEnumerator)
+
+NS_IMETHODIMP
+CategoryEnumerator::HasMoreElements(bool* aResult) {
+ *aResult = (mSimpleCurItem < mCount);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+CategoryEnumerator::GetNext(nsISupports** aResult) {
+ if (mSimpleCurItem >= mCount) {
+ return NS_ERROR_FAILURE;
+ }
+
+ auto* str = new nsSupportsDependentCString(mArray[mSimpleCurItem++]);
+
+ *aResult = str;
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+CategoryEnumerator::HasMore(bool* aResult) {
+ *aResult = (mStringCurItem < mCount);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+CategoryEnumerator::GetNext(nsACString& aResult) {
+ if (mStringCurItem >= mCount) {
+ return NS_ERROR_FAILURE;
+ }
+
+ aResult = nsDependentCString(mArray[mStringCurItem++]);
+ return NS_OK;
+}
+
+CategoryEnumerator* CategoryEnumerator::Create(
+ nsClassHashtable<nsDepCharHashKey, CategoryNode>& aTable) {
+ auto* enumObj = new CategoryEnumerator();
+ if (!enumObj) {
+ return nullptr;
+ }
+
+ enumObj->mArray = new const char*[aTable.Count()];
+ if (!enumObj->mArray) {
+ delete enumObj;
+ return nullptr;
+ }
+
+ for (const auto& entry : aTable) {
+ // if a category has no entries, we pretend it doesn't exist
+ CategoryNode* aNode = entry.GetWeak();
+ if (aNode->Count()) {
+ enumObj->mArray[enumObj->mCount++] = entry.GetKey();
+ }
+ }
+
+ return enumObj;
+}
+
+class CategoryEntry final : public nsICategoryEntry {
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSICATEGORYENTRY
+ NS_DECL_NSISUPPORTSCSTRING
+ NS_DECL_NSISUPPORTSPRIMITIVE
+
+ CategoryEntry(const char* aKey, const char* aValue)
+ : mKey(aKey), mValue(aValue) {}
+
+ const char* Key() const { return mKey; }
+
+ static CategoryEntry* Cast(nsICategoryEntry* aEntry) {
+ return static_cast<CategoryEntry*>(aEntry);
+ }
+
+ private:
+ ~CategoryEntry() = default;
+
+ const char* mKey;
+ const char* mValue;
+};
+
+NS_IMPL_ISUPPORTS(CategoryEntry, nsICategoryEntry, nsISupportsCString)
+
+nsresult CategoryEntry::ToString(char** aResult) {
+ *aResult = moz_xstrdup(mKey);
+ return NS_OK;
+}
+
+nsresult CategoryEntry::GetType(uint16_t* aType) {
+ *aType = TYPE_CSTRING;
+ return NS_OK;
+}
+
+nsresult CategoryEntry::GetData(nsACString& aData) {
+ aData = mKey;
+ return NS_OK;
+}
+
+nsresult CategoryEntry::SetData(const nsACString& aData) {
+ return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult CategoryEntry::GetEntry(nsACString& aEntry) {
+ aEntry = mKey;
+ return NS_OK;
+}
+
+nsresult CategoryEntry::GetValue(nsACString& aValue) {
+ aValue = mValue;
+ return NS_OK;
+}
+
+static nsresult CreateEntryEnumerator(nsTHashtable<CategoryLeaf>& aTable,
+ nsISimpleEnumerator** aResult) {
+ nsCOMArray<nsICategoryEntry> entries(aTable.Count());
+
+ for (auto iter = aTable.Iter(); !iter.Done(); iter.Next()) {
+ CategoryLeaf* leaf = iter.Get();
+ if (leaf->value) {
+ entries.AppendElement(new CategoryEntry(leaf->GetKey(), leaf->value));
+ }
+ }
+
+ entries.Sort(
+ [](nsICategoryEntry* aA, nsICategoryEntry* aB, void*) {
+ return strcmp(CategoryEntry::Cast(aA)->Key(),
+ CategoryEntry::Cast(aB)->Key());
+ },
+ nullptr);
+
+ return NS_NewArrayEnumerator(aResult, entries, NS_GET_IID(nsICategoryEntry));
+}
+
+//
+// CategoryNode implementations
+//
+
+CategoryNode* CategoryNode::Create(CategoryAllocator* aArena) {
+ return new (aArena) CategoryNode();
+}
+
+CategoryNode::~CategoryNode() = default;
+
+void* CategoryNode::operator new(size_t aSize, CategoryAllocator* aArena) {
+ return aArena->Allocate(aSize, mozilla::fallible);
+}
+
+static inline const char* MaybeStrdup(const nsACString& aStr,
+ CategoryAllocator* aArena) {
+ if (aStr.IsLiteral()) {
+ return aStr.BeginReading();
+ }
+ return ArenaStrdup(PromiseFlatCString(aStr).get(), *aArena);
+}
+
+nsresult CategoryNode::GetLeaf(const nsACString& aEntryName,
+ nsACString& aResult) {
+ MutexAutoLock lock(mLock);
+ nsresult rv = NS_ERROR_NOT_AVAILABLE;
+ CategoryLeaf* ent = mTable.GetEntry(PromiseFlatCString(aEntryName).get());
+
+ if (ent && ent->value) {
+ aResult.Assign(ent->value);
+ return NS_OK;
+ }
+
+ return rv;
+}
+
+nsresult CategoryNode::AddLeaf(const nsACString& aEntryName,
+ const nsACString& aValue, bool aReplace,
+ nsACString& aResult, CategoryAllocator* aArena) {
+ aResult.SetIsVoid(true);
+
+ auto entryName = PromiseFlatCString(aEntryName);
+
+ MutexAutoLock lock(mLock);
+ CategoryLeaf* leaf = mTable.GetEntry(entryName.get());
+
+ if (!leaf) {
+ leaf = mTable.PutEntry(MaybeStrdup(aEntryName, aArena));
+ if (!leaf) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ if (leaf->value && !aReplace) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (leaf->value) {
+ aResult.AssignLiteral(leaf->value, strlen(leaf->value));
+ } else {
+ aResult.SetIsVoid(true);
+ }
+ leaf->value = MaybeStrdup(aValue, aArena);
+ return NS_OK;
+}
+
+void CategoryNode::DeleteLeaf(const nsACString& aEntryName) {
+ // we don't throw any errors, because it normally doesn't matter
+ // and it makes JS a lot cleaner
+ MutexAutoLock lock(mLock);
+
+ // we can just remove the entire hash entry without introspection
+ mTable.RemoveEntry(PromiseFlatCString(aEntryName).get());
+}
+
+nsresult CategoryNode::Enumerate(nsISimpleEnumerator** aResult) {
+ MutexAutoLock lock(mLock);
+ return CreateEntryEnumerator(mTable, aResult);
+}
+
+size_t CategoryNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) {
+ // We don't measure the strings pointed to by the entries because the
+ // pointers are non-owning.
+ return mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+}
+
+//
+// nsCategoryManager implementations
+//
+
+NS_IMPL_QUERY_INTERFACE(nsCategoryManager, nsICategoryManager,
+ nsIMemoryReporter)
+
+NS_IMETHODIMP_(MozExternalRefCountType)
+nsCategoryManager::AddRef() { return 2; }
+
+NS_IMETHODIMP_(MozExternalRefCountType)
+nsCategoryManager::Release() { return 1; }
+
+nsCategoryManager* nsCategoryManager::gCategoryManager;
+
+/* static */
+nsCategoryManager* nsCategoryManager::GetSingleton() {
+ if (!gCategoryManager) {
+ gCategoryManager = new nsCategoryManager();
+ }
+ return gCategoryManager;
+}
+
+/* static */
+void nsCategoryManager::Destroy() {
+ // The nsMemoryReporterManager gets destroyed before the nsCategoryManager,
+ // so we don't need to unregister the nsCategoryManager as a memory reporter.
+ // In debug builds we assert that unregistering fails, as a way (imperfect
+ // but better than nothing) of testing the "destroyed before" part.
+ MOZ_ASSERT(NS_FAILED(UnregisterWeakMemoryReporter(gCategoryManager)));
+
+ delete gCategoryManager;
+ gCategoryManager = nullptr;
+}
+
+nsresult nsCategoryManager::Create(REFNSIID aIID, void** aResult) {
+ return GetSingleton()->QueryInterface(aIID, aResult);
+}
+
+nsCategoryManager::nsCategoryManager()
+ : mArena(),
+ mTable(),
+ mLock("nsCategoryManager"),
+ mSuppressNotifications(false) {}
+
+void nsCategoryManager::InitMemoryReporter() {
+ RegisterWeakMemoryReporter(this);
+}
+
+nsCategoryManager::~nsCategoryManager() {
+ // the hashtable contains entries that must be deleted before the arena is
+ // destroyed, or else you will have PRLocks undestroyed and other Really
+ // Bad Stuff (TM)
+ mTable.Clear();
+}
+
+inline CategoryNode* nsCategoryManager::get_category(const nsACString& aName) {
+ CategoryNode* node;
+ if (!mTable.Get(PromiseFlatCString(aName).get(), &node)) {
+ return nullptr;
+ }
+ return node;
+}
+
+MOZ_DEFINE_MALLOC_SIZE_OF(CategoryManagerMallocSizeOf)
+
+NS_IMETHODIMP
+nsCategoryManager::CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize) {
+ MOZ_COLLECT_REPORT("explicit/xpcom/category-manager", KIND_HEAP, UNITS_BYTES,
+ SizeOfIncludingThis(CategoryManagerMallocSizeOf),
+ "Memory used for the XPCOM category manager.");
+
+ return NS_OK;
+}
+
+size_t nsCategoryManager::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ size_t n = aMallocSizeOf(this);
+
+ n += mArena.SizeOfExcludingThis(aMallocSizeOf);
+
+ n += mTable.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (const auto& data : mTable.Values()) {
+ // We don't measure the key string because it's a non-owning pointer.
+ n += data->SizeOfExcludingThis(aMallocSizeOf);
+ }
+
+ return n;
+}
+
+namespace {
+
+class CategoryNotificationRunnable : public Runnable {
+ public:
+ CategoryNotificationRunnable(nsISupports* aSubject, const char* aTopic,
+ const nsACString& aData)
+ : Runnable("CategoryNotificationRunnable"),
+ mSubject(aSubject),
+ mTopic(aTopic),
+ mData(aData) {}
+
+ NS_DECL_NSIRUNNABLE
+
+ private:
+ nsCOMPtr<nsISupports> mSubject;
+ const char* mTopic;
+ NS_ConvertUTF8toUTF16 mData;
+};
+
+NS_IMETHODIMP
+CategoryNotificationRunnable::Run() {
+ nsCOMPtr<nsIObserverService> observerService =
+ mozilla::services::GetObserverService();
+ if (observerService) {
+ observerService->NotifyObservers(mSubject, mTopic, mData.get());
+ }
+
+ return NS_OK;
+}
+
+} // namespace
+
+void nsCategoryManager::NotifyObservers(const char* aTopic,
+ const nsACString& aCategoryName,
+ const nsACString& aEntryName) {
+ if (mSuppressNotifications) {
+ return;
+ }
+
+ RefPtr<CategoryNotificationRunnable> r;
+
+ if (aEntryName.Length()) {
+ nsCOMPtr<nsISupportsCString> entry =
+ do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID);
+ if (!entry) {
+ return;
+ }
+
+ nsresult rv = entry->SetData(aEntryName);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ r = new CategoryNotificationRunnable(entry, aTopic, aCategoryName);
+ } else {
+ r = new CategoryNotificationRunnable(
+ NS_ISUPPORTS_CAST(nsICategoryManager*, this), aTopic, aCategoryName);
+ }
+
+ NS_DispatchToMainThread(r);
+}
+
+NS_IMETHODIMP
+nsCategoryManager::GetCategoryEntry(const nsACString& aCategoryName,
+ const nsACString& aEntryName,
+ nsACString& aResult) {
+ nsresult status = NS_ERROR_NOT_AVAILABLE;
+
+ CategoryNode* category;
+ {
+ MutexAutoLock lock(mLock);
+ category = get_category(aCategoryName);
+ }
+
+ if (category) {
+ status = category->GetLeaf(aEntryName, aResult);
+ }
+
+ return status;
+}
+
+NS_IMETHODIMP
+nsCategoryManager::AddCategoryEntry(const nsACString& aCategoryName,
+ const nsACString& aEntryName,
+ const nsACString& aValue, bool aPersist,
+ bool aReplace, nsACString& aResult) {
+ if (aPersist) {
+ NS_ERROR("Category manager doesn't support persistence.");
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ AddCategoryEntry(aCategoryName, aEntryName, aValue, aReplace, aResult);
+ return NS_OK;
+}
+
+void nsCategoryManager::AddCategoryEntry(const nsACString& aCategoryName,
+ const nsACString& aEntryName,
+ const nsACString& aValue,
+ bool aReplace, nsACString& aOldValue) {
+ aOldValue.SetIsVoid(true);
+
+ // Before we can insert a new entry, we'll need to
+ // find the |CategoryNode| to put it in...
+ CategoryNode* category;
+ {
+ MutexAutoLock lock(mLock);
+ category = get_category(aCategoryName);
+
+ if (!category) {
+ // That category doesn't exist yet; let's make it.
+ category = mTable
+ .InsertOrUpdate(
+ MaybeStrdup(aCategoryName, &mArena),
+ UniquePtr<CategoryNode>{CategoryNode::Create(&mArena)})
+ .get();
+ }
+ }
+
+ if (!category) {
+ return;
+ }
+
+ nsresult rv =
+ category->AddLeaf(aEntryName, aValue, aReplace, aOldValue, &mArena);
+
+ if (NS_SUCCEEDED(rv)) {
+ if (!aOldValue.IsEmpty()) {
+ NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID,
+ aCategoryName, aEntryName);
+ }
+ NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_ADDED_OBSERVER_ID, aCategoryName,
+ aEntryName);
+ }
+}
+
+NS_IMETHODIMP
+nsCategoryManager::DeleteCategoryEntry(const nsACString& aCategoryName,
+ const nsACString& aEntryName,
+ bool aDontPersist) {
+ /*
+ Note: no errors are reported since failure to delete
+ probably won't hurt you, and returning errors seriously
+ inconveniences JS clients
+ */
+
+ CategoryNode* category;
+ {
+ MutexAutoLock lock(mLock);
+ category = get_category(aCategoryName);
+ }
+
+ if (category) {
+ category->DeleteLeaf(aEntryName);
+
+ NotifyObservers(NS_XPCOM_CATEGORY_ENTRY_REMOVED_OBSERVER_ID, aCategoryName,
+ aEntryName);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCategoryManager::DeleteCategory(const nsACString& aCategoryName) {
+ // the categories are arena-allocated, so we don't
+ // actually delete them. We just remove all of the
+ // leaf nodes.
+
+ CategoryNode* category;
+ {
+ MutexAutoLock lock(mLock);
+ category = get_category(aCategoryName);
+ }
+
+ if (category) {
+ category->Clear();
+ NotifyObservers(NS_XPCOM_CATEGORY_CLEARED_OBSERVER_ID, aCategoryName,
+ VoidCString());
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCategoryManager::EnumerateCategory(const nsACString& aCategoryName,
+ nsISimpleEnumerator** aResult) {
+ CategoryNode* category;
+ {
+ MutexAutoLock lock(mLock);
+ category = get_category(aCategoryName);
+ }
+
+ if (!category) {
+ return NS_NewEmptyEnumerator(aResult);
+ }
+
+ return category->Enumerate(aResult);
+}
+
+NS_IMETHODIMP
+nsCategoryManager::EnumerateCategories(nsISimpleEnumerator** aResult) {
+ if (NS_WARN_IF(!aResult)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ MutexAutoLock lock(mLock);
+ CategoryEnumerator* enumObj = CategoryEnumerator::Create(mTable);
+
+ if (!enumObj) {
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ *aResult = enumObj;
+ NS_ADDREF(*aResult);
+ return NS_OK;
+}
+
+struct writecat_struct {
+ PRFileDesc* fd;
+ bool success;
+};
+
+nsresult nsCategoryManager::SuppressNotifications(bool aSuppress) {
+ mSuppressNotifications = aSuppress;
+ return NS_OK;
+}
+
+/*
+ * CreateServicesFromCategory()
+ *
+ * Given a category, this convenience functions enumerates the category and
+ * creates a service of every CID or ContractID registered under the category.
+ * If observerTopic is non null and the service implements nsIObserver,
+ * this will attempt to notify the observer with the origin, observerTopic
+ * string as parameter.
+ */
+void NS_CreateServicesFromCategory(const char* aCategory, nsISupports* aOrigin,
+ const char* aObserverTopic,
+ const char16_t* aObserverData) {
+ nsresult rv;
+
+ nsCOMPtr<nsICategoryManager> categoryManager =
+ do_GetService("@mozilla.org/categorymanager;1");
+ if (!categoryManager) {
+ return;
+ }
+
+ nsDependentCString category(aCategory);
+
+ nsCOMPtr<nsISimpleEnumerator> enumerator;
+ rv = categoryManager->EnumerateCategory(category, getter_AddRefs(enumerator));
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ for (auto& categoryEntry : SimpleEnumerator<nsICategoryEntry>(enumerator)) {
+ // From here on just skip any error we get.
+ nsAutoCString entryString;
+ categoryEntry->GetEntry(entryString);
+
+ nsAutoCString contractID;
+ categoryEntry->GetValue(contractID);
+
+ nsCOMPtr<nsISupports> instance = do_GetService(contractID.get());
+ if (!instance) {
+ LogMessage(
+ "While creating services from category '%s', could not create "
+ "service for entry '%s', contract ID '%s'",
+ aCategory, entryString.get(), contractID.get());
+ continue;
+ }
+
+ if (aObserverTopic) {
+ // try an observer, if it implements it.
+ nsCOMPtr<nsIObserver> observer = do_QueryInterface(instance);
+ if (observer) {
+ nsPrintfCString profilerStr("%s (%s)", aObserverTopic,
+ entryString.get());
+ AUTO_PROFILER_MARKER_TEXT("Category observer notification", OTHER,
+ MarkerStack::Capture(), profilerStr);
+ AUTO_PROFILER_LABEL_DYNAMIC_NSCSTRING_NONSENSITIVE(
+ "Category observer notification -", OTHER, profilerStr);
+
+ observer->Observe(aOrigin, aObserverTopic,
+ aObserverData ? aObserverData : u"");
+ } else {
+ LogMessage(
+ "While creating services from category '%s', service for entry "
+ "'%s', contract ID '%s' does not implement nsIObserver.",
+ aCategory, entryString.get(), contractID.get());
+ }
+ }
+ }
+}
diff --git a/xpcom/components/nsCategoryManager.h b/xpcom/components/nsCategoryManager.h
new file mode 100644
index 0000000000..e15760768d
--- /dev/null
+++ b/xpcom/components/nsCategoryManager.h
@@ -0,0 +1,145 @@
+/* -*- 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/. */
+
+#ifndef NSCATEGORYMANAGER_H
+#define NSCATEGORYMANAGER_H
+
+#include "prio.h"
+#include "nsClassHashtable.h"
+#include "nsICategoryManager.h"
+#include "nsIMemoryReporter.h"
+#include "mozilla/ArenaAllocator.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Mutex.h"
+#include "mozilla/Attributes.h"
+
+class nsIMemoryReporter;
+
+typedef mozilla::ArenaAllocator<1024 * 8, 8> CategoryAllocator;
+
+/* 16d222a6-1dd2-11b2-b693-f38b02c021b2 */
+#define NS_CATEGORYMANAGER_CID \
+ { \
+ 0x16d222a6, 0x1dd2, 0x11b2, { \
+ 0xb6, 0x93, 0xf3, 0x8b, 0x02, 0xc0, 0x21, 0xb2 \
+ } \
+ }
+
+/**
+ * a "leaf-node", managed by the nsCategoryNode hashtable.
+ *
+ * we need to keep a "persistent value" (which will be written to the registry)
+ * and a non-persistent value (for the current runtime): these are usually
+ * the same, except when aPersist==false. The strings are permanently arena-
+ * allocated, and will never go away.
+ */
+class CategoryLeaf : public nsDepCharHashKey {
+ public:
+ explicit CategoryLeaf(const char* aKey)
+ : nsDepCharHashKey(aKey), value(nullptr) {}
+ const char* value;
+};
+
+/**
+ * CategoryNode keeps a hashtable of its entries.
+ * the CategoryNode itself is permanently allocated in
+ * the arena.
+ */
+class CategoryNode {
+ public:
+ nsresult GetLeaf(const nsACString& aEntryName, nsACString& aResult);
+
+ nsresult AddLeaf(const nsACString& aEntryName, const nsACString& aValue,
+ bool aReplace, nsACString& aResult,
+ CategoryAllocator* aArena);
+
+ void DeleteLeaf(const nsACString& aEntryName);
+
+ void Clear() {
+ mozilla::MutexAutoLock lock(mLock);
+ mTable.Clear();
+ }
+
+ uint32_t Count() {
+ mozilla::MutexAutoLock lock(mLock);
+ uint32_t tCount = mTable.Count();
+ return tCount;
+ }
+
+ nsresult Enumerate(nsISimpleEnumerator** aResult);
+
+ // CategoryNode is arena-allocated, with the strings
+ static CategoryNode* Create(CategoryAllocator* aArena);
+ ~CategoryNode();
+ void operator delete(void*) {}
+
+ size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf);
+
+ private:
+ CategoryNode() : mLock("CategoryLeaf") {}
+
+ void* operator new(size_t aSize, CategoryAllocator* aArena);
+
+ nsTHashtable<CategoryLeaf> mTable;
+ mozilla::Mutex mLock MOZ_UNANNOTATED;
+};
+
+/**
+ * The main implementation of nsICategoryManager.
+ *
+ * This implementation is thread-safe.
+ */
+class nsCategoryManager final : public nsICategoryManager,
+ public nsIMemoryReporter {
+ public:
+ NS_DECL_ISUPPORTS
+ NS_DECL_NSICATEGORYMANAGER
+ NS_DECL_NSIMEMORYREPORTER
+
+ /**
+ * Suppress or unsuppress notifications of category changes to the
+ * observer service. This is to be used by nsComponentManagerImpl
+ * on startup while reading the stored category list.
+ */
+ nsresult SuppressNotifications(bool aSuppress);
+
+ void AddCategoryEntry(const nsACString& aCategory, const nsACString& aKey,
+ const nsACString& aValue, bool aReplace,
+ nsACString& aOldValue);
+
+ void AddCategoryEntry(const nsACString& aCategory, const nsACString& aKey,
+ const nsACString& aValue, bool aReplace = true) {
+ nsCString oldValue;
+ return AddCategoryEntry(aCategory, aKey, aValue, aReplace, oldValue);
+ }
+
+ static nsresult Create(REFNSIID aIID, void** aResult);
+ void InitMemoryReporter();
+
+ static nsCategoryManager* GetSingleton();
+ static void Destroy();
+
+ private:
+ static nsCategoryManager* gCategoryManager;
+
+ nsCategoryManager();
+ ~nsCategoryManager();
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
+
+ CategoryNode* get_category(const nsACString& aName);
+ void NotifyObservers(
+ const char* aTopic,
+ const nsACString& aCategoryName, // must be a static string
+ const nsACString& aEntryName);
+
+ CategoryAllocator mArena;
+ nsClassHashtable<nsDepCharHashKey, CategoryNode> mTable;
+ mozilla::Mutex mLock MOZ_UNANNOTATED;
+ bool mSuppressNotifications;
+};
+
+#endif
diff --git a/xpcom/components/nsCategoryManagerUtils.h b/xpcom/components/nsCategoryManagerUtils.h
new file mode 100644
index 0000000000..30db31bab6
--- /dev/null
+++ b/xpcom/components/nsCategoryManagerUtils.h
@@ -0,0 +1,14 @@
+/* -*- 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/. */
+
+#ifndef nsCategoryManagerUtils_h__
+#define nsCategoryManagerUtils_h__
+
+void NS_CreateServicesFromCategory(const char* aCategory, nsISupports* aOrigin,
+ const char* aObserverTopic,
+ const char16_t* aObserverData = nullptr);
+
+#endif
diff --git a/xpcom/components/nsComponentManager.cpp b/xpcom/components/nsComponentManager.cpp
new file mode 100644
index 0000000000..35954b1702
--- /dev/null
+++ b/xpcom/components/nsComponentManager.cpp
@@ -0,0 +1,1575 @@
+/* -*- 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 <stdlib.h>
+#include "nscore.h"
+#include "nsISupports.h"
+#include "nspr.h"
+#include "nsCRT.h" // for atoll
+
+#include "StaticComponents.h"
+
+#include "nsCategoryManager.h"
+#include "nsCOMPtr.h"
+#include "nsComponentManager.h"
+#include "nsDirectoryService.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsCategoryManager.h"
+#include "nsLayoutModule.h"
+#include "mozilla/MemoryReporting.h"
+#include "nsIObserverService.h"
+#include "nsIStringEnumerator.h"
+#include "nsXPCOM.h"
+#include "nsXPCOMPrivate.h"
+#include "nsISupportsPrimitives.h"
+#include "nsLocalFile.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+#include "prcmon.h"
+#include "nsThreadManager.h"
+#include "nsThreadUtils.h"
+#include "prthread.h"
+#include "private/pprthred.h"
+#include "nsTArray.h"
+#include "prio.h"
+#include "ManifestParser.h"
+#include "nsNetUtil.h"
+#include "mozilla/Services.h"
+
+#include "mozilla/GenericFactory.h"
+#include "nsSupportsPrimitives.h"
+#include "nsArray.h"
+#include "nsIMutableArray.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/ProfilerMarkers.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/URLPreloader.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Variant.h"
+
+#include <new> // for placement new
+
+#include "mozilla/Omnijar.h"
+
+#include "mozilla/Logging.h"
+#include "LogModulePrefWatcher.h"
+
+#ifdef MOZ_MEMORY
+# include "mozmemory.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::xpcom;
+
+static LazyLogModule nsComponentManagerLog("nsComponentManager");
+
+#if 0
+# define SHOW_DENIED_ON_SHUTDOWN
+# define SHOW_CI_ON_EXISTING_SERVICE
+#endif
+
+namespace {
+
+class AutoIDString : public nsAutoCStringN<NSID_LENGTH> {
+ public:
+ explicit AutoIDString(const nsID& aID) {
+ SetLength(NSID_LENGTH - 1);
+ aID.ToProvidedString(
+ *reinterpret_cast<char(*)[NSID_LENGTH]>(BeginWriting()));
+ }
+};
+
+} // namespace
+
+namespace mozilla {
+namespace xpcom {
+
+using ProcessSelector = Module::ProcessSelector;
+
+// Note: These must be kept in sync with the ProcessSelector definition in
+// Module.h.
+bool ProcessSelectorMatches(ProcessSelector aSelector) {
+ GeckoProcessType type = XRE_GetProcessType();
+ if (type == GeckoProcessType_GPU) {
+ return !!(aSelector & Module::ALLOW_IN_GPU_PROCESS);
+ }
+
+ if (type == GeckoProcessType_RDD) {
+ return !!(aSelector & Module::ALLOW_IN_RDD_PROCESS);
+ }
+
+ if (type == GeckoProcessType_Socket) {
+ return !!(aSelector & (Module::ALLOW_IN_SOCKET_PROCESS));
+ }
+
+ if (type == GeckoProcessType_VR) {
+ return !!(aSelector & Module::ALLOW_IN_VR_PROCESS);
+ }
+
+ if (type == GeckoProcessType_Utility) {
+ return !!(aSelector & Module::ALLOW_IN_UTILITY_PROCESS);
+ }
+
+ // Only allow XPCOM modules which can be loaded in all processes to be loaded
+ // in the IPDLUnitTest process.
+ if (type == GeckoProcessType_IPDLUnitTest) {
+ return size_t(aSelector) == Module::kMaxProcessSelector;
+ }
+
+ if (aSelector & Module::MAIN_PROCESS_ONLY) {
+ return type == GeckoProcessType_Default;
+ }
+ if (aSelector & Module::CONTENT_PROCESS_ONLY) {
+ return type == GeckoProcessType_Content;
+ }
+ return true;
+}
+
+static bool gProcessMatchTable[Module::kMaxProcessSelector + 1];
+
+bool FastProcessSelectorMatches(ProcessSelector aSelector) {
+ return gProcessMatchTable[size_t(aSelector)];
+}
+
+} // namespace xpcom
+} // namespace mozilla
+
+namespace {
+
+/**
+ * A wrapper simple wrapper class, which can hold either a dynamic
+ * nsFactoryEntry instance, or a static StaticModule entry, and transparently
+ * forwards method calls to the wrapped object.
+ *
+ * This allows the same code to work with either static or dynamic modules
+ * without caring about the difference.
+ */
+class MOZ_STACK_CLASS EntryWrapper final {
+ public:
+ explicit EntryWrapper(nsFactoryEntry* aEntry) : mEntry(aEntry) {}
+
+ explicit EntryWrapper(const StaticModule* aEntry) : mEntry(aEntry) {}
+
+#define MATCH(type, ifFactory, ifStatic) \
+ struct Matcher { \
+ type operator()(nsFactoryEntry* entry) { ifFactory; } \
+ type operator()(const StaticModule* entry) { ifStatic; } \
+ }; \
+ return mEntry.match((Matcher()))
+
+ const nsID& CID() {
+ MATCH(const nsID&, return entry->mCID, return entry->CID());
+ }
+
+ already_AddRefed<nsIFactory> GetFactory() {
+ MATCH(already_AddRefed<nsIFactory>, return entry->GetFactory(),
+ return entry->GetFactory());
+ }
+
+ /**
+ * Creates an instance of the underlying component. This should be used in
+ * preference to GetFactory()->CreateInstance() where appropriate, since it
+ * side-steps the necessity of creating a nsIFactory instance for static
+ * modules.
+ */
+ nsresult CreateInstance(const nsIID& aIID, void** aResult) {
+ if (mEntry.is<nsFactoryEntry*>()) {
+ return mEntry.as<nsFactoryEntry*>()->CreateInstance(aIID, aResult);
+ }
+ return mEntry.as<const StaticModule*>()->CreateInstance(aIID, aResult);
+ }
+
+ /**
+ * Returns the cached service instance for this entry, if any. This should
+ * only be accessed while mLock is held.
+ */
+ nsISupports* ServiceInstance() {
+ MATCH(nsISupports*, return entry->mServiceObject,
+ return entry->ServiceInstance());
+ }
+ void SetServiceInstance(already_AddRefed<nsISupports> aInst) {
+ if (mEntry.is<nsFactoryEntry*>()) {
+ mEntry.as<nsFactoryEntry*>()->mServiceObject = aInst;
+ } else {
+ return mEntry.as<const StaticModule*>()->SetServiceInstance(
+ std::move(aInst));
+ }
+ }
+
+ /**
+ * Returns the description string for the module this entry belongs to.
+ * Currently always returns "<unknown module>".
+ */
+ nsCString ModuleDescription() { return "<unknown module>"_ns; }
+
+ private:
+ Variant<nsFactoryEntry*, const StaticModule*> mEntry;
+};
+
+} // namespace
+
+// this is safe to call during InitXPCOM
+static already_AddRefed<nsIFile> GetLocationFromDirectoryService(
+ const char* aProp) {
+ nsCOMPtr<nsIProperties> directoryService;
+ nsDirectoryService::Create(NS_GET_IID(nsIProperties),
+ getter_AddRefs(directoryService));
+
+ if (!directoryService) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIFile> file;
+ nsresult rv =
+ directoryService->Get(aProp, NS_GET_IID(nsIFile), getter_AddRefs(file));
+ if (NS_FAILED(rv)) {
+ return nullptr;
+ }
+
+ return file.forget();
+}
+
+static already_AddRefed<nsIFile> CloneAndAppend(nsIFile* aBase,
+ const nsACString& aAppend) {
+ nsCOMPtr<nsIFile> f;
+ aBase->Clone(getter_AddRefs(f));
+ if (!f) {
+ return nullptr;
+ }
+
+ f->AppendNative(aAppend);
+ return f.forget();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsComponentManagerImpl
+////////////////////////////////////////////////////////////////////////////////
+
+nsresult nsComponentManagerImpl::Create(REFNSIID aIID, void** aResult) {
+ if (!gComponentManager) {
+ return NS_ERROR_FAILURE;
+ }
+
+ return gComponentManager->QueryInterface(aIID, aResult);
+}
+
+static const int CONTRACTID_HASHTABLE_INITIAL_LENGTH = 8;
+
+nsComponentManagerImpl::nsComponentManagerImpl()
+ : mFactories(CONTRACTID_HASHTABLE_INITIAL_LENGTH),
+ mContractIDs(CONTRACTID_HASHTABLE_INITIAL_LENGTH),
+ mLock("nsComponentManagerImpl.mLock"),
+ mStatus(NOT_INITIALIZED) {}
+
+nsTArray<nsComponentManagerImpl::ComponentLocation>*
+ nsComponentManagerImpl::sModuleLocations;
+
+/* static */
+void nsComponentManagerImpl::InitializeModuleLocations() {
+ if (sModuleLocations) {
+ return;
+ }
+
+ sModuleLocations = new nsTArray<ComponentLocation>;
+}
+
+nsresult nsComponentManagerImpl::Init() {
+ {
+ gProcessMatchTable[size_t(ProcessSelector::ANY_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ANY_PROCESS);
+ gProcessMatchTable[size_t(ProcessSelector::MAIN_PROCESS_ONLY)] =
+ ProcessSelectorMatches(ProcessSelector::MAIN_PROCESS_ONLY);
+ gProcessMatchTable[size_t(ProcessSelector::CONTENT_PROCESS_ONLY)] =
+ ProcessSelectorMatches(ProcessSelector::CONTENT_PROCESS_ONLY);
+ gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_PROCESS);
+ gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_VR_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ALLOW_IN_VR_PROCESS);
+ gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_SOCKET_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ALLOW_IN_SOCKET_PROCESS);
+ gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_RDD_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ALLOW_IN_RDD_PROCESS);
+ gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_AND_MAIN_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_AND_MAIN_PROCESS);
+ gProcessMatchTable[size_t(ProcessSelector::ALLOW_IN_GPU_AND_VR_PROCESS)] =
+ ProcessSelectorMatches(ProcessSelector::ALLOW_IN_GPU_AND_VR_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_GPU_AND_SOCKET_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_GPU_AND_SOCKET_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_GPU_VR_AND_SOCKET_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_RDD_AND_SOCKET_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_RDD_AND_SOCKET_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_GPU_RDD_AND_SOCKET_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_GPU_RDD_SOCKET_AND_UTILITY_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_GPU_RDD_VR_AND_SOCKET_PROCESS);
+ gProcessMatchTable[size_t(
+ ProcessSelector::ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS)] =
+ ProcessSelectorMatches(
+ ProcessSelector::ALLOW_IN_GPU_RDD_VR_SOCKET_AND_UTILITY_PROCESS);
+ }
+
+ MOZ_ASSERT(NOT_INITIALIZED == mStatus);
+
+ nsCOMPtr<nsIFile> greDir = GetLocationFromDirectoryService(NS_GRE_DIR);
+ nsCOMPtr<nsIFile> appDir =
+ GetLocationFromDirectoryService(NS_XPCOM_CURRENT_PROCESS_DIR);
+
+ nsCategoryManager::GetSingleton()->SuppressNotifications(true);
+
+ auto* catMan = nsCategoryManager::GetSingleton();
+ for (const auto& cat : gStaticCategories) {
+ for (const auto& entry : cat) {
+ if (entry.Active()) {
+ catMan->AddCategoryEntry(cat.Name(), entry.Entry(), entry.Value());
+ }
+ }
+ }
+
+ bool loadChromeManifests;
+ switch (XRE_GetProcessType()) {
+ // We are going to assume that only a select few (see below) process types
+ // want to load chrome manifests, and that any new process types will not
+ // want to load them, because they're not going to be executing JS.
+ case GeckoProcessType_RemoteSandboxBroker:
+ default:
+ loadChromeManifests = false;
+ break;
+
+ // XXX The check this code replaced implicitly let through all of these
+ // process types, but presumably only the default (parent) and content
+ // processes really need chrome manifests...?
+ case GeckoProcessType_Default:
+ case GeckoProcessType_Content:
+ case GeckoProcessType_GMPlugin:
+ loadChromeManifests = true;
+ break;
+ }
+
+ if (loadChromeManifests) {
+ // This needs to be called very early, before anything in nsLayoutModule is
+ // used, and before any calls are made into the JS engine.
+ nsLayoutModuleInitialize();
+
+ mJSLoaderReady = true;
+
+ // The overall order in which chrome.manifests are expected to be treated
+ // is the following:
+ // - greDir's omni.ja or greDir
+ // - appDir's omni.ja or appDir
+
+ InitializeModuleLocations();
+ ComponentLocation* cl = sModuleLocations->AppendElement();
+ cl->type = NS_APP_LOCATION;
+ RefPtr<nsZipArchive> greOmnijar =
+ mozilla::Omnijar::GetReader(mozilla::Omnijar::GRE);
+ if (greOmnijar) {
+ cl->location.Init(greOmnijar, "chrome.manifest");
+ } else {
+ nsCOMPtr<nsIFile> lf = CloneAndAppend(greDir, "chrome.manifest"_ns);
+ cl->location.Init(lf);
+ }
+
+ RefPtr<nsZipArchive> appOmnijar =
+ mozilla::Omnijar::GetReader(mozilla::Omnijar::APP);
+ if (appOmnijar) {
+ cl = sModuleLocations->AppendElement();
+ cl->type = NS_APP_LOCATION;
+ cl->location.Init(appOmnijar, "chrome.manifest");
+ } else {
+ bool equals = false;
+ appDir->Equals(greDir, &equals);
+ if (!equals) {
+ cl = sModuleLocations->AppendElement();
+ cl->type = NS_APP_LOCATION;
+ nsCOMPtr<nsIFile> lf = CloneAndAppend(appDir, "chrome.manifest"_ns);
+ cl->location.Init(lf);
+ }
+ }
+
+ RereadChromeManifests(false);
+ }
+
+ nsCategoryManager::GetSingleton()->SuppressNotifications(false);
+
+ RegisterWeakMemoryReporter(this);
+
+ // NB: The logging preference watcher needs to be registered late enough in
+ // startup that it's okay to use the preference system, but also as soon as
+ // possible so that log modules enabled via preferences are turned on as
+ // early as possible.
+ //
+ // We can't initialize the preference watcher when the log module manager is
+ // initialized, as a number of things attempt to start logging before the
+ // preference system is initialized.
+ //
+ // The preference system is registered as a component so at this point during
+ // component manager initialization we know it is setup and we can register
+ // for notifications.
+ LogModulePrefWatcher::RegisterPrefWatcher();
+
+ // Unfortunately, we can't register the nsCategoryManager memory reporter
+ // in its constructor (which is triggered by the GetSingleton() call
+ // above) because the memory reporter manager isn't initialized at that
+ // point. So we wait until now.
+ nsCategoryManager::GetSingleton()->InitMemoryReporter();
+
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Debug,
+ ("nsComponentManager: Initialized."));
+
+ mStatus = NORMAL;
+
+ MOZ_ASSERT(!XRE_IsContentProcess() ||
+ CONTRACTID_HASHTABLE_INITIAL_LENGTH <= 8 ||
+ mFactories.Count() > CONTRACTID_HASHTABLE_INITIAL_LENGTH / 3,
+ "Initial component hashtable size is too large");
+
+ return NS_OK;
+}
+
+template <typename T>
+static void AssertNotMallocAllocated(T* aPtr) {
+#if defined(DEBUG) && defined(MOZ_MEMORY)
+ jemalloc_ptr_info_t info;
+ jemalloc_ptr_info((void*)aPtr, &info);
+ MOZ_ASSERT(info.tag == TagUnknown);
+#endif
+}
+
+template <typename T>
+static void AssertNotStackAllocated(T* aPtr) {
+ // On all of our supported platforms, the stack grows down. Any address
+ // located below the address of our argument is therefore guaranteed not to be
+ // stack-allocated by the caller.
+ //
+ // For addresses above our argument, things get trickier. The main thread
+ // stack is traditionally placed at the top of the program's address space,
+ // but that is becoming less reliable as more and more systems adopt address
+ // space layout randomization strategies, so we have to guess how much space
+ // above our argument pointer we need to care about.
+ //
+ // On most systems, we're guaranteed at least several KiB at the top of each
+ // stack for TLS. We'd probably be safe assuming at least 4KiB in the stack
+ // segment above our argument address, but safer is... well, safer.
+ //
+ // For threads with huge stacks, it's theoretically possible that we could
+ // wind up being passed a stack-allocated string from farther up the stack,
+ // but this is a best-effort thing, so we'll assume we only care about the
+ // immediate caller. For that case, max 2KiB per stack frame is probably a
+ // reasonable guess most of the time, and is less than the ~4KiB that we
+ // expect for TLS, so go with that to avoid the risk of bumping into heap
+ // data just above the stack.
+#ifdef DEBUG
+ static constexpr size_t kFuzz = 2048;
+
+ MOZ_ASSERT(uintptr_t(aPtr) < uintptr_t(&aPtr) ||
+ uintptr_t(aPtr) > uintptr_t(&aPtr) + kFuzz);
+#endif
+}
+
+static void DoRegisterManifest(NSLocationType aType, FileLocation& aFile,
+ bool aChromeOnly) {
+ auto result = URLPreloader::Read(aFile);
+ if (result.isOk()) {
+ nsCString buf(result.unwrap());
+ ParseManifest(aType, aFile, buf.BeginWriting(), aChromeOnly);
+ } else if (NS_BOOTSTRAPPED_LOCATION != aType) {
+ nsCString uri;
+ aFile.GetURIString(uri);
+ LogMessage("Could not read chrome manifest '%s'.", uri.get());
+ }
+}
+
+void nsComponentManagerImpl::RegisterManifest(NSLocationType aType,
+ FileLocation& aFile,
+ bool aChromeOnly) {
+ DoRegisterManifest(aType, aFile, aChromeOnly);
+}
+
+void nsComponentManagerImpl::ManifestManifest(ManifestProcessingContext& aCx,
+ int aLineNo, char* const* aArgv) {
+ char* file = aArgv[0];
+ FileLocation f(aCx.mFile, file);
+ RegisterManifest(aCx.mType, f, aCx.mChromeOnly);
+}
+
+void nsComponentManagerImpl::ManifestCategory(ManifestProcessingContext& aCx,
+ int aLineNo, char* const* aArgv) {
+ char* category = aArgv[0];
+ char* key = aArgv[1];
+ char* value = aArgv[2];
+
+ nsCategoryManager::GetSingleton()->AddCategoryEntry(
+ nsDependentCString(category), nsDependentCString(key),
+ nsDependentCString(value));
+}
+
+void nsComponentManagerImpl::RereadChromeManifests(bool aChromeOnly) {
+ for (uint32_t i = 0; i < sModuleLocations->Length(); ++i) {
+ ComponentLocation& l = sModuleLocations->ElementAt(i);
+ RegisterManifest(l.type, l.location, aChromeOnly);
+ }
+
+ nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+ if (obs) {
+ obs->NotifyObservers(nullptr, "chrome-manifests-loaded", nullptr);
+ }
+}
+
+nsresult nsComponentManagerImpl::Shutdown(void) {
+ MOZ_ASSERT(NORMAL == mStatus);
+
+ mStatus = SHUTDOWN_IN_PROGRESS;
+
+ // Shutdown the component manager
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Debug,
+ ("nsComponentManager: Beginning Shutdown."));
+
+ UnregisterWeakMemoryReporter(this);
+
+ // Release all cached factories
+ mContractIDs.Clear();
+ mFactories.Clear(); // XXX release the objects, don't just clear
+
+ StaticComponents::Shutdown();
+
+ delete sModuleLocations;
+
+ mStatus = SHUTDOWN_COMPLETE;
+
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Debug,
+ ("nsComponentManager: Shutdown complete."));
+
+ return NS_OK;
+}
+
+nsComponentManagerImpl::~nsComponentManagerImpl() {
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Debug,
+ ("nsComponentManager: Beginning destruction."));
+
+ if (SHUTDOWN_COMPLETE != mStatus) {
+ Shutdown();
+ }
+
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Debug,
+ ("nsComponentManager: Destroyed."));
+}
+
+NS_IMPL_ISUPPORTS(nsComponentManagerImpl, nsIComponentManager,
+ nsIServiceManager, nsIComponentRegistrar,
+ nsISupportsWeakReference, nsIInterfaceRequestor,
+ nsIMemoryReporter)
+
+nsresult nsComponentManagerImpl::GetInterface(const nsIID& aUuid,
+ void** aResult) {
+ NS_WARNING("This isn't supported");
+ // fall through to QI as anything QIable is a superset of what can be
+ // got via the GetInterface()
+ return QueryInterface(aUuid, aResult);
+}
+
+Maybe<EntryWrapper> nsComponentManagerImpl::LookupByCID(const nsID& aCID) {
+ return LookupByCID(MonitorAutoLock(mLock), aCID);
+}
+
+Maybe<EntryWrapper> nsComponentManagerImpl::LookupByCID(const MonitorAutoLock&,
+ const nsID& aCID) {
+ if (const StaticModule* module = StaticComponents::LookupByCID(aCID)) {
+ return Some(EntryWrapper(module));
+ }
+ if (nsFactoryEntry* entry = mFactories.Get(&aCID)) {
+ return Some(EntryWrapper(entry));
+ }
+ return Nothing();
+}
+
+Maybe<EntryWrapper> nsComponentManagerImpl::LookupByContractID(
+ const nsACString& aContractID) {
+ return LookupByContractID(MonitorAutoLock(mLock), aContractID);
+}
+
+Maybe<EntryWrapper> nsComponentManagerImpl::LookupByContractID(
+ const MonitorAutoLock&, const nsACString& aContractID) {
+ if (const StaticModule* module =
+ StaticComponents::LookupByContractID(aContractID)) {
+ return Some(EntryWrapper(module));
+ }
+ if (nsFactoryEntry* entry = mContractIDs.Get(aContractID)) {
+ // UnregisterFactory might have left a stale nsFactoryEntry in
+ // mContractIDs, so we should check to see whether this entry has
+ // anything useful.
+ if (entry->mFactory || entry->mServiceObject) {
+ return Some(EntryWrapper(entry));
+ }
+ }
+ return Nothing();
+}
+
+already_AddRefed<nsIFactory> nsComponentManagerImpl::FindFactory(
+ const nsCID& aClass) {
+ Maybe<EntryWrapper> e = LookupByCID(aClass);
+ if (!e) {
+ return nullptr;
+ }
+
+ return e->GetFactory();
+}
+
+already_AddRefed<nsIFactory> nsComponentManagerImpl::FindFactory(
+ const char* aContractID, uint32_t aContractIDLen) {
+ Maybe<EntryWrapper> entry =
+ LookupByContractID(nsDependentCString(aContractID, aContractIDLen));
+ if (!entry) {
+ return nullptr;
+ }
+
+ return entry->GetFactory();
+}
+
+/**
+ * GetClassObject()
+ *
+ * Given a classID, this finds the singleton ClassObject that implements the
+ * CID. Returns an interface of type aIID off the singleton classobject.
+ */
+NS_IMETHODIMP
+nsComponentManagerImpl::GetClassObject(const nsCID& aClass, const nsIID& aIID,
+ void** aResult) {
+ nsresult rv;
+
+ if (MOZ_LOG_TEST(nsComponentManagerLog, LogLevel::Debug)) {
+ char buf[NSID_LENGTH];
+ aClass.ToProvidedString(buf);
+ PR_LogPrint("nsComponentManager: GetClassObject(%s)", buf);
+ }
+
+ MOZ_ASSERT(aResult != nullptr);
+
+ nsCOMPtr<nsIFactory> factory = FindFactory(aClass);
+ if (!factory) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ rv = factory->QueryInterface(aIID, aResult);
+
+ MOZ_LOG(
+ nsComponentManagerLog, LogLevel::Warning,
+ ("\t\tGetClassObject() %s", NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+
+ return rv;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetClassObjectByContractID(const char* aContractID,
+ const nsIID& aIID,
+ void** aResult) {
+ if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aContractID)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsresult rv;
+
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Debug,
+ ("nsComponentManager: GetClassObjectByContractID(%s)", aContractID));
+
+ nsCOMPtr<nsIFactory> factory = FindFactory(aContractID, strlen(aContractID));
+ if (!factory) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ rv = factory->QueryInterface(aIID, aResult);
+
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Warning,
+ ("\t\tGetClassObjectByContractID() %s",
+ NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+
+ return rv;
+}
+
+/**
+ * CreateInstance()
+ *
+ * Create an instance of an object that implements an interface and belongs
+ * to the implementation aClass using the factory. The factory is immediately
+ * released and not held onto for any longer.
+ */
+NS_IMETHODIMP
+nsComponentManagerImpl::CreateInstance(const nsCID& aClass, const nsIID& aIID,
+ void** aResult) {
+ // test this first, since there's no point in creating a component during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Creating new instance on shutdown. Denied.\n"
+ " CID: %s\n IID: %s\n",
+ AutoIDString(aClass).get(), AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ *aResult = nullptr;
+
+ Maybe<EntryWrapper> entry = LookupByCID(aClass);
+
+ if (!entry) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+#ifdef SHOW_CI_ON_EXISTING_SERVICE
+ if (entry->ServiceInstance()) {
+ nsAutoCString message;
+ message = "You are calling CreateInstance \""_ns + AutoIDString(aClass) +
+ "\" when a service for this CID already exists!"_ns;
+ NS_ERROR(message.get());
+ }
+#endif
+
+ nsresult rv;
+ nsCOMPtr<nsIFactory> factory = entry->GetFactory();
+ if (factory) {
+ rv = factory->CreateInstance(aIID, aResult);
+ if (NS_SUCCEEDED(rv) && !*aResult) {
+ NS_ERROR("Factory did not return an object but returned success!");
+ rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
+ }
+ } else {
+ // Translate error values
+ rv = NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ if (MOZ_LOG_TEST(nsComponentManagerLog, LogLevel::Warning)) {
+ char buf[NSID_LENGTH];
+ aClass.ToProvidedString(buf);
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Warning,
+ ("nsComponentManager: CreateInstance(%s) %s", buf,
+ NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+ }
+
+ return rv;
+}
+
+/**
+ * CreateInstanceByContractID()
+ *
+ * A variant of CreateInstance() that creates an instance of the object that
+ * implements the interface aIID and whose implementation has a contractID
+ * aContractID.
+ *
+ * This is only a convenience routine that turns around can calls the
+ * CreateInstance() with classid and iid.
+ */
+NS_IMETHODIMP
+nsComponentManagerImpl::CreateInstanceByContractID(const char* aContractID,
+ const nsIID& aIID,
+ void** aResult) {
+ if (NS_WARN_IF(!aContractID)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ // test this first, since there's no point in creating a component during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Creating new instance on shutdown. Denied.\n"
+ " ContractID: %s\n IID: %s\n",
+ aContractID, AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (!aResult) {
+ return NS_ERROR_NULL_POINTER;
+ }
+ *aResult = nullptr;
+
+ Maybe<EntryWrapper> entry =
+ LookupByContractID(nsDependentCString(aContractID));
+
+ if (!entry) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+#ifdef SHOW_CI_ON_EXISTING_SERVICE
+ if (entry->ServiceInstance()) {
+ nsAutoCString message;
+ message =
+ "You are calling CreateInstance \""_ns +
+ nsDependentCString(aContractID) +
+ nsLiteralCString(
+ "\" when a service for this CID already exists! "
+ "Add it to abusedContracts to track down the service consumer.");
+ NS_ERROR(message.get());
+ }
+#endif
+
+ nsresult rv;
+ nsCOMPtr<nsIFactory> factory = entry->GetFactory();
+ if (factory) {
+ rv = factory->CreateInstance(aIID, aResult);
+ if (NS_SUCCEEDED(rv) && !*aResult) {
+ NS_ERROR("Factory did not return an object but returned success!");
+ rv = NS_ERROR_SERVICE_NOT_AVAILABLE;
+ }
+ } else {
+ // Translate error values
+ rv = NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ MOZ_LOG(nsComponentManagerLog, LogLevel::Warning,
+ ("nsComponentManager: CreateInstanceByContractID(%s) %s", aContractID,
+ NS_SUCCEEDED(rv) ? "succeeded" : "FAILED"));
+
+ return rv;
+}
+
+nsresult nsComponentManagerImpl::FreeServices() {
+ NS_ASSERTION(gXPCOMShuttingDown,
+ "Must be shutting down in order to free all services");
+
+ if (!gXPCOMShuttingDown) {
+ return NS_ERROR_FAILURE;
+ }
+
+ for (nsFactoryEntry* entry : mFactories.Values()) {
+ entry->mFactory = nullptr;
+ entry->mServiceObject = nullptr;
+ }
+
+ for (const auto& module : gStaticModules) {
+ module.SetServiceInstance(nullptr);
+ }
+
+ return NS_OK;
+}
+
+// This should only ever be called within the monitor!
+nsComponentManagerImpl::PendingServiceInfo*
+nsComponentManagerImpl::AddPendingService(const nsCID& aServiceCID,
+ PRThread* aThread) {
+ PendingServiceInfo* newInfo = mPendingServices.AppendElement();
+ if (newInfo) {
+ newInfo->cid = &aServiceCID;
+ newInfo->thread = aThread;
+ }
+ return newInfo;
+}
+
+// This should only ever be called within the monitor!
+void nsComponentManagerImpl::RemovePendingService(MonitorAutoLock& aLock,
+ const nsCID& aServiceCID) {
+ uint32_t pendingCount = mPendingServices.Length();
+ for (uint32_t index = 0; index < pendingCount; ++index) {
+ const PendingServiceInfo& info = mPendingServices.ElementAt(index);
+ if (info.cid->Equals(aServiceCID)) {
+ mPendingServices.RemoveElementAt(index);
+ aLock.NotifyAll();
+ return;
+ }
+ }
+}
+
+// This should only ever be called within the monitor!
+PRThread* nsComponentManagerImpl::GetPendingServiceThread(
+ const nsCID& aServiceCID) const {
+ uint32_t pendingCount = mPendingServices.Length();
+ for (uint32_t index = 0; index < pendingCount; ++index) {
+ const PendingServiceInfo& info = mPendingServices.ElementAt(index);
+ if (info.cid->Equals(aServiceCID)) {
+ return info.thread;
+ }
+ }
+ return nullptr;
+}
+
+nsresult nsComponentManagerImpl::GetServiceLocked(Maybe<MonitorAutoLock>& aLock,
+ EntryWrapper& aEntry,
+ const nsIID& aIID,
+ void** aResult) {
+ MOZ_ASSERT(aLock.isSome());
+ if (!aLock.isSome()) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ if (auto* service = aEntry.ServiceInstance()) {
+ aLock.reset();
+ return service->QueryInterface(aIID, aResult);
+ }
+
+ PRThread* currentPRThread = PR_GetCurrentThread();
+ MOZ_ASSERT(currentPRThread, "This should never be null!");
+
+ PRThread* pendingPRThread;
+ while ((pendingPRThread = GetPendingServiceThread(aEntry.CID()))) {
+ if (pendingPRThread == currentPRThread) {
+ NS_ERROR("Recursive GetService!");
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ aLock->Wait();
+ }
+
+ // It's still possible that the other thread failed to create the
+ // service so we're not guaranteed to have an entry or service yet.
+ if (auto* service = aEntry.ServiceInstance()) {
+ aLock.reset();
+ return service->QueryInterface(aIID, aResult);
+ }
+
+ DebugOnly<PendingServiceInfo*> newInfo =
+ AddPendingService(aEntry.CID(), currentPRThread);
+ NS_ASSERTION(newInfo, "Failed to add info to the array!");
+
+ // We need to not be holding the service manager's lock while calling
+ // CreateInstance, because it invokes user code which could try to re-enter
+ // the service manager:
+
+ nsCOMPtr<nsISupports> service;
+ auto cleanup = MakeScopeExit([&]() {
+ // `service` must be released after the lock is released, so if we fail and
+ // still have a reference, release the lock before releasing it.
+ if (service) {
+ MOZ_ASSERT(aLock.isSome());
+ aLock.reset();
+ service = nullptr;
+ }
+ });
+ nsresult rv;
+ mLock.AssertCurrentThreadOwns();
+ {
+ MonitorAutoUnlock unlock(mLock);
+ AUTO_PROFILER_MARKER_TEXT(
+ "GetService", OTHER, MarkerStack::Capture(),
+ nsDependentCString(nsIDToCString(aEntry.CID()).get()));
+ rv = aEntry.CreateInstance(aIID, getter_AddRefs(service));
+ }
+ if (NS_SUCCEEDED(rv) && !service) {
+ NS_ERROR("Factory did not return an object but returned success");
+ return NS_ERROR_SERVICE_NOT_AVAILABLE;
+ }
+
+#ifdef DEBUG
+ pendingPRThread = GetPendingServiceThread(aEntry.CID());
+ MOZ_ASSERT(pendingPRThread == currentPRThread,
+ "Pending service array has been changed!");
+#endif
+ MOZ_ASSERT(aLock.isSome());
+ RemovePendingService(*aLock, aEntry.CID());
+
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ NS_ASSERTION(!aEntry.ServiceInstance(),
+ "Created two instances of a service!");
+
+ aEntry.SetServiceInstance(service.forget());
+
+ aLock.reset();
+
+ *aResult = do_AddRef(aEntry.ServiceInstance()).take();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetService(const nsCID& aClass, const nsIID& aIID,
+ void** aResult) {
+ // test this first, since there's no point in returning a service during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Getting service on shutdown. Denied.\n"
+ " CID: %s\n IID: %s\n",
+ AutoIDString(aClass).get(), AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ Maybe<MonitorAutoLock> lock(std::in_place, mLock);
+
+ Maybe<EntryWrapper> entry = LookupByCID(*lock, aClass);
+ if (!entry) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ return GetServiceLocked(lock, *entry, aIID, aResult);
+}
+
+nsresult nsComponentManagerImpl::GetService(ModuleID aId, const nsIID& aIID,
+ void** aResult) {
+ const auto& entry = gStaticModules[size_t(aId)];
+
+ // test this first, since there's no point in returning a service during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Getting service on shutdown. Denied.\n"
+ " CID: %s\n IID: %s\n",
+ AutoIDString(entry.CID()).get(), AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ Maybe<MonitorAutoLock> lock(std::in_place, mLock);
+
+ Maybe<EntryWrapper> wrapper;
+ if (entry.Overridable()) {
+ // If we expect this service to be overridden by test code, we need to look
+ // it up by contract ID every time.
+ wrapper = LookupByContractID(*lock, entry.ContractID());
+ if (!wrapper) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+ } else if (!entry.Active()) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ } else {
+ wrapper.emplace(&entry);
+ }
+ return GetServiceLocked(lock, *wrapper, aIID, aResult);
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::IsServiceInstantiated(const nsCID& aClass,
+ const nsIID& aIID,
+ bool* aResult) {
+ // Now we want to get the service if we already got it. If not, we don't want
+ // to create an instance of it. mmh!
+
+ // test this first, since there's no point in returning a service during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Checking for service on shutdown. Denied.\n"
+ " CID: %s\n IID: %s\n",
+ AutoIDString(aClass).get(), AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (Maybe<EntryWrapper> entry = LookupByCID(aClass)) {
+ if (auto* service = entry->ServiceInstance()) {
+ nsCOMPtr<nsISupports> instance;
+ nsresult rv = service->QueryInterface(aIID, getter_AddRefs(instance));
+ *aResult = (instance != nullptr);
+ return rv;
+ }
+ }
+
+ *aResult = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::IsServiceInstantiatedByContractID(
+ const char* aContractID, const nsIID& aIID, bool* aResult) {
+ // Now we want to get the service if we already got it. If not, we don't want
+ // to create an instance of it. mmh!
+
+ // test this first, since there's no point in returning a service during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Checking for service on shutdown. Denied.\n"
+ " ContractID: %s\n IID: %s\n",
+ aContractID, AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ if (Maybe<EntryWrapper> entry =
+ LookupByContractID(nsDependentCString(aContractID))) {
+ if (auto* service = entry->ServiceInstance()) {
+ nsCOMPtr<nsISupports> instance;
+ nsresult rv = service->QueryInterface(aIID, getter_AddRefs(instance));
+ *aResult = (instance != nullptr);
+ return rv;
+ }
+ }
+
+ *aResult = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetServiceByContractID(const char* aContractID,
+ const nsIID& aIID,
+ void** aResult) {
+ // test this first, since there's no point in returning a service during
+ // shutdown -- whether it's available or not would depend on the order it
+ // occurs in the list
+ if (gXPCOMShuttingDown) {
+ // When processing shutdown, don't process new GetService() requests
+#ifdef SHOW_DENIED_ON_SHUTDOWN
+ fprintf(stderr,
+ "Getting service on shutdown. Denied.\n"
+ " ContractID: %s\n IID: %s\n",
+ aContractID, AutoIDString(aIID).get());
+#endif /* SHOW_DENIED_ON_SHUTDOWN */
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ AUTO_PROFILER_LABEL_DYNAMIC_CSTR_NONSENSITIVE("GetServiceByContractID", OTHER,
+ aContractID);
+ Maybe<MonitorAutoLock> lock(std::in_place, mLock);
+
+ Maybe<EntryWrapper> entry =
+ LookupByContractID(*lock, nsDependentCString(aContractID));
+ if (!entry) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ return GetServiceLocked(lock, *entry, aIID, aResult);
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::RegisterFactory(const nsCID& aClass, const char* aName,
+ const char* aContractID,
+ nsIFactory* aFactory) {
+ if (!aFactory) {
+ // If a null factory is passed in, this call just wants to reset
+ // the contract ID to point to an existing CID entry.
+ if (!aContractID) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ nsDependentCString contractID(aContractID);
+
+ MonitorAutoLock lock(mLock);
+ nsFactoryEntry* oldf = mFactories.Get(&aClass);
+ if (oldf) {
+ StaticComponents::InvalidateContractID(contractID);
+ mContractIDs.InsertOrUpdate(contractID, oldf);
+ return NS_OK;
+ }
+
+ if (StaticComponents::LookupByCID(aClass)) {
+ // If this is the CID of a static module, just reset the invalid bit of
+ // the static entry for this contract ID, and assume it points to the
+ // correct class.
+ if (StaticComponents::InvalidateContractID(contractID, false)) {
+ mContractIDs.Remove(contractID);
+ return NS_OK;
+ }
+ }
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ auto f = MakeUnique<nsFactoryEntry>(aClass, aFactory);
+
+ MonitorAutoLock lock(mLock);
+ return mFactories.WithEntryHandle(&f->mCID, [&](auto&& entry) {
+ if (entry) {
+ return NS_ERROR_FACTORY_EXISTS;
+ }
+ if (StaticComponents::LookupByCID(f->mCID)) {
+ return NS_ERROR_FACTORY_EXISTS;
+ }
+ if (aContractID) {
+ nsDependentCString contractID(aContractID);
+ mContractIDs.InsertOrUpdate(contractID, f.get());
+ // We allow dynamically-registered contract IDs to override static
+ // entries, so invalidate any static entry for this contract ID.
+ StaticComponents::InvalidateContractID(contractID);
+ }
+ entry.Insert(f.release());
+
+ return NS_OK;
+ });
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::UnregisterFactory(const nsCID& aClass,
+ nsIFactory* aFactory) {
+ // Don't release the dying factory or service object until releasing
+ // the component manager monitor.
+ nsCOMPtr<nsIFactory> dyingFactory;
+ nsCOMPtr<nsISupports> dyingServiceObject;
+
+ {
+ MonitorAutoLock lock(mLock);
+ auto entry = mFactories.Lookup(&aClass);
+ nsFactoryEntry* f = entry ? entry.Data() : nullptr;
+ if (!f || f->mFactory != aFactory) {
+ // Note: We do not support unregistering static factories.
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ entry.Remove();
+
+ // This might leave a stale contractid -> factory mapping in
+ // place, so null out the factory entry (see
+ // nsFactoryEntry::GetFactory)
+ f->mFactory.swap(dyingFactory);
+ f->mServiceObject.swap(dyingServiceObject);
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::AutoRegister(nsIFile* aLocation) {
+ XRE_AddManifestLocation(NS_EXTENSION_LOCATION, aLocation);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::IsCIDRegistered(const nsCID& aClass, bool* aResult) {
+ *aResult = LookupByCID(aClass).isSome();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::IsContractIDRegistered(const char* aClass,
+ bool* aResult) {
+ if (NS_WARN_IF(!aClass)) {
+ return NS_ERROR_INVALID_ARG;
+ }
+
+ Maybe<EntryWrapper> entry = LookupByContractID(nsDependentCString(aClass));
+
+ *aResult = entry.isSome();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetContractIDs(nsTArray<nsCString>& aResult) {
+ aResult = ToTArray<nsTArray<nsCString>>(mContractIDs.Keys());
+
+ for (const auto& entry : gContractEntries) {
+ if (!entry.Invalid()) {
+ aResult.AppendElement(entry.ContractID());
+ }
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::ContractIDToCID(const char* aContractID,
+ nsCID** aResult) {
+ {
+ MonitorAutoLock lock(mLock);
+ Maybe<EntryWrapper> entry =
+ LookupByContractID(lock, nsDependentCString(aContractID));
+ if (entry) {
+ *aResult = (nsCID*)moz_xmalloc(sizeof(nsCID));
+ **aResult = entry->CID();
+ return NS_OK;
+ }
+ }
+ *aResult = nullptr;
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+}
+
+MOZ_DEFINE_MALLOC_SIZE_OF(ComponentManagerMallocSizeOf)
+
+NS_IMETHODIMP
+nsComponentManagerImpl::CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize) {
+ MOZ_COLLECT_REPORT("explicit/xpcom/component-manager", KIND_HEAP, UNITS_BYTES,
+ SizeOfIncludingThis(ComponentManagerMallocSizeOf),
+ "Memory used for the XPCOM component manager.");
+
+ return NS_OK;
+}
+
+size_t nsComponentManagerImpl::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) const {
+ size_t n = aMallocSizeOf(this);
+
+ n += mFactories.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (const auto& data : mFactories.Values()) {
+ n += data->SizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ n += mContractIDs.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (const auto& key : mContractIDs.Keys()) {
+ // We don't measure the nsFactoryEntry data because it's owned by
+ // mFactories (which is measured above).
+ n += key.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+ }
+
+ if (sModuleLocations) {
+ n += sModuleLocations->ShallowSizeOfIncludingThis(aMallocSizeOf);
+ }
+
+ n += mPendingServices.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
+ // Measurement of the following members may be added later if DMD finds it is
+ // worthwhile:
+ // - mMon
+ // - sModuleLocations' entries
+
+ return n;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsFactoryEntry
+////////////////////////////////////////////////////////////////////////////////
+
+nsFactoryEntry::nsFactoryEntry(const nsCID& aCID, nsIFactory* aFactory)
+ : mCID(aCID), mFactory(aFactory) {}
+
+already_AddRefed<nsIFactory> nsFactoryEntry::GetFactory() {
+ nsComponentManagerImpl::gComponentManager->mLock.AssertNotCurrentThreadOwns();
+
+ nsCOMPtr<nsIFactory> factory = mFactory;
+ return factory.forget();
+}
+
+nsresult nsFactoryEntry::CreateInstance(const nsIID& aIID, void** aResult) {
+ nsCOMPtr<nsIFactory> factory = GetFactory();
+ NS_ENSURE_TRUE(factory, NS_ERROR_FAILURE);
+ return factory->CreateInstance(aIID, aResult);
+}
+
+size_t nsFactoryEntry::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) {
+ size_t n = aMallocSizeOf(this);
+
+ // Measurement of the following members may be added later if DMD finds it is
+ // worthwhile:
+ // - mCID;
+ // - mFactory;
+ // - mServiceObject;
+
+ return n;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Static Access Functions
+////////////////////////////////////////////////////////////////////////////////
+
+nsresult NS_GetComponentManager(nsIComponentManager** aResult) {
+ if (!nsComponentManagerImpl::gComponentManager) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ NS_ADDREF(*aResult = nsComponentManagerImpl::gComponentManager);
+ return NS_OK;
+}
+
+nsresult NS_GetServiceManager(nsIServiceManager** aResult) {
+ if (!nsComponentManagerImpl::gComponentManager) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ NS_ADDREF(*aResult = nsComponentManagerImpl::gComponentManager);
+ return NS_OK;
+}
+
+nsresult NS_GetComponentRegistrar(nsIComponentRegistrar** aResult) {
+ if (!nsComponentManagerImpl::gComponentManager) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ NS_ADDREF(*aResult = nsComponentManagerImpl::gComponentManager);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::AddBootstrappedManifestLocation(nsIFile* aLocation) {
+ NS_ENSURE_ARG_POINTER(aLocation);
+
+ nsString path;
+ nsresult rv = aLocation->GetPath(path);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ if (Substring(path, path.Length() - 4).EqualsLiteral(".xpi")) {
+ return XRE_AddJarManifestLocation(NS_BOOTSTRAPPED_LOCATION, aLocation);
+ }
+
+ nsCOMPtr<nsIFile> manifest = CloneAndAppend(aLocation, "chrome.manifest"_ns);
+ return XRE_AddManifestLocation(NS_BOOTSTRAPPED_LOCATION, manifest);
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::RemoveBootstrappedManifestLocation(nsIFile* aLocation) {
+ NS_ENSURE_ARG_POINTER(aLocation);
+
+ nsCOMPtr<nsIChromeRegistry> cr = mozilla::services::GetChromeRegistry();
+ if (!cr) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsString path;
+ nsresult rv = aLocation->GetPath(path);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ nsComponentManagerImpl::ComponentLocation elem;
+ elem.type = NS_BOOTSTRAPPED_LOCATION;
+
+ if (Substring(path, path.Length() - 4).EqualsLiteral(".xpi")) {
+ elem.location.Init(aLocation, "chrome.manifest");
+ } else {
+ nsCOMPtr<nsIFile> lf = CloneAndAppend(aLocation, "chrome.manifest"_ns);
+ elem.location.Init(lf);
+ }
+
+ // Remove reference.
+ nsComponentManagerImpl::sModuleLocations->RemoveElement(
+ elem, ComponentLocationComparator());
+
+ rv = cr->CheckForNewChrome();
+ return rv;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetComponentJSMs(nsIUTF8StringEnumerator** aJSMs) {
+ nsCOMPtr<nsIUTF8StringEnumerator> result =
+ StaticComponents::GetComponentJSMs();
+ result.forget(aJSMs);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetComponentESModules(
+ nsIUTF8StringEnumerator** aESModules) {
+ nsCOMPtr<nsIUTF8StringEnumerator> result =
+ StaticComponents::GetComponentESModules();
+ result.forget(aESModules);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsComponentManagerImpl::GetManifestLocations(nsIArray** aLocations) {
+ NS_ENSURE_ARG_POINTER(aLocations);
+ *aLocations = nullptr;
+
+ if (!sModuleLocations) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ nsCOMPtr<nsIMutableArray> locations = nsArray::Create();
+ nsresult rv;
+ for (uint32_t i = 0; i < sModuleLocations->Length(); ++i) {
+ ComponentLocation& l = sModuleLocations->ElementAt(i);
+ FileLocation loc = l.location;
+ nsCString uriString;
+ loc.GetURIString(uriString);
+ nsCOMPtr<nsIURI> uri;
+ rv = NS_NewURI(getter_AddRefs(uri), uriString);
+ if (NS_SUCCEEDED(rv)) {
+ locations->AppendElement(uri);
+ }
+ }
+
+ locations.forget(aLocations);
+ return NS_OK;
+}
+
+EXPORT_XPCOM_API(nsresult)
+XRE_AddManifestLocation(NSLocationType aType, nsIFile* aLocation) {
+ nsComponentManagerImpl::InitializeModuleLocations();
+ nsComponentManagerImpl::ComponentLocation* c =
+ nsComponentManagerImpl::sModuleLocations->AppendElement();
+ c->type = aType;
+ c->location.Init(aLocation);
+
+ if (nsComponentManagerImpl::gComponentManager &&
+ nsComponentManagerImpl::NORMAL ==
+ nsComponentManagerImpl::gComponentManager->mStatus) {
+ nsComponentManagerImpl::gComponentManager->RegisterManifest(
+ aType, c->location, false);
+ }
+
+ return NS_OK;
+}
+
+EXPORT_XPCOM_API(nsresult)
+XRE_AddJarManifestLocation(NSLocationType aType, nsIFile* aLocation) {
+ nsComponentManagerImpl::InitializeModuleLocations();
+ nsComponentManagerImpl::ComponentLocation* c =
+ nsComponentManagerImpl::sModuleLocations->AppendElement();
+
+ c->type = aType;
+ c->location.Init(aLocation, "chrome.manifest");
+
+ if (nsComponentManagerImpl::gComponentManager &&
+ nsComponentManagerImpl::NORMAL ==
+ nsComponentManagerImpl::gComponentManager->mStatus) {
+ nsComponentManagerImpl::gComponentManager->RegisterManifest(
+ aType, c->location, false);
+ }
+
+ return NS_OK;
+}
+
+// Expose some important global interfaces to rust for the rust xpcom API. These
+// methods return a non-owning reference to the component manager, which should
+// live for the lifetime of XPCOM.
+extern "C" {
+
+const nsIComponentManager* Gecko_GetComponentManager() {
+ return nsComponentManagerImpl::gComponentManager;
+}
+
+const nsIServiceManager* Gecko_GetServiceManager() {
+ return nsComponentManagerImpl::gComponentManager;
+}
+
+const nsIComponentRegistrar* Gecko_GetComponentRegistrar() {
+ return nsComponentManagerImpl::gComponentManager;
+}
+
+// FFI-compatible version of `GetServiceHelper::operator()`.
+nsresult Gecko_GetServiceByModuleID(ModuleID aId, const nsIID* aIID,
+ void** aResult) {
+ return nsComponentManagerImpl::gComponentManager->GetService(aId, *aIID,
+ aResult);
+}
+
+// FFI-compatible version of `CreateInstanceHelper::operator()`.
+nsresult Gecko_CreateInstanceByModuleID(ModuleID aId, const nsIID* aIID,
+ void** aResult) {
+ const auto& entry = gStaticModules[size_t(aId)];
+ if (!entry.Active()) {
+ return NS_ERROR_FACTORY_NOT_REGISTERED;
+ }
+
+ nsresult rv = entry.CreateInstance(*aIID, aResult);
+ return rv;
+}
+}
diff --git a/xpcom/components/nsComponentManager.h b/xpcom/components/nsComponentManager.h
new file mode 100644
index 0000000000..5ad555b53b
--- /dev/null
+++ b/xpcom/components/nsComponentManager.h
@@ -0,0 +1,218 @@
+/* -*- 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/. */
+
+#ifndef nsComponentManager_h__
+#define nsComponentManager_h__
+
+#include "nsXPCOM.h"
+
+#include "nsIComponentManager.h"
+#include "nsIComponentRegistrar.h"
+#include "nsIMemoryReporter.h"
+#include "nsIServiceManager.h"
+#include "nsIFile.h"
+#include "mozilla/ArenaAllocator.h"
+#include "mozilla/Atomics.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/Module.h"
+#include "mozilla/Monitor.h"
+#include "mozilla/UniquePtr.h"
+#include "nsXULAppAPI.h"
+#include "nsIFactory.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "PLDHashTable.h"
+#include "prtime.h"
+#include "nsCOMPtr.h"
+#include "nsWeakReference.h"
+#include "nsCOMArray.h"
+#include "nsTHashMap.h"
+#include "nsInterfaceHashtable.h"
+#include "nsClassHashtable.h"
+#include "nsTArray.h"
+
+#include "mozilla/Components.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Omnijar.h"
+#include "mozilla/Attributes.h"
+
+struct nsFactoryEntry;
+struct PRThread;
+
+#define NS_COMPONENTMANAGER_CID \
+ { /* 91775d60-d5dc-11d2-92fb-00e09805570f */ \
+ 0x91775d60, 0xd5dc, 0x11d2, { \
+ 0x92, 0xfb, 0x00, 0xe0, 0x98, 0x05, 0x57, 0x0f \
+ } \
+ }
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+class EntryWrapper;
+} // namespace
+
+namespace mozilla {
+namespace xpcom {
+
+bool ProcessSelectorMatches(Module::ProcessSelector aSelector);
+bool FastProcessSelectorMatches(Module::ProcessSelector aSelector);
+
+} // namespace xpcom
+} // namespace mozilla
+
+class nsComponentManagerImpl final : public nsIComponentManager,
+ public nsIServiceManager,
+ public nsSupportsWeakReference,
+ public nsIComponentRegistrar,
+ public nsIInterfaceRequestor,
+ public nsIMemoryReporter {
+ public:
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIINTERFACEREQUESTOR
+ NS_DECL_NSICOMPONENTMANAGER
+ NS_DECL_NSICOMPONENTREGISTRAR
+ NS_DECL_NSIMEMORYREPORTER
+
+ static nsresult Create(REFNSIID aIID, void** aResult);
+
+ nsresult RegistryLocationForFile(nsIFile* aFile, nsCString& aResult);
+ nsresult FileForRegistryLocation(const nsCString& aLocation, nsIFile** aSpec);
+
+ NS_DECL_NSISERVICEMANAGER
+
+ // nsComponentManagerImpl methods:
+ nsComponentManagerImpl();
+
+ static nsComponentManagerImpl* gComponentManager;
+ nsresult Init();
+
+ nsresult Shutdown(void);
+
+ nsresult FreeServices();
+
+ already_AddRefed<nsIFactory> FindFactory(const nsCID& aClass);
+ already_AddRefed<nsIFactory> FindFactory(const char* aContractID,
+ uint32_t aContractIDLen);
+
+ already_AddRefed<nsIFactory> LoadFactory(nsFactoryEntry* aEntry);
+
+ nsTHashMap<nsIDPointerHashKey, nsFactoryEntry*> mFactories;
+ nsTHashMap<nsCStringHashKey, nsFactoryEntry*> mContractIDs;
+
+ mozilla::Monitor mLock MOZ_UNANNOTATED;
+
+ mozilla::Maybe<EntryWrapper> LookupByCID(const nsID& aCID);
+ mozilla::Maybe<EntryWrapper> LookupByCID(const mozilla::MonitorAutoLock&,
+ const nsID& aCID);
+
+ mozilla::Maybe<EntryWrapper> LookupByContractID(
+ const nsACString& aContractID);
+ mozilla::Maybe<EntryWrapper> LookupByContractID(
+ const mozilla::MonitorAutoLock&, const nsACString& aContractID);
+
+ nsresult GetService(mozilla::xpcom::ModuleID, const nsIID& aIID,
+ void** aResult);
+
+ static bool JSLoaderReady() { return gComponentManager->mJSLoaderReady; }
+
+ static void InitializeStaticModules();
+ static void InitializeModuleLocations();
+
+ struct ComponentLocation {
+ NSLocationType type;
+ mozilla::FileLocation location;
+ };
+
+ class ComponentLocationComparator {
+ public:
+ bool Equals(const ComponentLocation& aA,
+ const ComponentLocation& aB) const {
+ return (aA.type == aB.type && aA.location.Equals(aB.location));
+ }
+ };
+
+ static nsTArray<ComponentLocation>* sModuleLocations;
+
+ // Mutex not held
+ void RegisterManifest(NSLocationType aType, mozilla::FileLocation& aFile,
+ bool aChromeOnly);
+
+ struct ManifestProcessingContext {
+ ManifestProcessingContext(NSLocationType aType,
+ mozilla::FileLocation& aFile, bool aChromeOnly)
+ : mType(aType), mFile(aFile), mChromeOnly(aChromeOnly) {}
+
+ ~ManifestProcessingContext() = default;
+
+ NSLocationType mType;
+ mozilla::FileLocation mFile;
+ bool mChromeOnly;
+ };
+
+ void ManifestManifest(ManifestProcessingContext& aCx, int aLineNo,
+ char* const* aArgv);
+ void ManifestCategory(ManifestProcessingContext& aCx, int aLineNo,
+ char* const* aArgv);
+
+ void RereadChromeManifests(bool aChromeOnly = true);
+
+ // Shutdown
+ enum {
+ NOT_INITIALIZED,
+ NORMAL,
+ SHUTDOWN_IN_PROGRESS,
+ SHUTDOWN_COMPLETE
+ } mStatus;
+
+ struct PendingServiceInfo {
+ const nsCID* cid;
+ PRThread* thread;
+ };
+
+ inline PendingServiceInfo* AddPendingService(const nsCID& aServiceCID,
+ PRThread* aThread);
+ inline void RemovePendingService(mozilla::MonitorAutoLock& aLock,
+ const nsCID& aServiceCID);
+ inline PRThread* GetPendingServiceThread(const nsCID& aServiceCID) const;
+
+ nsTArray<PendingServiceInfo> mPendingServices;
+
+ bool mJSLoaderReady = false;
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+
+ private:
+ ~nsComponentManagerImpl();
+
+ nsresult GetServiceLocked(mozilla::Maybe<mozilla::MonitorAutoLock>& aLock,
+ EntryWrapper& aEntry, const nsIID& aIID,
+ void** aResult);
+};
+
+#define NS_MAX_FILENAME_LEN 1024
+
+#define NS_ERROR_IS_DIR NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_XPCOM, 24)
+
+struct nsFactoryEntry {
+ // nsIComponentRegistrar.registerFactory support
+ nsFactoryEntry(const nsCID& aClass, nsIFactory* aFactory);
+
+ ~nsFactoryEntry() = default;
+
+ already_AddRefed<nsIFactory> GetFactory();
+
+ nsresult CreateInstance(const nsIID& aIID, void** aResult);
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
+
+ const nsCID mCID;
+
+ nsCOMPtr<nsIFactory> mFactory;
+ nsCOMPtr<nsISupports> mServiceObject;
+};
+
+#endif // nsComponentManager_h__
diff --git a/xpcom/components/nsComponentManagerUtils.cpp b/xpcom/components/nsComponentManagerUtils.cpp
new file mode 100644
index 0000000000..1977e4b3dd
--- /dev/null
+++ b/xpcom/components/nsComponentManagerUtils.cpp
@@ -0,0 +1,259 @@
+/* -*- 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/. */
+
+#ifndef nsXPCOM_h__
+# include "nsXPCOM.h"
+#endif
+
+#ifndef nsCOMPtr_h__
+# include "nsCOMPtr.h"
+#endif
+
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+
+#include "nsIComponentManager.h"
+
+#ifndef MOZILLA_INTERNAL_API
+
+nsresult CallGetService(const nsCID& aCID, const nsIID& aIID, void** aResult) {
+ nsCOMPtr<nsIServiceManager> servMgr;
+ nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));
+ if (servMgr) {
+ status = servMgr->GetService(aCID, aIID, aResult);
+ }
+ return status;
+}
+
+nsresult CallGetService(const char* aContractID, const nsIID& aIID,
+ void** aResult) {
+ nsCOMPtr<nsIServiceManager> servMgr;
+ nsresult status = NS_GetServiceManager(getter_AddRefs(servMgr));
+ if (servMgr) {
+ status = servMgr->GetServiceByContractID(aContractID, aIID, aResult);
+ }
+ return status;
+}
+
+#else
+
+# include "nsComponentManager.h"
+
+nsresult CallGetService(const nsCID& aCID, const nsIID& aIID, void** aResult) {
+ nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
+ if (!compMgr) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ return compMgr->nsComponentManagerImpl::GetService(aCID, aIID, aResult);
+}
+
+nsresult CallGetService(const char* aContractID, const nsIID& aIID,
+ void** aResult) {
+ nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
+ if (!compMgr) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ return compMgr->nsComponentManagerImpl::GetServiceByContractID(aContractID,
+ aIID, aResult);
+}
+
+#endif
+
+#ifndef MOZILLA_INTERNAL_API
+
+nsresult CallCreateInstance(const nsCID& aCID, const nsIID& aIID,
+ void** aResult) {
+ nsCOMPtr<nsIComponentManager> compMgr;
+ nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
+ if (compMgr) {
+ status = compMgr->CreateInstance(aCID, aIID, aResult);
+ }
+ return status;
+}
+
+nsresult CallCreateInstance(const char* aContractID, const nsIID& aIID,
+ void** aResult) {
+ nsCOMPtr<nsIComponentManager> compMgr;
+ nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
+ if (compMgr)
+ status = compMgr->CreateInstanceByContractID(aContractID, aIID, aResult);
+ return status;
+}
+
+nsresult CallGetClassObject(const nsCID& aCID, const nsIID& aIID,
+ void** aResult) {
+ nsCOMPtr<nsIComponentManager> compMgr;
+ nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
+ if (compMgr) {
+ status = compMgr->GetClassObject(aCID, aIID, aResult);
+ }
+ return status;
+}
+
+nsresult CallGetClassObject(const char* aContractID, const nsIID& aIID,
+ void** aResult) {
+ nsCOMPtr<nsIComponentManager> compMgr;
+ nsresult status = NS_GetComponentManager(getter_AddRefs(compMgr));
+ if (compMgr)
+ status = compMgr->GetClassObjectByContractID(aContractID, aIID, aResult);
+ return status;
+}
+
+#else
+
+# include "nsComponentManager.h"
+
+nsresult CallCreateInstance(const nsCID& aCID, const nsIID& aIID,
+ void** aResult) {
+ nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
+ if (NS_WARN_IF(!compMgr)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ return compMgr->nsComponentManagerImpl::CreateInstance(aCID, aIID, aResult);
+}
+
+nsresult CallCreateInstance(const char* aContractID, const nsIID& aIID,
+ void** aResult) {
+ nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
+ if (NS_WARN_IF(!compMgr)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ return compMgr->nsComponentManagerImpl::CreateInstanceByContractID(
+ aContractID, aIID, aResult);
+}
+
+nsresult CallGetClassObject(const nsCID& aCID, const nsIID& aIID,
+ void** aResult) {
+ nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
+ if (NS_WARN_IF(!compMgr)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ return compMgr->nsComponentManagerImpl::GetClassObject(aCID, aIID, aResult);
+}
+
+nsresult CallGetClassObject(const char* aContractID, const nsIID& aIID,
+ void** aResult) {
+ nsComponentManagerImpl* compMgr = nsComponentManagerImpl::gComponentManager;
+ if (NS_WARN_IF(!compMgr)) {
+ return NS_ERROR_NOT_INITIALIZED;
+ }
+
+ return compMgr->nsComponentManagerImpl::GetClassObjectByContractID(
+ aContractID, aIID, aResult);
+}
+
+#endif
+
+nsresult nsCreateInstanceByCID::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallCreateInstance(mCID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
+
+nsresult nsCreateInstanceByContractID::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallCreateInstance(mContractID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
+
+nsresult nsCreateInstanceFromFactory::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = mFactory->CreateInstance(aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
+
+nsresult nsGetClassObjectByCID::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallGetClassObject(mCID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
+
+nsresult nsGetClassObjectByContractID::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallGetClassObject(mContractID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
+
+nsresult nsGetServiceByCID::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallGetService(mCID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+
+ return status;
+}
+
+nsresult nsGetServiceByCIDWithError::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallGetService(mCID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
+
+nsresult nsGetServiceByContractID::operator()(const nsIID& aIID,
+ void** aInstancePtr) const {
+ nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+
+ return status;
+}
+
+nsresult nsGetServiceByContractIDWithError::operator()(
+ const nsIID& aIID, void** aInstancePtr) const {
+ nsresult status = CallGetService(mContractID, aIID, aInstancePtr);
+ if (NS_FAILED(status)) {
+ *aInstancePtr = 0;
+ }
+
+ if (mErrorPtr) {
+ *mErrorPtr = status;
+ }
+ return status;
+}
diff --git a/xpcom/components/nsComponentManagerUtils.h b/xpcom/components/nsComponentManagerUtils.h
new file mode 100644
index 0000000000..b6f15aabaa
--- /dev/null
+++ b/xpcom/components/nsComponentManagerUtils.h
@@ -0,0 +1,170 @@
+/* -*- 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/. */
+
+#ifndef nsComponentManagerUtils_h__
+#define nsComponentManagerUtils_h__
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+
+#include "nsIFactory.h"
+
+nsresult CallCreateInstance(const nsCID& aCID, const nsIID& aIID,
+ void** aResult);
+
+nsresult CallCreateInstance(const char* aContractID, const nsIID& aIID,
+ void** aResult);
+
+nsresult CallGetClassObject(const nsCID& aCID, const nsIID& aIID,
+ void** aResult);
+
+nsresult CallGetClassObject(const char* aContractID, const nsIID& aIID,
+ void** aResult);
+
+class MOZ_STACK_CLASS nsCreateInstanceByCID final : public nsCOMPtr_helper {
+ public:
+ nsCreateInstanceByCID(const nsCID& aCID, nsresult* aErrorPtr)
+ : mCID(aCID), mErrorPtr(aErrorPtr) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
+
+ private:
+ const nsCID& mCID;
+ nsresult* mErrorPtr;
+};
+
+class MOZ_STACK_CLASS nsCreateInstanceByContractID final
+ : public nsCOMPtr_helper {
+ public:
+ nsCreateInstanceByContractID(const char* aContractID, nsresult* aErrorPtr)
+ : mContractID(aContractID), mErrorPtr(aErrorPtr) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
+
+ private:
+ const char* mContractID;
+ nsresult* mErrorPtr;
+};
+
+class MOZ_STACK_CLASS nsCreateInstanceFromFactory final
+ : public nsCOMPtr_helper {
+ public:
+ nsCreateInstanceFromFactory(nsIFactory* aFactory, nsresult* aErrorPtr)
+ : mFactory(aFactory), mErrorPtr(aErrorPtr) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
+
+ private:
+ nsIFactory* MOZ_NON_OWNING_REF mFactory;
+ nsresult* mErrorPtr;
+};
+
+inline const nsCreateInstanceByCID do_CreateInstance(const nsCID& aCID,
+ nsresult* aError = 0) {
+ return nsCreateInstanceByCID(aCID, aError);
+}
+
+inline const nsCreateInstanceByContractID do_CreateInstance(
+ const char* aContractID, nsresult* aError = 0) {
+ return nsCreateInstanceByContractID(aContractID, aError);
+}
+
+inline const nsCreateInstanceFromFactory do_CreateInstance(
+ nsIFactory* aFactory, nsresult* aError = 0) {
+ return nsCreateInstanceFromFactory(aFactory, aError);
+}
+
+class MOZ_STACK_CLASS nsGetClassObjectByCID final : public nsCOMPtr_helper {
+ public:
+ nsGetClassObjectByCID(const nsCID& aCID, nsresult* aErrorPtr)
+ : mCID(aCID), mErrorPtr(aErrorPtr) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
+
+ private:
+ const nsCID& mCID;
+ nsresult* mErrorPtr;
+};
+
+class MOZ_STACK_CLASS nsGetClassObjectByContractID final
+ : public nsCOMPtr_helper {
+ public:
+ nsGetClassObjectByContractID(const char* aContractID, nsresult* aErrorPtr)
+ : mContractID(aContractID), mErrorPtr(aErrorPtr) {}
+
+ virtual nsresult NS_FASTCALL operator()(const nsIID&, void**) const override;
+
+ private:
+ const char* mContractID;
+ nsresult* mErrorPtr;
+};
+
+/**
+ * do_GetClassObject can be used to improve performance of callers
+ * that call |CreateInstance| many times. They can cache the factory
+ * and call do_CreateInstance or CallCreateInstance with the cached
+ * factory rather than having the component manager retrieve it every
+ * time.
+ */
+inline const nsGetClassObjectByCID do_GetClassObject(const nsCID& aCID,
+ nsresult* aError = 0) {
+ return nsGetClassObjectByCID(aCID, aError);
+}
+
+inline const nsGetClassObjectByContractID do_GetClassObject(
+ const char* aContractID, nsresult* aError = 0) {
+ return nsGetClassObjectByContractID(aContractID, aError);
+}
+
+// type-safe shortcuts for calling |CreateInstance|
+template <class DestinationType>
+inline nsresult CallCreateInstance(const nsCID& aClass,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return CallCreateInstance(aClass, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+template <class DestinationType>
+inline nsresult CallCreateInstance(const char* aContractID,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aContractID, "null parameter");
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return CallCreateInstance(aContractID, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+template <class DestinationType>
+inline nsresult CallCreateInstance(nsIFactory* aFactory,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aFactory, "null parameter");
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return aFactory->CreateInstance(nullptr, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+template <class DestinationType>
+inline nsresult CallGetClassObject(const nsCID& aClass,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return CallGetClassObject(aClass, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+template <class DestinationType>
+inline nsresult CallGetClassObject(const char* aContractID,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return CallGetClassObject(aContractID, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+#endif /* nsComponentManagerUtils_h__ */
diff --git a/xpcom/components/nsICategoryManager.idl b/xpcom/components/nsICategoryManager.idl
new file mode 100644
index 0000000000..12c1a9e4a9
--- /dev/null
+++ b/xpcom/components/nsICategoryManager.idl
@@ -0,0 +1,137 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "nsISupports.idl"
+#include "nsISupportsPrimitives.idl"
+
+interface nsISimpleEnumerator;
+
+%{C++
+#include "nsString.h"
+%}
+
+/*
+ * nsICategoryManager
+ */
+
+[scriptable, builtinclass, uuid(de021d54-57a3-4025-ae63-4c8eedbe74c0)]
+interface nsICategoryEntry : nsISupportsCString
+{
+ readonly attribute ACString entry;
+
+ readonly attribute ACString value;
+};
+
+[builtinclass, scriptable, uuid(3275b2cd-af6d-429a-80d7-f0c5120342ac)]
+interface nsICategoryManager : nsISupports
+{
+ /**
+ * Get the value for the given category's entry.
+ * @param aCategory The name of the category ("protocol")
+ * @param aEntry The entry you're looking for ("http")
+ * @return The value.
+ */
+ ACString getCategoryEntry(in ACString aCategory, in ACString aEntry);
+
+ /**
+ * Add an entry to a category.
+ * @param aCategory The name of the category ("protocol")
+ * @param aEntry The entry to be added ("http")
+ * @param aValue The value for the entry ("moz.httprulez.1")
+ * @param aPersist Should this data persist between invocations?
+ * @param aReplace Should we replace an existing entry?
+ * @return Previous entry, if any
+ */
+ ACString addCategoryEntry(in ACString aCategory, in ACString aEntry,
+ in ACString aValue, in boolean aPersist,
+ in boolean aReplace);
+
+ /**
+ * Delete an entry from the category.
+ * @param aCategory The name of the category ("protocol")
+ * @param aEntry The entry to be added ("http")
+ * @param aPersist Delete persistent data from registry, if present?
+ */
+ void deleteCategoryEntry(in ACString aCategory, in ACString aEntry,
+ in boolean aPersist);
+
+ /**
+ * Delete a category and all entries.
+ * @param aCategory The category to be deleted.
+ */
+ void deleteCategory(in ACString aCategory);
+
+ /**
+ * Enumerate the entries in a category.
+ * @param aCategory The category to be enumerated.
+ * @return a simple enumerator, each result QIs to
+ * nsICategoryEntry.
+ */
+ nsISimpleEnumerator enumerateCategory(in ACString aCategory);
+
+
+ /**
+ * Enumerate all existing categories
+ * @param aCategory The category to be enumerated.
+ * @return a simple enumerator, each result QIs to
+ * nsISupportsCString.
+ */
+ nsISimpleEnumerator enumerateCategories();
+
+ %{C++
+ template<size_t N>
+ nsresult
+ GetCategoryEntry(const char (&aCategory)[N], const nsACString& aEntry,
+ nsACString& aResult)
+ {
+ return GetCategoryEntry(nsLiteralCString(aCategory),
+ aEntry, aResult);
+ }
+
+ template<size_t N, size_t M>
+ nsresult
+ GetCategoryEntry(const char (&aCategory)[N], const char (&aEntry)[M],
+ nsACString& aResult)
+ {
+ return GetCategoryEntry(nsLiteralCString(aCategory),
+ nsLiteralCString(aEntry),
+ aResult);
+ }
+
+ nsresult
+ AddCategoryEntry(const nsACString& aCategory, const nsACString& aEntry,
+ const nsACString& aValue, bool aPersist, bool aReplace)
+ {
+ nsCString oldValue;
+ return AddCategoryEntry(aCategory, aEntry, aValue, aPersist, aReplace,
+ oldValue);
+ }
+
+ template<size_t N>
+ nsresult
+ AddCategoryEntry(const char (&aCategory)[N], const nsACString& aEntry,
+ const nsACString& aValue, bool aPersist, bool aReplace)
+ {
+ nsCString oldValue;
+ return AddCategoryEntry(nsLiteralCString(aCategory), aEntry, aValue,
+ aPersist, aReplace, oldValue);
+ }
+
+ template<size_t N>
+ nsresult
+ DeleteCategoryEntry(const char (&aCategory)[N], const nsACString& aEntry, bool aPersist)
+ {
+ return DeleteCategoryEntry(nsLiteralCString(aCategory), aEntry, aPersist);
+ }
+
+
+ template<size_t N>
+ nsresult
+ EnumerateCategory(const char (&aCategory)[N], nsISimpleEnumerator** aResult)
+ {
+ return EnumerateCategory(nsLiteralCString(aCategory), aResult);
+ }
+ %}
+};
diff --git a/xpcom/components/nsIClassInfo.idl b/xpcom/components/nsIClassInfo.idl
new file mode 100644
index 0000000000..1ebef34ecf
--- /dev/null
+++ b/xpcom/components/nsIClassInfo.idl
@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * 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 "nsISupports.idl"
+
+interface nsIXPCScriptable;
+
+/**
+ * Provides information about a specific implementation class. If you want
+ * your class to implement nsIClassInfo, see nsIClassInfoImpl.h for
+ * instructions--you most likely do not want to inherit from nsIClassInfo.
+ */
+
+[scriptable, uuid(a60569d7-d401-4677-ba63-2aa5971af25d)]
+interface nsIClassInfo : nsISupports
+{
+ /**
+ * Returns a list of the interfaces which instances of this class promise
+ * to implement. Note that nsISupports is an implicit member of any such
+ * list, and need not be included.
+ */
+ readonly attribute Array<nsIIDRef> interfaces;
+
+ /**
+ * Return an object to assist XPConnect in supplying JavaScript-specific
+ * behavior to callers of the instance object, or null if not needed.
+ */
+ nsIXPCScriptable getScriptableHelper();
+
+ /**
+ * A contract ID through which an instance of this class can be created
+ * (or accessed as a service, if |flags & SINGLETON|), or null/void.
+ */
+ readonly attribute AUTF8String contractID;
+
+ /**
+ * A human readable string naming the class, or null/void.
+ */
+ readonly attribute AUTF8String classDescription;
+
+ /**
+ * A class ID through which an instance of this class can be created
+ * (or accessed as a service, if |flags & SINGLETON|), or null.
+ */
+ readonly attribute nsCIDPtr classID;
+
+ /**
+ * Bitflags for 'flags' attribute.
+ */
+ const uint32_t SINGLETON = 1 << 0;
+ const uint32_t THREADSAFE = 1 << 1;
+ const uint32_t SINGLETON_CLASSINFO = 1 << 5;
+
+ // The high order bit is RESERVED for consumers of these flags.
+ // No implementor of this interface should ever return flags
+ // with this bit set.
+ const uint32_t RESERVED = 1 << 31;
+
+
+ readonly attribute uint32_t flags;
+
+ /**
+ * Also a class ID through which an instance of this class can be created
+ * (or accessed as a service, if |flags & SINGLETON|). If the class does
+ * not have a CID, it should return NS_ERROR_NOT_AVAILABLE. This attribute
+ * exists so C++ callers can avoid allocating and freeing a CID, as would
+ * happen if they used classID.
+ */
+ [noscript] readonly attribute nsCID classIDNoAlloc;
+
+};
diff --git a/xpcom/components/nsIComponentManager.idl b/xpcom/components/nsIComponentManager.idl
new file mode 100644
index 0000000000..9abde9960c
--- /dev/null
+++ b/xpcom/components/nsIComponentManager.idl
@@ -0,0 +1,117 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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/. */
+
+/**
+ * The nsIComponentManager interface.
+ */
+
+#include "nsISupports.idl"
+
+interface nsIFile;
+interface nsIFactory;
+interface nsIArray;
+interface nsIUTF8StringEnumerator;
+
+[scriptable, builtinclass, uuid(d604ffc3-1ba3-4f6c-b65f-1ed4199364c3)]
+interface nsIComponentManager : nsISupports
+{
+ /**
+ * getClassObject
+ *
+ * Returns the factory object that can be used to create instances of
+ * CID aClass
+ *
+ * @param aClass The classid of the factory that is being requested
+ */
+ void getClassObject(in nsCIDRef aClass,
+ in nsIIDRef aIID,
+ [iid_is(aIID),retval] out nsQIResult result);
+
+ /**
+ * getClassObjectByContractID
+ *
+ * Returns the factory object that can be used to create instances of
+ * CID aClass
+ *
+ * @param aClass The classid of the factory that is being requested
+ */
+ void getClassObjectByContractID(in string aContractID,
+ in nsIIDRef aIID,
+ [iid_is(aIID),retval] out nsQIResult result);
+
+
+ /**
+ * createInstance
+ *
+ * Create an instance of the CID aClass and return the interface aIID.
+ *
+ * @param aClass : ClassID of object instance requested
+ * @param aIID : IID of interface requested
+ */
+ [noscript]
+ void createInstance(in nsCIDRef aClass,
+ in nsIIDRef aIID,
+ [iid_is(aIID),retval] out nsQIResult result);
+
+ /**
+ * createInstanceByContractID
+ *
+ * Create an instance of the CID that implements aContractID and return the
+ * interface aIID.
+ *
+ * @param aContractID : aContractID of object instance requested
+ * @param aIID : IID of interface requested
+ */
+ [noscript]
+ void createInstanceByContractID(in string aContractID,
+ in nsIIDRef aIID,
+ [iid_is(aIID),retval] out nsQIResult result);
+
+ /**
+ * addBootstrappedManifestLocation
+ *
+ * Adds a bootstrapped manifest location on runtime.
+ *
+ * @param aLocation : A directory where chrome.manifest resides,
+ * or an XPI with it on the root.
+ */
+ void addBootstrappedManifestLocation(in nsIFile aLocation);
+
+ /**
+ * removeBootstrappedManifestLocation
+ *
+ * Removes a bootstrapped manifest location on runtime.
+ *
+ * @param aLocation : A directory where chrome.manifest resides,
+ * or an XPI with it on the root.
+ */
+ void removeBootstrappedManifestLocation(in nsIFile aLocation);
+
+ /**
+ * getManifestLocations
+ *
+ * Get an array of nsIURIs of all registered and builtin manifest locations.
+ */
+ nsIArray getManifestLocations();
+
+ /**
+ * Returns a list of JSM URLs which are used to create components. This
+ * should only be used in automation.
+ */
+ nsIUTF8StringEnumerator getComponentJSMs();
+
+ /**
+ * Returns a list of ESM URLs which are used to create components. This
+ * should only be used in automation.
+ */
+ nsIUTF8StringEnumerator getComponentESModules();
+};
+
+
+%{ C++
+#ifdef MOZILLA_INTERNAL_API
+#include "nsComponentManagerUtils.h"
+#endif
+%} C++
diff --git a/xpcom/components/nsIComponentRegistrar.idl b/xpcom/components/nsIComponentRegistrar.idl
new file mode 100644
index 0000000000..6b85caffab
--- /dev/null
+++ b/xpcom/components/nsIComponentRegistrar.idl
@@ -0,0 +1,100 @@
+/* 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/. */
+
+/**
+ * The nsIComponentRegistrar interface.
+ */
+
+#include "nsISupports.idl"
+
+interface nsIFile;
+interface nsIFactory;
+
+[builtinclass, scriptable, uuid(2417cbfe-65ad-48a6-b4b6-eb84db174392)]
+interface nsIComponentRegistrar : nsISupports
+{
+ /**
+ * autoRegister
+ *
+ * Register a .manifest file, or an entire directory containing
+ * these files. Registration lasts for this run only, and is not cached.
+ *
+ * @note Formerly this method would register component files directly. This
+ * is no longer supported.
+ */
+ void autoRegister(in nsIFile aSpec);
+
+ /**
+ * registerFactory
+ *
+ * Register a factory with a given ContractID, CID and Class Name.
+ *
+ * @param aClass : CID of object
+ * @param aClassName : Class Name of CID (unused)
+ * @param aContractID : ContractID associated with CID aClass. May be null
+ * if no contract ID is needed.
+ * @param aFactory : Factory that will be registered for CID aClass.
+ * If aFactory is null, the contract will be associated
+ * with a previously registered CID.
+ */
+ void registerFactory(in nsCIDRef aClass,
+ in string aClassName,
+ in string aContractID,
+ in nsIFactory aFactory);
+
+ /**
+ * unregisterFactory
+ *
+ * Unregister a factory associated with CID aClass.
+ *
+ * @param aClass : CID being unregistered
+ * @param aFactory : Factory previously registered to create instances of
+ * CID aClass.
+ *
+ * @throws NS_ERROR* Method failure.
+ */
+ void unregisterFactory(in nsCIDRef aClass,
+ in nsIFactory aFactory);
+
+ /**
+ * isCIDRegistered
+ *
+ * Returns true if a factory is registered for the CID.
+ *
+ * @param aClass : CID queried for registeration
+ * @return : true if a factory is registered for CID
+ * false otherwise.
+ */
+ boolean isCIDRegistered(in nsCIDRef aClass);
+
+ /**
+ * isContractIDRegistered
+ *
+ * Returns true if a factory is registered for the contract id.
+ *
+ * @param aClass : contract id queried for registeration
+ * @return : true if a factory is registered for contract id
+ * false otherwise.
+ */
+ boolean isContractIDRegistered(in string aContractID);
+
+ /**
+ * getContractIDs
+ *
+ * Return the list of all registered ContractIDs.
+ *
+ * @return : Array of ContractIDs. Elements of the array are the string
+ * encoding of Contract IDs.
+ */
+ Array<ACString> getContractIDs();
+
+ /**
+ * contractIDToCID
+ *
+ * Returns the CID for a given Contract ID, if one exists and is registered.
+ *
+ * @return : Contract ID.
+ */
+ nsCIDPtr contractIDToCID(in string aContractID);
+};
diff --git a/xpcom/components/nsIFactory.idl b/xpcom/components/nsIFactory.idl
new file mode 100644
index 0000000000..e0b3e6e756
--- /dev/null
+++ b/xpcom/components/nsIFactory.idl
@@ -0,0 +1,27 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "nsISupports.idl"
+
+/**
+ * A class factory allows the creation of nsISupports derived
+ * components without specifying a concrete base class.
+ */
+
+[scriptable, object, uuid(1bb40a56-9223-41e6-97d4-da97bdeb6a4d)]
+interface nsIFactory : nsISupports {
+ /**
+ * Creates an instance of a component.
+ *
+ * @param iid The IID of the interface being requested in
+ * the component which is being currently created.
+ * @param result [out] Pointer to the newly created instance, if successful.
+ * @throws NS_NOINTERFACE - Interface not accessible.
+ * NS_ERROR* - Method failure.
+ */
+ void createInstance(in nsIIDRef iid,
+ [retval, iid_is(iid)] out nsQIResult result);
+
+};
diff --git a/xpcom/components/nsIServiceManager.idl b/xpcom/components/nsIServiceManager.idl
new file mode 100644
index 0000000000..dd613070e9
--- /dev/null
+++ b/xpcom/components/nsIServiceManager.idl
@@ -0,0 +1,70 @@
+/* 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 "nsISupports.idl"
+
+/**
+ * The nsIServiceManager manager interface provides a means to obtain
+ * global services in an application. The service manager depends on the
+ * repository to find and instantiate factories to obtain services.
+ *
+ * Users of the service manager must first obtain a pointer to the global
+ * service manager by calling NS_GetServiceManager. After that,
+ * they can request specific services by calling GetService. When they are
+ * finished they can NS_RELEASE() the service as usual.
+ *
+ * A user of a service may keep references to particular services indefinitely
+ * and only must call Release when it shuts down.
+ */
+
+[builtinclass, scriptable, uuid(8bb35ed9-e332-462d-9155-4a002ab5c958)]
+interface nsIServiceManager : nsISupports
+{
+ /**
+ * getServiceByContractID
+ *
+ * Returns the instance that implements aClass or aContractID and the
+ * interface aIID. This may result in the instance being created.
+ *
+ * @param aClass or aContractID : aClass or aContractID of object
+ * instance requested
+ * @param aIID : IID of interface requested
+ * @param result : resulting service
+ */
+ void getService(in nsCIDRef aClass,
+ in nsIIDRef aIID,
+ [iid_is(aIID),retval] out nsQIResult result);
+
+ void getServiceByContractID(in string aContractID,
+ in nsIIDRef aIID,
+ [iid_is(aIID),retval] out nsQIResult result);
+
+ /**
+ * isServiceInstantiated
+ *
+ * isServiceInstantiated will return a true if the service has already
+ * been created, or false otherwise. Throws if the service does not
+ * implement the given IID.
+ *
+ * @param aClass or aContractID : aClass or aContractID of object
+ * instance requested
+ * @param aIID : IID of interface requested
+ * @throws NS_NOINTERFACE if the IID given isn't supported by the object
+ */
+ boolean isServiceInstantiated(in nsCIDRef aClass, in nsIIDRef aIID);
+ boolean isServiceInstantiatedByContractID(in string aContractID, in nsIIDRef aIID);
+};
+
+
+%{C++
+// Observing xpcom autoregistration. Topics will be 'start' and 'stop'.
+#define NS_XPCOM_AUTOREGISTRATION_OBSERVER_ID "xpcom-autoregistration"
+
+#ifdef MOZILLA_INTERNAL_API
+#include "nsXPCOM.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#endif
+%}
diff --git a/xpcom/components/nsServiceManagerUtils.h b/xpcom/components/nsServiceManagerUtils.h
new file mode 100644
index 0000000000..4bfbc804cc
--- /dev/null
+++ b/xpcom/components/nsServiceManagerUtils.h
@@ -0,0 +1,56 @@
+/* -*- 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/. */
+
+#ifndef nsServiceManagerUtils_h__
+#define nsServiceManagerUtils_h__
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+inline nsGetServiceByCID do_GetService(const nsCID& aCID) {
+ return nsGetServiceByCID(aCID);
+}
+
+inline nsGetServiceByCIDWithError do_GetService(const nsCID& aCID,
+ nsresult* aError) {
+ return nsGetServiceByCIDWithError(aCID, aError);
+}
+
+inline nsGetServiceByContractID do_GetService(const char* aContractID) {
+ return nsGetServiceByContractID(aContractID);
+}
+
+inline nsGetServiceByContractIDWithError do_GetService(const char* aContractID,
+ nsresult* aError) {
+ return nsGetServiceByContractIDWithError(aContractID, aError);
+}
+
+nsresult CallGetService(const nsCID& aClass, const nsIID& aIID, void** aResult);
+
+nsresult CallGetService(const char* aContractID, const nsIID& aIID,
+ void** aResult);
+
+// type-safe shortcuts for calling |GetService|
+template <class DestinationType>
+inline nsresult CallGetService(const nsCID& aClass,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return CallGetService(aClass, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+template <class DestinationType>
+inline nsresult CallGetService(const char* aContractID,
+ DestinationType** aDestination) {
+ MOZ_ASSERT(aContractID, "null parameter");
+ MOZ_ASSERT(aDestination, "null parameter");
+
+ return CallGetService(aContractID, NS_GET_TEMPLATE_IID(DestinationType),
+ reinterpret_cast<void**>(aDestination));
+}
+
+#endif
diff --git a/xpcom/components/test/python.ini b/xpcom/components/test/python.ini
new file mode 100644
index 0000000000..9792769c24
--- /dev/null
+++ b/xpcom/components/test/python.ini
@@ -0,0 +1,4 @@
+[DEFAULT]
+subsuite = xpcom
+
+[test_gen_static_components.py]
diff --git a/xpcom/components/test/test_gen_static_components.py b/xpcom/components/test/test_gen_static_components.py
new file mode 100644
index 0000000000..85f731c082
--- /dev/null
+++ b/xpcom/components/test/test_gen_static_components.py
@@ -0,0 +1,150 @@
+# 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/.
+
+import os
+import sys
+import unittest
+
+import mozunit
+
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+import gen_static_components
+from gen_static_components import BackgroundTasksSelector
+
+
+class TestGenStaticComponents(unittest.TestCase):
+ def test_string(self):
+ # A string: we default to NO_TASKS.
+ clas = {
+ "cid": "{a8566880-0bc7-4822-adb9-748c9af5cce7}",
+ "contract_ids": ["@mozilla.org/dummy-class;1"],
+ "jsm": "resource:///modules/DummyClass.jsm",
+ "js_name": "dummyClass",
+ "constructor": "DummyClassImpl",
+ "categories": {
+ "dummy1": ["m-dummy1", "m-dummy2"],
+ },
+ "protocol_config": {
+ "scheme": "dummy",
+ "flags": [],
+ },
+ }
+
+ substs = gen_static_components.gen_substs([{"Classes": [clas]}])
+
+ self.assertEqual(substs["category_count"], 1)
+ self.assertEqual(
+ [s.strip() for s in substs["categories"].splitlines()],
+ [
+ '{ { 0x0 } /* "dummy1" */,',
+ "0, 2 },",
+ ],
+ )
+ self.assertEqual(
+ [s.strip() for s in substs["category_entries"].splitlines()],
+ [
+ '/* "dummy1" */',
+ '{ { 0x7 } /* "m-dummy1" */,',
+ '{ 0x10 } /* "@mozilla.org/dummy-class;1" */,',
+ "Module::BackgroundTasksSelector::NO_TASKS,",
+ "Module::ProcessSelector::ANY_PROCESS },",
+ '{ { 0x2b } /* "m-dummy2" */,',
+ '{ 0x10 } /* "@mozilla.org/dummy-class;1" */,',
+ "Module::BackgroundTasksSelector::NO_TASKS,",
+ "Module::ProcessSelector::ANY_PROCESS },",
+ ],
+ )
+
+ def test_dict(self):
+ # A dict, but no backgroundtasks selector: we default to NO_TASKS.
+ clas = {
+ "cid": "{a8566880-0bc7-4822-adb9-748c9af5cce7}",
+ "contract_ids": ["@mozilla.org/dummy-class;1"],
+ "jsm": "resource:///modules/DummyClass.jsm",
+ "js_name": "dummyClass",
+ "constructor": "DummyClassImpl",
+ "categories": {
+ "dummy1": {
+ "name": ["m-dummy1", "m-dummy2"],
+ },
+ },
+ "protocol_config": {
+ "scheme": "dummy",
+ "flags": [],
+ },
+ }
+
+ substs = gen_static_components.gen_substs([{"Classes": [clas]}])
+
+ self.assertEqual(substs["category_count"], 1)
+ self.assertEqual(
+ [s.strip() for s in substs["categories"].splitlines()],
+ [
+ '{ { 0x0 } /* "dummy1" */,',
+ "0, 2 },",
+ ],
+ )
+ self.assertEqual(
+ [s.strip() for s in substs["category_entries"].splitlines()],
+ [
+ '/* "dummy1" */',
+ '{ { 0x7 } /* "m-dummy1" */,',
+ '{ 0x10 } /* "@mozilla.org/dummy-class;1" */,',
+ "Module::BackgroundTasksSelector::NO_TASKS,",
+ "Module::ProcessSelector::ANY_PROCESS },",
+ '{ { 0x2b } /* "m-dummy2" */,',
+ '{ 0x10 } /* "@mozilla.org/dummy-class;1" */,',
+ "Module::BackgroundTasksSelector::NO_TASKS,",
+ "Module::ProcessSelector::ANY_PROCESS },",
+ ],
+ )
+
+ def test_dict_with_selector(self):
+ # A dict with a selector.
+ clas = {
+ "cid": "{a8566880-0bc7-4822-adb9-748c9af5cce7}",
+ "contract_ids": ["@mozilla.org/dummy-class;1"],
+ "jsm": "resource:///modules/DummyClass.jsm",
+ "js_name": "dummyClass",
+ "constructor": "DummyClassImpl",
+ "categories": {
+ "dummy1": {
+ "name": ["m-dummy1", "m-dummy2"],
+ "backgroundtasks": BackgroundTasksSelector.ALL_TASKS,
+ },
+ },
+ "protocol_config": {
+ "scheme": "dummy",
+ "flags": [],
+ },
+ }
+
+ substs = gen_static_components.gen_substs([{"Classes": [clas]}])
+
+ self.assertEqual(substs["category_count"], 1)
+ self.assertEqual(
+ [s.strip() for s in substs["categories"].splitlines()],
+ [
+ '{ { 0x0 } /* "dummy1" */,',
+ "0, 2 },",
+ ],
+ )
+ self.assertEqual(
+ [s.strip() for s in substs["category_entries"].splitlines()],
+ [
+ '/* "dummy1" */',
+ '{ { 0x7 } /* "m-dummy1" */,',
+ '{ 0x10 } /* "@mozilla.org/dummy-class;1" */,',
+ "Module::BackgroundTasksSelector::ALL_TASKS,",
+ "Module::ProcessSelector::ANY_PROCESS },",
+ '{ { 0x2b } /* "m-dummy2" */,',
+ '{ 0x10 } /* "@mozilla.org/dummy-class;1" */,',
+ "Module::BackgroundTasksSelector::ALL_TASKS,",
+ "Module::ProcessSelector::ANY_PROCESS },",
+ ],
+ )
+
+
+if __name__ == "__main__":
+ mozunit.main()