The Tor Browser: comparison intl/hyphenation/src/nsHyphenationManager.cpp

--1:000000000000
+:d0dd9810528c
+/* -*- 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 "nsHyphenationManager.h"
+#include "nsHyphenator.h"
+#include "nsIAtom.h"
+#include "nsIFile.h"
+#include "nsIURI.h"
+#include "nsIProperties.h"
+#include "nsISimpleEnumerator.h"
+#include "nsIDirectoryEnumerator.h"
+#include "nsDirectoryServiceDefs.h"
+#include "nsNetUtil.h"
+#include "nsUnicharUtils.h"
+#include "mozilla/Preferences.h"
+#include "nsZipArchive.h"
+#include "mozilla/Services.h"
+#include "nsIObserverService.h"
+#include "nsCRT.h"
+using namespace mozilla;
+static const char kIntlHyphenationAliasPrefix[] = "intl.hyphenation-alias.";
+static const char kMemoryPressureNotification[] = "memory-pressure";
+nsHyphenationManager *nsHyphenationManager::sInstance = nullptr;
+NS_IMPL_ISUPPORTS(nsHyphenationManager::MemoryPressureObserver,
+nsIObserver)
+NS_IMETHODIMP
+nsHyphenationManager::MemoryPressureObserver::Observe(nsISupports *aSubject,
+const char *aTopic,
+const char16_t *aData)
+{
+if (!nsCRT::strcmp(aTopic, kMemoryPressureNotification)) {
+// We don't call Instance() here, as we don't want to create a hyphenation
+// manager if there isn't already one in existence.
+// (This observer class is local to the hyphenation manager, so it can use
+// the protected members directly.)
+if (nsHyphenationManager::sInstance) {
+nsHyphenationManager::sInstance->mHyphenators.Clear();
+}
+}
+return NS_OK;
+}
+nsHyphenationManager*
+nsHyphenationManager::Instance()
+{
+if (sInstance == nullptr) {
+sInstance = new nsHyphenationManager();
+nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+if (obs) {
+obs->AddObserver(new MemoryPressureObserver,
+kMemoryPressureNotification, false);
+}
+}
+return sInstance;
+}
+void
+nsHyphenationManager::Shutdown()
+{
+delete sInstance;
+sInstance = nullptr;
+}
+nsHyphenationManager::nsHyphenationManager()
+{
+LoadPatternList();
+LoadAliases();
+}
+nsHyphenationManager::~nsHyphenationManager()
+{
+sInstance = nullptr;
+}
+already_AddRefed<nsHyphenator>
+nsHyphenationManager::GetHyphenator(nsIAtom *aLocale)
+{
+nsRefPtr<nsHyphenator> hyph;
+mHyphenators.Get(aLocale, getter_AddRefs(hyph));
+if (hyph) {
+return hyph.forget();
+}
+nsCOMPtr<nsIURI> uri = mPatternFiles.Get(aLocale);
+if (!uri) {
+nsCOMPtr<nsIAtom> alias = mHyphAliases.Get(aLocale);
+if (alias) {
+mHyphenators.Get(alias, getter_AddRefs(hyph));
+if (hyph) {
+return hyph.forget();
+}
+uri = mPatternFiles.Get(alias);
+if (uri) {
+aLocale = alias;
+}
+}
+if (!uri) {
+// In the case of a locale such as "de-DE-1996", we try replacing
+// successive trailing subtags with "-*" to find fallback patterns,
+// so "de-DE-1996" -> "de-DE-*" (and then recursively -> "de-*")
+nsAtomCString localeStr(aLocale);
+if (StringEndsWith(localeStr, NS_LITERAL_CSTRING("-*"))) {
+localeStr.Truncate(localeStr.Length() - 2);
+}
+int32_t i = localeStr.RFindChar('-');
+if (i > 1) {
+localeStr.Replace(i, localeStr.Length() - i, "-*");
+nsCOMPtr<nsIAtom> fuzzyLocale = do_GetAtom(localeStr);
+return GetHyphenator(fuzzyLocale);
+} else {
+return nullptr;
+}
+}
+}
+hyph = new nsHyphenator(uri);
+if (hyph->IsValid()) {
+mHyphenators.Put(aLocale, hyph);
+return hyph.forget();
+}
+#ifdef DEBUG
+nsCString msg;
+uri->GetSpec(msg);
+msg.Insert("failed to load patterns from ", 0);
+NS_WARNING(msg.get());
+#endif
+mPatternFiles.Remove(aLocale);
+return nullptr;
+}
+void
+nsHyphenationManager::LoadPatternList()
+{
+mPatternFiles.Clear();
+mHyphenators.Clear();
+LoadPatternListFromOmnijar(Omnijar::GRE);
+LoadPatternListFromOmnijar(Omnijar::APP);
+nsCOMPtr<nsIProperties> dirSvc =
+do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID);
+if (!dirSvc) {
+return;
+}
+nsresult rv;
+nsCOMPtr<nsIFile> greDir;
+rv = dirSvc->Get(NS_GRE_DIR,
+NS_GET_IID(nsIFile), getter_AddRefs(greDir));
+if (NS_SUCCEEDED(rv)) {
+greDir->AppendNative(NS_LITERAL_CSTRING("hyphenation"));
+LoadPatternListFromDir(greDir);
+}
+nsCOMPtr<nsIFile> appDir;
+rv = dirSvc->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
+NS_GET_IID(nsIFile), getter_AddRefs(appDir));
+if (NS_SUCCEEDED(rv)) {
+appDir->AppendNative(NS_LITERAL_CSTRING("hyphenation"));
+bool equals;
+if (NS_SUCCEEDED(appDir->Equals(greDir, &equals)) && !equals) {
+LoadPatternListFromDir(appDir);
+}
+}
+}
+void
+nsHyphenationManager::LoadPatternListFromOmnijar(Omnijar::Type aType)
+{
+nsCString base;
+nsresult rv = Omnijar::GetURIString(aType, base);
+if (NS_FAILED(rv)) {
+return;
+}
+nsRefPtr<nsZipArchive> zip = Omnijar::GetReader(aType);
+if (!zip) {
+return;
+}
+nsZipFind *find;
+zip->FindInit("hyphenation/hyph_*.dic", &find);
+if (!find) {
+return;
+}
+const char *result;
+uint16_t len;
+while (NS_SUCCEEDED(find->FindNext(&result, &len))) {
+nsCString uriString(base);
+uriString.Append(result, len);
+nsCOMPtr<nsIURI> uri;
+rv = NS_NewURI(getter_AddRefs(uri), uriString);
+if (NS_FAILED(rv)) {
+continue;
+}
+nsCString locale;
+rv = uri->GetPath(locale);
+if (NS_FAILED(rv)) {
+continue;
+}
+ToLowerCase(locale);
+locale.SetLength(locale.Length() - 4); // strip ".dic"
+locale.Cut(0, locale.RFindChar('/') + 1); // strip directory
+if (StringBeginsWith(locale, NS_LITERAL_CSTRING("hyph_"))) {
+locale.Cut(0, 5);
+}
+for (uint32_t i = 0; i < locale.Length(); ++i) {
+if (locale[i] == '_') {
+locale.Replace(i, 1, '-');
+}
+}
+nsCOMPtr<nsIAtom> localeAtom = do_GetAtom(locale);
+if (NS_SUCCEEDED(rv)) {
+mPatternFiles.Put(localeAtom, uri);
+}
+}
+delete find;
+}
+void
+nsHyphenationManager::LoadPatternListFromDir(nsIFile *aDir)
+{
+nsresult rv;
+bool check = false;
+rv = aDir->Exists(&check);
+if (NS_FAILED(rv) || !check) {
+return;
+}
+rv = aDir->IsDirectory(&check);
+if (NS_FAILED(rv) || !check) {
+return;
+}
+nsCOMPtr<nsISimpleEnumerator> e;
+rv = aDir->GetDirectoryEntries(getter_AddRefs(e));
+if (NS_FAILED(rv)) {
+return;
+}
+nsCOMPtr<nsIDirectoryEnumerator> files(do_QueryInterface(e));
+if (!files) {
+return;
+}
+nsCOMPtr<nsIFile> file;
+while (NS_SUCCEEDED(files->GetNextFile(getter_AddRefs(file))) && file){
+nsAutoString dictName;
+file->GetLeafName(dictName);
+NS_ConvertUTF16toUTF8 locale(dictName);
+ToLowerCase(locale);
+if (!StringEndsWith(locale, NS_LITERAL_CSTRING(".dic"))) {
+continue;
+}
+if (StringBeginsWith(locale, NS_LITERAL_CSTRING("hyph_"))) {
+locale.Cut(0, 5);
+}
+locale.SetLength(locale.Length() - 4); // strip ".dic"
+for (uint32_t i = 0; i < locale.Length(); ++i) {
+if (locale[i] == '_') {
+locale.Replace(i, 1, '-');
+}
+}
+#ifdef DEBUG_hyph
+printf("adding hyphenation patterns for %s: %s\n", locale.get(),
+NS_ConvertUTF16toUTF8(dictName).get());
+#endif
+nsCOMPtr<nsIAtom> localeAtom = do_GetAtom(locale);
+nsCOMPtr<nsIURI> uri;
+nsresult rv = NS_NewFileURI(getter_AddRefs(uri), file);
+if (NS_SUCCEEDED(rv)) {
+mPatternFiles.Put(localeAtom, uri);
+}
+}
+}
+void
+nsHyphenationManager::LoadAliases()
+{
+nsIPrefBranch* prefRootBranch = Preferences::GetRootBranch();
+if (!prefRootBranch) {
+return;
+}
+uint32_t prefCount;
+char **prefNames;
+nsresult rv = prefRootBranch->GetChildList(kIntlHyphenationAliasPrefix,
+&prefCount, &prefNames);
+if (NS_SUCCEEDED(rv) && prefCount > 0) {
+for (uint32_t i = 0; i < prefCount; ++i) {
+nsAdoptingCString value = Preferences::GetCString(prefNames[i]);
+if (value) {
+nsAutoCString alias(prefNames[i]);
+alias.Cut(0, sizeof(kIntlHyphenationAliasPrefix) - 1);
+ToLowerCase(alias);
+ToLowerCase(value);
+nsCOMPtr<nsIAtom> aliasAtom = do_GetAtom(alias);
+nsCOMPtr<nsIAtom> valueAtom = do_GetAtom(value);
+mHyphAliases.Put(aliasAtom, valueAtom);
+}
+}
+NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(prefCount, prefNames);
+}
+}

The Tor Browser / file comparison

comparison: intl/hyphenation/src/nsHyphenationManager.cpp

intl/hyphenation/src/nsHyphenationManager.cpp