summaryrefslogtreecommitdiffstats
path: root/intl/strres/nsStringBundle.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'intl/strres/nsStringBundle.cpp')
-rw-r--r--intl/strres/nsStringBundle.cpp1026
1 files changed, 1026 insertions, 0 deletions
diff --git a/intl/strres/nsStringBundle.cpp b/intl/strres/nsStringBundle.cpp
new file mode 100644
index 0000000000..320d122c72
--- /dev/null
+++ b/intl/strres/nsStringBundle.cpp
@@ -0,0 +1,1026 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsStringBundle.h"
+
+#include "netCore.h"
+#include "nsID.h"
+#include "nsString.h"
+#include "nsIStringBundle.h"
+#include "nsStringBundleService.h"
+#include "nsArrayEnumerator.h"
+#include "nscore.h"
+#include "nsNetUtil.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIChannel.h"
+#include "nsIInputStream.h"
+#include "nsIURI.h"
+#include "nsIObserverService.h"
+#include "nsCOMArray.h"
+#include "nsTextFormatter.h"
+#include "nsContentUtils.h"
+#include "nsPersistentProperties.h"
+#include "nsQueryObject.h"
+#include "nsSimpleEnumerator.h"
+#include "nsStringStream.h"
+#include "mozilla/dom/txXSLTMsgsURL.h"
+#include "mozilla/BinarySearch.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/URLPreloader.h"
+#include "mozilla/ResultExtensions.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ipc/SharedStringMap.h"
+
+// for async loading
+#ifdef ASYNC_LOADING
+# include "nsIBinaryInputStream.h"
+# include "nsIStringStream.h"
+#endif
+
+using namespace mozilla;
+
+using mozilla::dom::ContentParent;
+using mozilla::dom::StringBundleDescriptor;
+using mozilla::dom::ipc::SharedStringMap;
+using mozilla::dom::ipc::SharedStringMapBuilder;
+using mozilla::ipc::FileDescriptor;
+
+/**
+ * A set of string bundle URLs which are loaded by content processes, and
+ * should be allocated in a shared memory region, and then sent to content
+ * processes.
+ *
+ * Note: This layout is chosen to avoid having to create a separate char*
+ * array pointing to the string constant values, which would require
+ * per-process relocations. The second array size is the length of the longest
+ * URL plus its null terminator. Shorter strings are null padded to this
+ * length.
+ *
+ * This should be kept in sync with the similar array in nsContentUtils.cpp,
+ * and updated with any other property files which need to be loaded in all
+ * content processes.
+ */
+static const char kContentBundles[][52] = {
+ "chrome://branding/locale/brand.properties",
+ "chrome://global/locale/commonDialogs.properties",
+ "chrome://global/locale/css.properties",
+ "chrome://global/locale/dom/dom.properties",
+ "chrome://global/locale/layout/HtmlForm.properties",
+ "chrome://global/locale/layout/htmlparser.properties",
+ "chrome://global/locale/layout_errors.properties",
+ "chrome://global/locale/mathml/mathml.properties",
+ "chrome://global/locale/printing.properties",
+ "chrome://global/locale/security/csp.properties",
+ "chrome://global/locale/security/security.properties",
+ "chrome://global/locale/svg/svg.properties",
+ "chrome://global/locale/xul.properties",
+ "chrome://necko/locale/necko.properties",
+};
+
+static bool IsContentBundle(const nsCString& aUrl) {
+ size_t index;
+ return BinarySearchIf(
+ kContentBundles, 0, MOZ_ARRAY_LENGTH(kContentBundles),
+ [&](const char* aElem) {
+ return Compare(aUrl, nsDependentCString(aElem));
+ },
+ &index);
+}
+
+namespace {
+
+#define STRINGBUNDLEPROXY_IID \
+ { \
+ 0x537cf21b, 0x99fc, 0x4002, { \
+ 0x9e, 0xec, 0x97, 0xbe, 0x4d, 0xe0, 0xb3, 0xdc \
+ } \
+ }
+
+/**
+ * A simple proxy class for a string bundle instance which will be replaced by
+ * a different implementation later in the session.
+ *
+ * This is used when creating string bundles which should use shared memory,
+ * but the content process has not yet received their shared memory buffer.
+ * When the shared memory variant becomes available, this proxy is retarged to
+ * that instance, and the original non-shared instance is destroyed.
+ *
+ * At that point, the cache entry for the proxy is replaced with the shared
+ * memory instance, and callers which already have an instance of the proxy
+ * are redirected to the new instance.
+ */
+class StringBundleProxy : public nsIStringBundle {
+ NS_DECL_THREADSAFE_ISUPPORTS
+
+ NS_DECLARE_STATIC_IID_ACCESSOR(STRINGBUNDLEPROXY_IID)
+
+ explicit StringBundleProxy(already_AddRefed<nsIStringBundle> aTarget)
+ : mMutex("StringBundleProxy::mMutex"), mTarget(aTarget) {}
+
+ void Retarget(nsIStringBundle* aTarget) {
+ MutexAutoLock automon(mMutex);
+ mTarget = aTarget;
+ }
+
+ // Forward nsIStringBundle methods (other than the `SizeOf*` methods) to
+ // `Target()`.
+ NS_IMETHOD GetStringFromID(int32_t aID, nsAString& _retval) override {
+ return Target()->GetStringFromID(aID, _retval);
+ }
+ NS_IMETHOD GetStringFromAUTF8Name(const nsACString& aName,
+ nsAString& _retval) override {
+ return Target()->GetStringFromAUTF8Name(aName, _retval);
+ }
+ NS_IMETHOD GetStringFromName(const char* aName, nsAString& _retval) override {
+ return Target()->GetStringFromName(aName, _retval);
+ }
+ NS_IMETHOD FormatStringFromID(int32_t aID, const nsTArray<nsString>& params,
+ nsAString& _retval) override {
+ return Target()->FormatStringFromID(aID, params, _retval);
+ }
+ NS_IMETHOD FormatStringFromAUTF8Name(const nsACString& aName,
+ const nsTArray<nsString>& params,
+ nsAString& _retval) override {
+ return Target()->FormatStringFromAUTF8Name(aName, params, _retval);
+ }
+ NS_IMETHOD FormatStringFromName(const char* aName,
+ const nsTArray<nsString>& params,
+ nsAString& _retval) override {
+ return Target()->FormatStringFromName(aName, params, _retval);
+ }
+ NS_IMETHOD GetSimpleEnumeration(nsISimpleEnumerator** _retval) override {
+ return Target()->GetSimpleEnumeration(_retval);
+ }
+ NS_IMETHOD AsyncPreload() override { return Target()->AsyncPreload(); }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) override {
+ return aMallocSizeOf(this);
+ }
+
+ size_t SizeOfIncludingThisIfUnshared(
+ mozilla::MallocSizeOf aMallocSizeOf) override {
+ return mRefCnt == 1 ? SizeOfIncludingThis(aMallocSizeOf) : 0;
+ }
+
+ protected:
+ virtual ~StringBundleProxy() = default;
+
+ private:
+ Mutex mMutex MOZ_UNANNOTATED;
+ nsCOMPtr<nsIStringBundle> mTarget;
+
+ // Atomically reads mTarget and returns a strong reference to it. This
+ // allows for safe multi-threaded use when the proxy may be retargetted by
+ // the main thread during access.
+ nsCOMPtr<nsIStringBundle> Target() {
+ MutexAutoLock automon(mMutex);
+ return mTarget;
+ }
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(StringBundleProxy, STRINGBUNDLEPROXY_IID)
+
+NS_IMPL_ISUPPORTS(StringBundleProxy, nsIStringBundle, StringBundleProxy)
+
+#define SHAREDSTRINGBUNDLE_IID \
+ { \
+ 0x7a8df5f7, 0x9e50, 0x44f6, { \
+ 0xbf, 0x89, 0xc7, 0xad, 0x6c, 0x17, 0xf8, 0x5f \
+ } \
+ }
+
+/**
+ * A string bundle backed by a read-only, shared memory buffer. This should
+ * only be used for string bundles which are used in child processes.
+ *
+ * Important: The memory allocated by these string bundles will never be freed
+ * before process shutdown, per the restrictions in SharedStringMap.h, so they
+ * should never be used for short-lived bundles.
+ */
+class SharedStringBundle final : public nsStringBundleBase {
+ public:
+ /**
+ * Initialize the string bundle with a file descriptor pointing to a
+ * pre-populated key-value store for this string bundle. This should only be
+ * called in child processes, for bundles initially created in the parent
+ * process.
+ */
+ void SetMapFile(const FileDescriptor& aFile, size_t aSize);
+
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECLARE_STATIC_IID_ACCESSOR(SHAREDSTRINGBUNDLE_IID)
+
+ nsresult LoadProperties() override;
+
+ /**
+ * Returns a copy of the file descriptor pointing to the shared memory
+ * key-values tore for this string bundle. This should only be called in the
+ * parent process, and may be used to send shared string bundles to child
+ * processes.
+ */
+ FileDescriptor CloneFileDescriptor() const {
+ MOZ_ASSERT(XRE_IsParentProcess());
+ if (mMapFile.isSome()) {
+ return mMapFile.ref();
+ }
+ return mStringMap->CloneFileDescriptor();
+ }
+
+ size_t MapSize() const {
+ if (mMapFile.isSome()) {
+ return mMapSize;
+ }
+ if (mStringMap) {
+ return mStringMap->MapSize();
+ }
+ return 0;
+ }
+
+ bool Initialized() const { return mStringMap || mMapFile.isSome(); }
+
+ StringBundleDescriptor GetDescriptor() const {
+ MOZ_ASSERT(Initialized());
+
+ StringBundleDescriptor descriptor;
+ descriptor.bundleURL() = BundleURL();
+ descriptor.mapFile() = CloneFileDescriptor();
+ descriptor.mapSize() = MapSize();
+ return descriptor;
+ }
+
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) override;
+
+ static SharedStringBundle* Cast(nsIStringBundle* aStringBundle) {
+ return static_cast<SharedStringBundle*>(aStringBundle);
+ }
+
+ protected:
+ friend class nsStringBundleBase;
+
+ explicit SharedStringBundle(const char* aURLSpec)
+ : nsStringBundleBase(aURLSpec) {}
+
+ ~SharedStringBundle() override = default;
+
+ nsresult GetStringImpl(const nsACString& aName, nsAString& aResult) override;
+
+ nsresult GetSimpleEnumerationImpl(nsISimpleEnumerator** elements) override;
+
+ private:
+ RefPtr<SharedStringMap> mStringMap;
+
+ Maybe<FileDescriptor> mMapFile;
+ size_t mMapSize;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(SharedStringBundle, SHAREDSTRINGBUNDLE_IID)
+
+class StringMapEnumerator final : public nsSimpleEnumerator {
+ public:
+ NS_DECL_NSISIMPLEENUMERATOR
+
+ explicit StringMapEnumerator(SharedStringMap* aStringMap)
+ : mStringMap(aStringMap) {}
+
+ const nsID& DefaultInterface() override {
+ return NS_GET_IID(nsIPropertyElement);
+ }
+
+ protected:
+ virtual ~StringMapEnumerator() = default;
+
+ private:
+ RefPtr<SharedStringMap> mStringMap;
+
+ uint32_t mIndex = 0;
+};
+
+template <typename T, typename... Args>
+already_AddRefed<T> MakeBundle(Args... args) {
+ return nsStringBundleBase::Create<T>(args...);
+}
+
+template <typename T, typename... Args>
+RefPtr<T> MakeBundleRefPtr(Args... args) {
+ return nsStringBundleBase::Create<T>(args...);
+}
+
+} // anonymous namespace
+
+NS_IMPL_ISUPPORTS(nsStringBundleBase, nsIStringBundle, nsIMemoryReporter)
+
+NS_IMPL_ISUPPORTS_INHERITED0(nsStringBundle, nsStringBundleBase)
+NS_IMPL_ISUPPORTS_INHERITED(SharedStringBundle, nsStringBundleBase,
+ SharedStringBundle)
+
+nsStringBundleBase::nsStringBundleBase(const char* aURLSpec)
+ : mPropertiesURL(aURLSpec),
+ mMutex("nsStringBundle.mMutex"),
+ mAttemptedLoad(false),
+ mLoaded(false) {}
+
+nsStringBundleBase::~nsStringBundleBase() {
+ UnregisterWeakMemoryReporter(this);
+}
+
+void nsStringBundleBase::RegisterMemoryReporter() {
+ RegisterWeakMemoryReporter(this);
+}
+
+template <typename T, typename... Args>
+/* static */
+already_AddRefed<T> nsStringBundleBase::Create(Args... args) {
+ RefPtr<T> bundle = new T(args...);
+ bundle->RegisterMemoryReporter();
+ return bundle.forget();
+}
+
+nsStringBundle::nsStringBundle(const char* aURLSpec)
+ : nsStringBundleBase(aURLSpec) {}
+
+nsStringBundle::~nsStringBundle() = default;
+
+NS_IMETHODIMP
+nsStringBundleBase::AsyncPreload() {
+ return NS_DispatchToCurrentThreadQueue(
+ NewIdleRunnableMethod("nsStringBundleBase::LoadProperties", this,
+ &nsStringBundleBase::LoadProperties),
+ EventQueuePriority::Idle);
+}
+
+size_t nsStringBundle::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ size_t n = 0;
+ if (mProps) {
+ n += mProps->SizeOfIncludingThis(aMallocSizeOf);
+ }
+ return aMallocSizeOf(this) + n;
+}
+
+size_t nsStringBundleBase::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ return 0;
+}
+
+size_t nsStringBundleBase::SizeOfIncludingThisIfUnshared(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ if (mRefCnt == 1) {
+ return SizeOfIncludingThis(aMallocSizeOf);
+ } else {
+ return 0;
+ }
+}
+
+size_t SharedStringBundle::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ size_t n = 0;
+ if (mStringMap) {
+ n += aMallocSizeOf(mStringMap);
+ }
+ return aMallocSizeOf(this) + n;
+}
+
+NS_IMETHODIMP
+nsStringBundleBase::CollectReports(nsIHandleReportCallback* aHandleReport,
+ nsISupports* aData, bool aAnonymize) {
+ // String bundle URLs are always local, and part of the distribution.
+ // There's no need to anonymize.
+ nsAutoCStringN<64> escapedURL(mPropertiesURL);
+ escapedURL.ReplaceChar('/', '\\');
+
+ size_t sharedSize = 0;
+ size_t heapSize = SizeOfIncludingThis(MallocSizeOf);
+
+ nsAutoCStringN<256> path("explicit/string-bundles/");
+ if (RefPtr<SharedStringBundle> shared = do_QueryObject(this)) {
+ path.AppendLiteral("SharedStringBundle");
+ if (XRE_IsParentProcess()) {
+ sharedSize = shared->MapSize();
+ }
+ } else {
+ path.AppendLiteral("nsStringBundle");
+ }
+
+ path.AppendLiteral("(url=\"");
+ path.Append(escapedURL);
+
+ // Note: The memory reporter service holds a strong reference to reporters
+ // while collecting reports, so we want to ignore the extra ref in reports.
+ path.AppendLiteral("\", shared=");
+ path.AppendASCII(mRefCnt > 2 ? "true" : "false");
+ path.AppendLiteral(", refCount=");
+ path.AppendInt(uint32_t(mRefCnt - 1));
+
+ if (sharedSize) {
+ path.AppendLiteral(", sharedMemorySize=");
+ path.AppendInt(uint32_t(sharedSize));
+ }
+
+ path.AppendLiteral(")");
+
+ constexpr auto desc =
+ "A StringBundle instance representing the data in a (probably "
+ "localized) .properties file. Data may be shared between "
+ "processes."_ns;
+
+ aHandleReport->Callback(""_ns, path, KIND_HEAP, UNITS_BYTES, heapSize, desc,
+ aData);
+
+ if (sharedSize) {
+ path.ReplaceLiteral(0, sizeof("explicit/") - 1, "shared-");
+
+ aHandleReport->Callback(""_ns, path, KIND_OTHER, UNITS_BYTES, sharedSize,
+ desc, aData);
+ }
+
+ return NS_OK;
+}
+
+nsresult nsStringBundleBase::ParseProperties(nsIPersistentProperties** aProps) {
+ // this is different than mLoaded, because we only want to attempt
+ // to load once
+ // we only want to load once, but if we've tried once and failed,
+ // continue to throw an error!
+ if (mAttemptedLoad) {
+ if (mLoaded) return NS_OK;
+
+ return NS_ERROR_UNEXPECTED;
+ }
+
+ MOZ_ASSERT(NS_IsMainThread(),
+ "String bundles must be initialized on the main thread "
+ "before they may be used off-main-thread");
+
+ mAttemptedLoad = true;
+
+ nsresult rv;
+
+ // do it synchronously
+ nsCOMPtr<nsIURI> uri;
+ rv = NS_NewURI(getter_AddRefs(uri), mPropertiesURL);
+ if (NS_FAILED(rv)) return rv;
+
+ // whitelist check for local schemes
+ nsCString scheme;
+ uri->GetScheme(scheme);
+ if (!scheme.EqualsLiteral("chrome") && !scheme.EqualsLiteral("jar") &&
+ !scheme.EqualsLiteral("resource") && !scheme.EqualsLiteral("file") &&
+ !scheme.EqualsLiteral("data")) {
+ return NS_ERROR_ABORT;
+ }
+
+ nsCOMPtr<nsIInputStream> in;
+
+ auto result = URLPreloader::ReadURI(uri);
+ if (result.isOk()) {
+ MOZ_TRY(NS_NewCStringInputStream(getter_AddRefs(in), result.unwrap()));
+ } else {
+ nsCOMPtr<nsIChannel> channel;
+ rv = NS_NewChannel(getter_AddRefs(channel), uri,
+ nsContentUtils::GetSystemPrincipal(),
+ nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
+ nsIContentPolicy::TYPE_OTHER);
+
+ if (NS_FAILED(rv)) return rv;
+
+ // It's a string bundle. We expect a text/plain type, so set that as hint
+ channel->SetContentType("text/plain"_ns);
+
+ rv = channel->Open(getter_AddRefs(in));
+ if (NS_FAILED(rv)) return rv;
+ }
+
+ auto props = MakeRefPtr<nsPersistentProperties>();
+
+ mAttemptedLoad = true;
+
+ MOZ_TRY(props->Load(in));
+ props.forget(aProps);
+
+ mLoaded = true;
+ return NS_OK;
+}
+
+nsresult nsStringBundle::LoadProperties() {
+ // Something such as Necko might use string bundle after ClearOnShutdown is
+ // called. LocaleService etc is already down, so we cannot get bundle data.
+ if (PastShutdownPhase(ShutdownPhase::XPCOMShutdown)) {
+ return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
+ }
+
+ if (mProps) {
+ return NS_OK;
+ }
+ return ParseProperties(getter_AddRefs(mProps));
+}
+
+nsresult SharedStringBundle::LoadProperties() {
+ if (mStringMap) return NS_OK;
+
+ if (mMapFile.isSome()) {
+ mStringMap = new SharedStringMap(mMapFile.ref(), mMapSize);
+ mMapFile.reset();
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(NS_IsMainThread(),
+ "String bundles must be initialized on the main thread "
+ "before they may be used off-main-thread");
+
+ // We can't access the locale service after shutdown has started, which
+ // means we can't attempt to load chrome: locale resources (which most of
+ // our string bundles come from). Since shared string bundles won't be
+ // useful after shutdown has started anyway (and we almost certainly got
+ // here from a pre-load attempt in an idle task), just bail out.
+ if (PastShutdownPhase(ShutdownPhase::XPCOMShutdown)) {
+ return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
+ }
+
+ // We should only populate shared memory string bundles in the parent
+ // process. Instances in the child process should always be instantiated
+ // with a shared memory file descriptor sent from the parent.
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ nsCOMPtr<nsIPersistentProperties> props;
+ MOZ_TRY(ParseProperties(getter_AddRefs(props)));
+
+ SharedStringMapBuilder builder;
+
+ nsCOMPtr<nsISimpleEnumerator> iter;
+ MOZ_TRY(props->Enumerate(getter_AddRefs(iter)));
+ bool hasMore;
+ while (NS_SUCCEEDED(iter->HasMoreElements(&hasMore)) && hasMore) {
+ nsCOMPtr<nsISupports> next;
+ MOZ_TRY(iter->GetNext(getter_AddRefs(next)));
+
+ nsresult rv;
+ nsCOMPtr<nsIPropertyElement> elem = do_QueryInterface(next, &rv);
+ MOZ_TRY(rv);
+
+ nsCString key;
+ nsString value;
+ MOZ_TRY(elem->GetKey(key));
+ MOZ_TRY(elem->GetValue(value));
+
+ builder.Add(key, value);
+ }
+
+ mStringMap = new SharedStringMap(std::move(builder));
+
+ ContentParent::BroadcastStringBundle(GetDescriptor());
+
+ return NS_OK;
+}
+
+void SharedStringBundle::SetMapFile(const FileDescriptor& aFile, size_t aSize) {
+ MOZ_ASSERT(XRE_IsContentProcess());
+ mStringMap = nullptr;
+ mMapFile.emplace(aFile);
+ mMapSize = aSize;
+}
+
+NS_IMETHODIMP
+nsStringBundleBase::GetStringFromID(int32_t aID, nsAString& aResult) {
+ nsAutoCString idStr;
+ idStr.AppendInt(aID, 10);
+ return GetStringFromName(idStr.get(), aResult);
+}
+
+NS_IMETHODIMP
+nsStringBundleBase::GetStringFromAUTF8Name(const nsACString& aName,
+ nsAString& aResult) {
+ return GetStringFromName(PromiseFlatCString(aName).get(), aResult);
+}
+
+NS_IMETHODIMP
+nsStringBundleBase::GetStringFromName(const char* aName, nsAString& aResult) {
+ NS_ENSURE_ARG_POINTER(aName);
+
+ MutexAutoLock autolock(mMutex);
+
+ return GetStringImpl(nsDependentCString(aName), aResult);
+}
+
+nsresult nsStringBundle::GetStringImpl(const nsACString& aName,
+ nsAString& aResult) {
+ MOZ_TRY(LoadProperties());
+
+ return mProps->GetStringProperty(aName, aResult);
+}
+
+nsresult SharedStringBundle::GetStringImpl(const nsACString& aName,
+ nsAString& aResult) {
+ MOZ_TRY(LoadProperties());
+
+ if (mStringMap->Get(PromiseFlatCString(aName), aResult)) {
+ return NS_OK;
+ }
+ return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsStringBundleBase::FormatStringFromID(int32_t aID,
+ const nsTArray<nsString>& aParams,
+ nsAString& aResult) {
+ nsAutoCString idStr;
+ idStr.AppendInt(aID, 10);
+ return FormatStringFromName(idStr.get(), aParams, aResult);
+}
+
+// this function supports at most 10 parameters.. see below for why
+NS_IMETHODIMP
+nsStringBundleBase::FormatStringFromAUTF8Name(const nsACString& aName,
+ const nsTArray<nsString>& aParams,
+ nsAString& aResult) {
+ return FormatStringFromName(PromiseFlatCString(aName).get(), aParams,
+ aResult);
+}
+
+// this function supports at most 10 parameters.. see below for why
+NS_IMETHODIMP
+nsStringBundleBase::FormatStringFromName(const char* aName,
+ const nsTArray<nsString>& aParams,
+ nsAString& aResult) {
+ NS_ASSERTION(!aParams.IsEmpty(),
+ "FormatStringFromName() without format parameters: use "
+ "GetStringFromName() instead");
+
+ nsAutoString formatStr;
+ nsresult rv = GetStringFromName(aName, formatStr);
+ if (NS_FAILED(rv)) return rv;
+
+ return FormatString(formatStr.get(), aParams, aResult);
+}
+
+NS_IMETHODIMP
+nsStringBundleBase::GetSimpleEnumeration(nsISimpleEnumerator** aElements) {
+ NS_ENSURE_ARG_POINTER(aElements);
+
+ return GetSimpleEnumerationImpl(aElements);
+}
+
+nsresult nsStringBundle::GetSimpleEnumerationImpl(
+ nsISimpleEnumerator** elements) {
+ MOZ_TRY(LoadProperties());
+
+ return mProps->Enumerate(elements);
+}
+
+nsresult SharedStringBundle::GetSimpleEnumerationImpl(
+ nsISimpleEnumerator** aEnumerator) {
+ MOZ_TRY(LoadProperties());
+
+ auto iter = MakeRefPtr<StringMapEnumerator>(mStringMap);
+ iter.forget(aEnumerator);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+StringMapEnumerator::HasMoreElements(bool* aHasMore) {
+ *aHasMore = mIndex < mStringMap->Count();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+StringMapEnumerator::GetNext(nsISupports** aNext) {
+ if (mIndex >= mStringMap->Count()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ auto elem = MakeRefPtr<nsPropertyElement>(mStringMap->GetKeyAt(mIndex),
+ mStringMap->GetValueAt(mIndex));
+
+ elem.forget(aNext);
+
+ mIndex++;
+ return NS_OK;
+}
+
+nsresult nsStringBundleBase::FormatString(const char16_t* aFormatStr,
+ const nsTArray<nsString>& aParams,
+ nsAString& aResult) {
+ auto length = aParams.Length();
+ NS_ENSURE_ARG(length <= 10); // enforce 10-parameter limit
+
+ // implementation note: you would think you could use vsmprintf
+ // to build up an arbitrary length array.. except that there
+ // is no way to build up a va_list at runtime!
+ // Don't believe me? See:
+ // http://www.eskimo.com/~scs/C-faq/q15.13.html
+ // -alecf
+ nsTextFormatter::ssprintf(aResult, aFormatStr,
+ length >= 1 ? aParams[0].get() : nullptr,
+ length >= 2 ? aParams[1].get() : nullptr,
+ length >= 3 ? aParams[2].get() : nullptr,
+ length >= 4 ? aParams[3].get() : nullptr,
+ length >= 5 ? aParams[4].get() : nullptr,
+ length >= 6 ? aParams[5].get() : nullptr,
+ length >= 7 ? aParams[6].get() : nullptr,
+ length >= 8 ? aParams[7].get() : nullptr,
+ length >= 9 ? aParams[8].get() : nullptr,
+ length >= 10 ? aParams[9].get() : nullptr);
+
+ return NS_OK;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+
+#define MAX_CACHED_BUNDLES 16
+
+struct bundleCacheEntry_t final : public LinkedListElement<bundleCacheEntry_t> {
+ nsCString mHashKey;
+ nsCOMPtr<nsIStringBundle> mBundle;
+
+ MOZ_COUNTED_DEFAULT_CTOR(bundleCacheEntry_t)
+
+ MOZ_COUNTED_DTOR(bundleCacheEntry_t)
+};
+
+nsStringBundleService::nsStringBundleService()
+ : mBundleMap(MAX_CACHED_BUNDLES) {}
+
+NS_IMPL_ISUPPORTS(nsStringBundleService, nsIStringBundleService, nsIObserver,
+ nsISupportsWeakReference, nsIMemoryReporter)
+
+nsStringBundleService::~nsStringBundleService() {
+ UnregisterWeakMemoryReporter(this);
+ flushBundleCache(/* ignoreShared = */ false);
+}
+
+nsresult nsStringBundleService::Init() {
+ nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+ if (os) {
+ os->AddObserver(this, "memory-pressure", true);
+ os->AddObserver(this, "profile-do-change", true);
+ os->AddObserver(this, "chrome-flush-caches", true);
+ os->AddObserver(this, "intl:app-locales-changed", true);
+ }
+
+ RegisterWeakMemoryReporter(this);
+
+ return NS_OK;
+}
+
+size_t nsStringBundleService::SizeOfIncludingThis(
+ mozilla::MallocSizeOf aMallocSizeOf) {
+ size_t n = mBundleMap.ShallowSizeOfExcludingThis(aMallocSizeOf);
+ for (const auto& data : mBundleMap.Values()) {
+ n += aMallocSizeOf(data);
+ n += data->mHashKey.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
+ }
+ return aMallocSizeOf(this) + n;
+}
+
+NS_IMETHODIMP
+nsStringBundleService::Observe(nsISupports* aSubject, const char* aTopic,
+ const char16_t* aSomeData) {
+ if (strcmp("profile-do-change", aTopic) == 0 ||
+ strcmp("chrome-flush-caches", aTopic) == 0 ||
+ strcmp("intl:app-locales-changed", aTopic) == 0) {
+ flushBundleCache(/* ignoreShared = */ false);
+ } else if (strcmp("memory-pressure", aTopic) == 0) {
+ flushBundleCache(/* ignoreShared = */ true);
+ }
+
+ return NS_OK;
+}
+
+void nsStringBundleService::flushBundleCache(bool ignoreShared) {
+ LinkedList<bundleCacheEntry_t> newList;
+
+ while (!mBundleCache.isEmpty()) {
+ UniquePtr<bundleCacheEntry_t> entry(mBundleCache.popFirst());
+ auto* bundle = nsStringBundleBase::Cast(entry->mBundle);
+
+ if (ignoreShared && bundle->IsShared()) {
+ newList.insertBack(entry.release());
+ } else {
+ mBundleMap.Remove(entry->mHashKey);
+ }
+ }
+
+ mBundleCache = std::move(newList);
+}
+
+NS_IMETHODIMP
+nsStringBundleService::FlushBundles() {
+ flushBundleCache(/* ignoreShared = */ false);
+ return NS_OK;
+}
+
+void nsStringBundleService::SendContentBundles(ContentParent* aContentParent) {
+ nsTArray<StringBundleDescriptor> bundles;
+
+ for (auto* entry : mSharedBundles) {
+ auto bundle = SharedStringBundle::Cast(entry->mBundle);
+
+ if (bundle->Initialized()) {
+ bundles.AppendElement(bundle->GetDescriptor());
+ }
+ }
+
+ Unused << aContentParent->SendRegisterStringBundles(std::move(bundles));
+}
+
+void nsStringBundleService::RegisterContentBundle(
+ const nsACString& aBundleURL, const FileDescriptor& aMapFile,
+ size_t aMapSize) {
+ RefPtr<StringBundleProxy> proxy;
+
+ bundleCacheEntry_t* cacheEntry = mBundleMap.Get(aBundleURL);
+ if (cacheEntry) {
+ if (RefPtr<SharedStringBundle> shared =
+ do_QueryObject(cacheEntry->mBundle)) {
+ return;
+ }
+
+ proxy = do_QueryObject(cacheEntry->mBundle);
+ MOZ_ASSERT(proxy);
+ cacheEntry->remove();
+ delete cacheEntry;
+ }
+
+ auto bundle = MakeBundleRefPtr<SharedStringBundle>(
+ PromiseFlatCString(aBundleURL).get());
+ bundle->SetMapFile(aMapFile, aMapSize);
+
+ if (proxy) {
+ proxy->Retarget(bundle);
+ }
+
+ cacheEntry = insertIntoCache(bundle.forget(), aBundleURL);
+ mSharedBundles.insertBack(cacheEntry);
+}
+
+void nsStringBundleService::getStringBundle(const char* aURLSpec,
+ nsIStringBundle** aResult) {
+ nsDependentCString key(aURLSpec);
+ bundleCacheEntry_t* cacheEntry = mBundleMap.Get(key);
+
+ RefPtr<SharedStringBundle> shared;
+
+ if (cacheEntry) {
+ // Remove the entry from the list so it can be re-inserted at the back.
+ cacheEntry->remove();
+
+ shared = do_QueryObject(cacheEntry->mBundle);
+ } else {
+ nsCOMPtr<nsIStringBundle> bundle;
+ bool isContent = IsContentBundle(key);
+ if (!isContent || !XRE_IsParentProcess()) {
+ bundle = MakeBundle<nsStringBundle>(aURLSpec);
+ }
+
+ // If this is a bundle which is used by the content processes, we want to
+ // load it into a shared memory region.
+ //
+ // If we're in the parent process, just create a new SharedStringBundle,
+ // and populate it from the properties file.
+ //
+ // If we're in a child process, the fact that the bundle is not already in
+ // the cache means that we haven't received its shared memory descriptor
+ // from the parent yet. There's not much we can do about that besides
+ // wait, but we need to return a bundle now. So instead of a shared memory
+ // bundle, we create a temporary proxy, which points to a non-shared
+ // bundle initially, and is retarged to a shared memory bundle when it
+ // becomes available.
+ if (isContent) {
+ if (XRE_IsParentProcess()) {
+ shared = MakeBundle<SharedStringBundle>(aURLSpec);
+ bundle = shared;
+ } else {
+ bundle = new StringBundleProxy(bundle.forget());
+ }
+ }
+
+ cacheEntry = insertIntoCache(bundle.forget(), key);
+ }
+
+ if (shared) {
+ mSharedBundles.insertBack(cacheEntry);
+ } else {
+ mBundleCache.insertBack(cacheEntry);
+ }
+
+ // finally, return the value
+ *aResult = cacheEntry->mBundle;
+ NS_ADDREF(*aResult);
+}
+
+UniquePtr<bundleCacheEntry_t> nsStringBundleService::evictOneEntry() {
+ for (auto* entry : mBundleCache) {
+ auto* bundle = nsStringBundleBase::Cast(entry->mBundle);
+ if (!bundle->IsShared()) {
+ entry->remove();
+ mBundleMap.Remove(entry->mHashKey);
+ return UniquePtr<bundleCacheEntry_t>(entry);
+ }
+ }
+ return nullptr;
+}
+
+bundleCacheEntry_t* nsStringBundleService::insertIntoCache(
+ already_AddRefed<nsIStringBundle> aBundle, const nsACString& aHashKey) {
+ UniquePtr<bundleCacheEntry_t> cacheEntry;
+
+ if (mBundleMap.Count() >= MAX_CACHED_BUNDLES) {
+ cacheEntry = evictOneEntry();
+ }
+
+ if (!cacheEntry) {
+ cacheEntry.reset(new bundleCacheEntry_t());
+ }
+
+ cacheEntry->mHashKey = aHashKey;
+ cacheEntry->mBundle = aBundle;
+
+ mBundleMap.InsertOrUpdate(cacheEntry->mHashKey, cacheEntry.get());
+
+ return cacheEntry.release();
+}
+
+NS_IMETHODIMP
+nsStringBundleService::CreateBundle(const char* aURLSpec,
+ nsIStringBundle** aResult) {
+ getStringBundle(aURLSpec, aResult);
+ return NS_OK;
+}
+
+#define GLOBAL_PROPERTIES "chrome://global/locale/global-strres.properties"
+
+nsresult nsStringBundleService::FormatWithBundle(
+ nsIStringBundle* bundle, nsresult aStatus,
+ const nsTArray<nsString>& argArray, nsAString& result) {
+ nsresult rv;
+
+ // try looking up the error message with the int key:
+ uint16_t code = NS_ERROR_GET_CODE(aStatus);
+ rv = bundle->FormatStringFromID(code, argArray, result);
+
+ // If the int key fails, try looking up the default error message. E.g. print:
+ // An unknown error has occurred (0x804B0003).
+ if (NS_FAILED(rv)) {
+ AutoTArray<nsString, 1> otherArgArray;
+ otherArgArray.AppendElement()->AppendInt(static_cast<uint32_t>(aStatus),
+ 16);
+ uint16_t code = NS_ERROR_GET_CODE(NS_ERROR_FAILURE);
+ rv = bundle->FormatStringFromID(code, otherArgArray, result);
+ }
+
+ return rv;
+}
+
+NS_IMETHODIMP
+nsStringBundleService::FormatStatusMessage(nsresult aStatus,
+ const char16_t* aStatusArg,
+ nsAString& result) {
+ uint32_t i, argCount = 0;
+ nsCOMPtr<nsIStringBundle> bundle;
+
+ // XXX hack for mailnews who has already formatted their messages:
+ if (aStatus == NS_OK && aStatusArg) {
+ result.Assign(aStatusArg);
+ return NS_OK;
+ }
+
+ if (aStatus == NS_OK) {
+ return NS_ERROR_FAILURE; // no message to format
+ }
+
+ // format the arguments:
+ const nsDependentString args(aStatusArg);
+ argCount = args.CountChar(char16_t('\n')) + 1;
+ NS_ENSURE_ARG(argCount <= 10); // enforce 10-parameter limit
+ AutoTArray<nsString, 10> argArray;
+
+ // convert the aStatusArg into an nsString array
+ if (argCount == 1) {
+ argArray.AppendElement(aStatusArg);
+ } else if (argCount > 1) {
+ int32_t offset = 0;
+ for (i = 0; i < argCount; i++) {
+ int32_t pos = args.FindChar('\n', offset);
+ if (pos == -1) pos = args.Length();
+ argArray.AppendElement(Substring(args, offset, pos - offset));
+ offset = pos + 1;
+ }
+ }
+
+ switch (NS_ERROR_GET_MODULE(aStatus)) {
+ case NS_ERROR_MODULE_XSLT:
+ getStringBundle(XSLT_MSGS_URL, getter_AddRefs(bundle));
+ break;
+ case NS_ERROR_MODULE_NETWORK:
+ getStringBundle(NECKO_MSGS_URL, getter_AddRefs(bundle));
+ break;
+ default:
+ getStringBundle(GLOBAL_PROPERTIES, getter_AddRefs(bundle));
+ break;
+ }
+
+ return FormatWithBundle(bundle, aStatus, argArray, result);
+}