mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 21:43:24 +00:00
133e16ecf4
The following was removed: - the main meat of the overlays and interface in XULDocument - all overlay observers and forward references - the notion of a master document - XUL overlay provider - manifest parsing of overlay attribute - references to "overlay" atom - restrictions on persistence (only need because of overlays) - unused code that the above referenced I also attempted to update comments that referenced overlays, but there is still some work to be done here. MozReview-Commit-ID: 8lrirzcgSuJ --HG-- extra : rebase_source : 25b4e1d3fb2af6f02d894887271fd345c9c2083b
820 lines
23 KiB
C++
820 lines
23 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=2 sts=2 sw=2 et 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/dom/ContentParent.h"
|
|
#include "RegistryMessageUtils.h"
|
|
#include "nsResProtocolHandler.h"
|
|
|
|
#include "nsChromeRegistryChrome.h"
|
|
|
|
#if defined(XP_WIN)
|
|
#include <windows.h>
|
|
#elif defined(XP_MACOSX)
|
|
#include <CoreServices/CoreServices.h>
|
|
#endif
|
|
|
|
#include "nsArrayEnumerator.h"
|
|
#include "nsComponentManager.h"
|
|
#include "nsEnumeratorUtils.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsStringEnumerator.h"
|
|
#include "nsTextFormatter.h"
|
|
#include "nsXPCOMCIDInternal.h"
|
|
|
|
#include "mozilla/LookAndFeel.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/intl/LocaleService.h"
|
|
|
|
#include "nsIObserverService.h"
|
|
#include "nsIPrefBranch.h"
|
|
#include "nsIPrefService.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "nsIResProtocolHandler.h"
|
|
#include "nsIScriptError.h"
|
|
#include "nsIXULRuntime.h"
|
|
|
|
#define SELECTED_SKIN_PREF "general.skins.selectedSkin"
|
|
#define PACKAGE_OVERRIDE_BRANCH "chrome.override_package."
|
|
|
|
using namespace mozilla;
|
|
using mozilla::dom::ContentParent;
|
|
using mozilla::dom::PContentParent;
|
|
using mozilla::intl::LocaleService;
|
|
|
|
// We use a "best-fit" algorithm for matching locales and themes.
|
|
// 1) the exact selected locale/theme
|
|
// 2) (locales only) same language, different country
|
|
// e.g. en-GB is the selected locale, only en-US is available
|
|
// 3) any available locale/theme
|
|
|
|
/**
|
|
* Match the language-part of two lang-COUNTRY codes, hopefully but
|
|
* not guaranteed to be in the form ab-CD or abz-CD. "ab" should also
|
|
* work, any other garbage-in will produce undefined results as long
|
|
* as it does not crash.
|
|
*/
|
|
static bool
|
|
LanguagesMatch(const nsACString& a, const nsACString& b)
|
|
{
|
|
if (a.Length() < 2 || b.Length() < 2)
|
|
return false;
|
|
|
|
nsACString::const_iterator as, ae, bs, be;
|
|
a.BeginReading(as);
|
|
a.EndReading(ae);
|
|
b.BeginReading(bs);
|
|
b.EndReading(be);
|
|
|
|
while (*as == *bs) {
|
|
if (*as == '-')
|
|
return true;
|
|
|
|
++as; ++bs;
|
|
|
|
// reached the end
|
|
if (as == ae && bs == be)
|
|
return true;
|
|
|
|
// "a" is short
|
|
if (as == ae)
|
|
return (*bs == '-');
|
|
|
|
// "b" is short
|
|
if (bs == be)
|
|
return (*as == '-');
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
nsChromeRegistryChrome::nsChromeRegistryChrome()
|
|
: mProfileLoaded(false)
|
|
, mDynamicRegistration(true)
|
|
{
|
|
}
|
|
|
|
nsChromeRegistryChrome::~nsChromeRegistryChrome()
|
|
{
|
|
}
|
|
|
|
nsresult
|
|
nsChromeRegistryChrome::Init()
|
|
{
|
|
nsresult rv = nsChromeRegistry::Init();
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
mSelectedSkin = NS_LITERAL_CSTRING("classic/1.0");
|
|
|
|
bool safeMode = false;
|
|
nsCOMPtr<nsIXULRuntime> xulrun (do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
|
|
if (xulrun)
|
|
xulrun->GetInSafeMode(&safeMode);
|
|
|
|
nsCOMPtr<nsIPrefService> prefserv (do_GetService(NS_PREFSERVICE_CONTRACTID));
|
|
nsCOMPtr<nsIPrefBranch> prefs;
|
|
|
|
if (prefserv) {
|
|
if (safeMode) {
|
|
prefserv->GetDefaultBranch(nullptr, getter_AddRefs(prefs));
|
|
} else {
|
|
prefs = do_QueryInterface(prefserv);
|
|
}
|
|
}
|
|
|
|
if (!prefs) {
|
|
NS_WARNING("Could not get pref service!");
|
|
} else {
|
|
nsAutoCString provider;
|
|
rv = prefs->GetCharPref(SELECTED_SKIN_PREF, provider);
|
|
if (NS_SUCCEEDED(rv))
|
|
mSelectedSkin = provider;
|
|
|
|
rv = prefs->AddObserver(SELECTED_SKIN_PREF, this, true);
|
|
}
|
|
|
|
nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService();
|
|
if (obsService) {
|
|
obsService->AddObserver(this, "profile-initial-state", true);
|
|
obsService->AddObserver(this, "intl:app-locales-changed", true);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsChromeRegistryChrome::CheckForOSAccessibility()
|
|
{
|
|
int32_t useAccessibilityTheme =
|
|
LookAndFeel::GetInt(LookAndFeel::eIntID_UseAccessibilityTheme, 0);
|
|
|
|
if (useAccessibilityTheme) {
|
|
/* Set the skin to classic and remove pref observers */
|
|
if (!mSelectedSkin.EqualsLiteral("classic/1.0")) {
|
|
mSelectedSkin.AssignLiteral("classic/1.0");
|
|
RefreshSkins();
|
|
}
|
|
|
|
nsCOMPtr<nsIPrefBranch> prefs (do_GetService(NS_PREFSERVICE_CONTRACTID));
|
|
if (prefs) {
|
|
prefs->RemoveObserver(SELECTED_SKIN_PREF, this);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsChromeRegistryChrome::GetLocalesForPackage(const nsACString& aPackage,
|
|
nsIUTF8StringEnumerator* *aResult)
|
|
{
|
|
nsCString realpackage;
|
|
nsresult rv = OverrideLocalePackage(aPackage, realpackage);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
nsTArray<nsCString> *a = new nsTArray<nsCString>;
|
|
if (!a)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
PackageEntry* entry;
|
|
if (mPackagesHash.Get(realpackage, &entry)) {
|
|
entry->locales.EnumerateToArray(a);
|
|
}
|
|
|
|
rv = NS_NewAdoptingUTF8StringEnumerator(aResult, a);
|
|
if (NS_FAILED(rv))
|
|
delete a;
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsChromeRegistryChrome::IsLocaleRTL(const nsACString& package, bool *aResult)
|
|
{
|
|
*aResult = false;
|
|
|
|
nsAutoCString locale;
|
|
GetSelectedLocale(package, false, locale);
|
|
if (locale.Length() < 2)
|
|
return NS_OK;
|
|
|
|
*aResult = GetDirectionForLocale(locale);
|
|
return NS_OK;
|
|
}
|
|
|
|
/**
|
|
* This method negotiates only between the app locale and the available
|
|
* chrome packages.
|
|
*
|
|
* If you want to get the current application's UI locale, please use
|
|
* LocaleService::GetAppLocaleAsLangTag.
|
|
*/
|
|
nsresult
|
|
nsChromeRegistryChrome::GetSelectedLocale(const nsACString& aPackage,
|
|
bool aAsBCP47,
|
|
nsACString& aLocale)
|
|
{
|
|
nsAutoCString reqLocale;
|
|
if (aPackage.EqualsLiteral("global")) {
|
|
LocaleService::GetInstance()->GetAppLocaleAsLangTag(reqLocale);
|
|
} else {
|
|
AutoTArray<nsCString, 10> requestedLocales;
|
|
LocaleService::GetInstance()->GetRequestedLocales(requestedLocales);
|
|
reqLocale.Assign(requestedLocales[0]);
|
|
}
|
|
|
|
nsCString realpackage;
|
|
nsresult rv = OverrideLocalePackage(aPackage, realpackage);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
PackageEntry* entry;
|
|
if (!mPackagesHash.Get(realpackage, &entry))
|
|
return NS_ERROR_FILE_NOT_FOUND;
|
|
|
|
aLocale = entry->locales.GetSelected(reqLocale, nsProviderArray::LOCALE);
|
|
if (aLocale.IsEmpty())
|
|
return NS_ERROR_FAILURE;
|
|
|
|
if (aAsBCP47) {
|
|
SanitizeForBCP47(aLocale);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult
|
|
nsChromeRegistryChrome::OverrideLocalePackage(const nsACString& aPackage,
|
|
nsACString& aOverride)
|
|
{
|
|
const nsACString& pref = NS_LITERAL_CSTRING(PACKAGE_OVERRIDE_BRANCH) + aPackage;
|
|
nsAutoCString override;
|
|
nsresult rv =
|
|
mozilla::Preferences::GetCString(PromiseFlatCString(pref).get(), override);
|
|
if (NS_SUCCEEDED(rv)) {
|
|
aOverride = override;
|
|
} else {
|
|
aOverride = aPackage;
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsChromeRegistryChrome::Observe(nsISupports *aSubject, const char *aTopic,
|
|
const char16_t *someData)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (!strcmp(NS_PREFBRANCH_PREFCHANGE_TOPIC_ID, aTopic)) {
|
|
nsCOMPtr<nsIPrefBranch> prefs (do_QueryInterface(aSubject));
|
|
NS_ASSERTION(prefs, "Bad observer call!");
|
|
|
|
NS_ConvertUTF16toUTF8 pref(someData);
|
|
|
|
if (pref.EqualsLiteral(SELECTED_SKIN_PREF)) {
|
|
nsAutoCString provider;
|
|
rv = prefs->GetCharPref(pref.get(), provider);
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("Couldn't get new skin pref!");
|
|
return rv;
|
|
}
|
|
|
|
mSelectedSkin = provider;
|
|
RefreshSkins();
|
|
} else {
|
|
NS_ERROR("Unexpected pref!");
|
|
}
|
|
}
|
|
else if (!strcmp("profile-initial-state", aTopic)) {
|
|
mProfileLoaded = true;
|
|
}
|
|
else if (!strcmp("intl:app-locales-changed", aTopic)) {
|
|
if (mProfileLoaded) {
|
|
FlushAllCaches();
|
|
}
|
|
}
|
|
else {
|
|
NS_ERROR("Unexpected observer topic!");
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsChromeRegistryChrome::CheckForNewChrome()
|
|
{
|
|
mPackagesHash.Clear();
|
|
mOverrideTable.Clear();
|
|
|
|
mDynamicRegistration = false;
|
|
|
|
nsComponentManagerImpl::gComponentManager->RereadChromeManifests();
|
|
|
|
mDynamicRegistration = true;
|
|
|
|
SendRegisteredChrome(nullptr);
|
|
return NS_OK;
|
|
}
|
|
|
|
static void
|
|
SerializeURI(nsIURI* aURI,
|
|
SerializedURI& aSerializedURI)
|
|
{
|
|
if (!aURI)
|
|
return;
|
|
|
|
aURI->GetSpec(aSerializedURI.spec);
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::SendRegisteredChrome(
|
|
mozilla::dom::PContentParent* aParent)
|
|
{
|
|
InfallibleTArray<ChromePackage> packages;
|
|
InfallibleTArray<SubstitutionMapping> resources;
|
|
InfallibleTArray<OverrideMapping> overrides;
|
|
|
|
for (auto iter = mPackagesHash.Iter(); !iter.Done(); iter.Next()) {
|
|
ChromePackage chromePackage;
|
|
ChromePackageFromPackageEntry(iter.Key(), iter.UserData(), &chromePackage,
|
|
mSelectedSkin);
|
|
packages.AppendElement(chromePackage);
|
|
}
|
|
|
|
// If we were passed a parent then a new child process has been created and
|
|
// has requested all of the chrome so send it the resources too. Otherwise
|
|
// resource mappings are sent by the resource protocol handler dynamically.
|
|
if (aParent) {
|
|
nsCOMPtr<nsIIOService> io (do_GetIOService());
|
|
NS_ENSURE_TRUE_VOID(io);
|
|
|
|
nsCOMPtr<nsIProtocolHandler> ph;
|
|
nsresult rv = io->GetProtocolHandler("resource", getter_AddRefs(ph));
|
|
NS_ENSURE_SUCCESS_VOID(rv);
|
|
|
|
nsCOMPtr<nsIResProtocolHandler> irph (do_QueryInterface(ph));
|
|
nsResProtocolHandler* rph = static_cast<nsResProtocolHandler*>(irph.get());
|
|
rv = rph->CollectSubstitutions(resources);
|
|
NS_ENSURE_SUCCESS_VOID(rv);
|
|
}
|
|
|
|
for (auto iter = mOverrideTable.Iter(); !iter.Done(); iter.Next()) {
|
|
SerializedURI chromeURI, overrideURI;
|
|
|
|
SerializeURI(iter.Key(), chromeURI);
|
|
SerializeURI(iter.UserData(), overrideURI);
|
|
|
|
OverrideMapping override = { chromeURI, overrideURI };
|
|
overrides.AppendElement(override);
|
|
}
|
|
|
|
nsAutoCString appLocale;
|
|
LocaleService::GetInstance()->GetAppLocaleAsLangTag(appLocale);
|
|
|
|
if (aParent) {
|
|
bool success = aParent->SendRegisterChrome(packages, resources, overrides,
|
|
appLocale, false);
|
|
NS_ENSURE_TRUE_VOID(success);
|
|
} else {
|
|
nsTArray<ContentParent*> parents;
|
|
ContentParent::GetAll(parents);
|
|
if (!parents.Length())
|
|
return;
|
|
|
|
for (uint32_t i = 0; i < parents.Length(); i++) {
|
|
DebugOnly<bool> success =
|
|
parents[i]->SendRegisterChrome(packages, resources, overrides,
|
|
appLocale, true);
|
|
NS_WARNING_ASSERTION(success,
|
|
"couldn't reset a child's registered chrome");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* static */ void
|
|
nsChromeRegistryChrome::ChromePackageFromPackageEntry(const nsACString& aPackageName,
|
|
PackageEntry* aPackage,
|
|
ChromePackage* aChromePackage,
|
|
const nsCString& aSelectedSkin)
|
|
{
|
|
nsAutoCString appLocale;
|
|
LocaleService::GetInstance()->GetAppLocaleAsLangTag(appLocale);
|
|
|
|
SerializeURI(aPackage->baseURI, aChromePackage->contentBaseURI);
|
|
SerializeURI(aPackage->locales.GetBase(appLocale, nsProviderArray::LOCALE),
|
|
aChromePackage->localeBaseURI);
|
|
SerializeURI(aPackage->skins.GetBase(aSelectedSkin, nsProviderArray::ANY),
|
|
aChromePackage->skinBaseURI);
|
|
aChromePackage->package = aPackageName;
|
|
aChromePackage->flags = aPackage->flags;
|
|
}
|
|
|
|
static bool
|
|
CanLoadResource(nsIURI* aResourceURI)
|
|
{
|
|
bool isLocalResource = false;
|
|
(void)NS_URIChainHasFlags(aResourceURI,
|
|
nsIProtocolHandler::URI_IS_LOCAL_RESOURCE,
|
|
&isLocalResource);
|
|
return isLocalResource;
|
|
}
|
|
|
|
nsIURI*
|
|
nsChromeRegistryChrome::GetBaseURIFromPackage(const nsCString& aPackage,
|
|
const nsCString& aProvider,
|
|
const nsCString& aPath)
|
|
{
|
|
PackageEntry* entry;
|
|
if (!mPackagesHash.Get(aPackage, &entry)) {
|
|
if (!mInitialized)
|
|
return nullptr;
|
|
|
|
LogMessage("No chrome package registered for chrome://%s/%s/%s",
|
|
aPackage.get(), aProvider.get(), aPath.get());
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
if (aProvider.EqualsLiteral("locale")) {
|
|
nsAutoCString appLocale;
|
|
LocaleService::GetInstance()->GetAppLocaleAsLangTag(appLocale);
|
|
return entry->locales.GetBase(appLocale, nsProviderArray::LOCALE);
|
|
}
|
|
else if (aProvider.EqualsLiteral("skin")) {
|
|
return entry->skins.GetBase(mSelectedSkin, nsProviderArray::ANY);
|
|
}
|
|
else if (aProvider.EqualsLiteral("content")) {
|
|
return entry->baseURI;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
nsresult
|
|
nsChromeRegistryChrome::GetFlagsFromPackage(const nsCString& aPackage,
|
|
uint32_t* aFlags)
|
|
{
|
|
PackageEntry* entry;
|
|
if (!mPackagesHash.Get(aPackage, &entry))
|
|
return NS_ERROR_FILE_NOT_FOUND;
|
|
|
|
*aFlags = entry->flags;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsChromeRegistryChrome::ProviderEntry*
|
|
nsChromeRegistryChrome::nsProviderArray::GetProvider(const nsACString& aPreferred, MatchType aType)
|
|
{
|
|
size_t i = mArray.Length();
|
|
if (!i)
|
|
return nullptr;
|
|
|
|
ProviderEntry* found = nullptr; // Only set if we find a partial-match locale
|
|
ProviderEntry* entry = nullptr;
|
|
|
|
while (i--) {
|
|
entry = &mArray[i];
|
|
if (aPreferred.Equals(entry->provider))
|
|
return entry;
|
|
|
|
if (aType != LOCALE)
|
|
continue;
|
|
|
|
if (LanguagesMatch(aPreferred, entry->provider)) {
|
|
found = entry;
|
|
continue;
|
|
}
|
|
|
|
if (!found && entry->provider.EqualsLiteral("en-US"))
|
|
found = entry;
|
|
}
|
|
|
|
if (!found && aType != EXACT)
|
|
return entry;
|
|
|
|
return found;
|
|
}
|
|
|
|
nsIURI*
|
|
nsChromeRegistryChrome::nsProviderArray::GetBase(const nsACString& aPreferred, MatchType aType)
|
|
{
|
|
ProviderEntry* provider = GetProvider(aPreferred, aType);
|
|
|
|
if (!provider)
|
|
return nullptr;
|
|
|
|
return provider->baseURI;
|
|
}
|
|
|
|
const nsACString&
|
|
nsChromeRegistryChrome::nsProviderArray::GetSelected(const nsACString& aPreferred, MatchType aType)
|
|
{
|
|
ProviderEntry* entry = GetProvider(aPreferred, aType);
|
|
|
|
if (entry)
|
|
return entry->provider;
|
|
|
|
return EmptyCString();
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::nsProviderArray::SetBase(const nsACString& aProvider, nsIURI* aBaseURL)
|
|
{
|
|
ProviderEntry* provider = GetProvider(aProvider, EXACT);
|
|
|
|
if (provider) {
|
|
provider->baseURI = aBaseURL;
|
|
return;
|
|
}
|
|
|
|
// no existing entries, add a new one
|
|
mArray.AppendElement(ProviderEntry(aProvider, aBaseURL));
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::nsProviderArray::EnumerateToArray(nsTArray<nsCString> *a)
|
|
{
|
|
int32_t i = mArray.Length();
|
|
while (i--) {
|
|
a->AppendElement(mArray[i].provider);
|
|
}
|
|
}
|
|
|
|
nsIURI*
|
|
nsChromeRegistry::ManifestProcessingContext::GetManifestURI()
|
|
{
|
|
if (!mManifestURI) {
|
|
nsCString uri;
|
|
mFile.GetURIString(uri);
|
|
NS_NewURI(getter_AddRefs(mManifestURI), uri);
|
|
}
|
|
return mManifestURI;
|
|
}
|
|
|
|
already_AddRefed<nsIURI>
|
|
nsChromeRegistry::ManifestProcessingContext::ResolveURI(const char* uri)
|
|
{
|
|
nsIURI* baseuri = GetManifestURI();
|
|
if (!baseuri)
|
|
return nullptr;
|
|
|
|
nsCOMPtr<nsIURI> resolved;
|
|
nsresult rv = NS_NewURI(getter_AddRefs(resolved), uri, baseuri);
|
|
if (NS_FAILED(rv))
|
|
return nullptr;
|
|
|
|
return resolved.forget();
|
|
}
|
|
|
|
static void
|
|
EnsureLowerCase(char *aBuf)
|
|
{
|
|
for (; *aBuf; ++aBuf) {
|
|
char ch = *aBuf;
|
|
if (ch >= 'A' && ch <= 'Z')
|
|
*aBuf = ch + 'a' - 'A';
|
|
}
|
|
}
|
|
|
|
static void
|
|
SendManifestEntry(const ChromeRegistryItem &aItem)
|
|
{
|
|
nsTArray<ContentParent*> parents;
|
|
ContentParent::GetAll(parents);
|
|
if (!parents.Length())
|
|
return;
|
|
|
|
for (uint32_t i = 0; i < parents.Length(); i++) {
|
|
Unused << parents[i]->SendRegisterChromeItem(aItem);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::ManifestContent(ManifestProcessingContext& cx, int lineno,
|
|
char *const * argv, int flags)
|
|
{
|
|
char* package = argv[0];
|
|
char* uri = argv[1];
|
|
|
|
EnsureLowerCase(package);
|
|
|
|
nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
|
|
if (!resolved) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, unable to create URI '%s'.", uri);
|
|
return;
|
|
}
|
|
|
|
if (!CanLoadResource(resolved)) {
|
|
LogMessageWithContext(resolved, lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, cannot register non-local URI '%s' as content.",
|
|
uri);
|
|
return;
|
|
}
|
|
|
|
nsDependentCString packageName(package);
|
|
PackageEntry* entry = mPackagesHash.LookupOrAdd(packageName);
|
|
entry->baseURI = resolved;
|
|
entry->flags = flags;
|
|
|
|
if (mDynamicRegistration) {
|
|
ChromePackage chromePackage;
|
|
ChromePackageFromPackageEntry(packageName, entry, &chromePackage,
|
|
mSelectedSkin);
|
|
SendManifestEntry(chromePackage);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::ManifestLocale(ManifestProcessingContext& cx, int lineno,
|
|
char *const * argv, int flags)
|
|
{
|
|
char* package = argv[0];
|
|
char* provider = argv[1];
|
|
char* uri = argv[2];
|
|
|
|
EnsureLowerCase(package);
|
|
|
|
nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
|
|
if (!resolved) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, unable to create URI '%s'.", uri);
|
|
return;
|
|
}
|
|
|
|
if (!CanLoadResource(resolved)) {
|
|
LogMessageWithContext(resolved, lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, cannot register non-local URI '%s' as content.",
|
|
uri);
|
|
return;
|
|
}
|
|
|
|
nsDependentCString packageName(package);
|
|
PackageEntry* entry = mPackagesHash.LookupOrAdd(packageName);
|
|
entry->locales.SetBase(nsDependentCString(provider), resolved);
|
|
|
|
if (mDynamicRegistration) {
|
|
ChromePackage chromePackage;
|
|
ChromePackageFromPackageEntry(packageName, entry, &chromePackage,
|
|
mSelectedSkin);
|
|
SendManifestEntry(chromePackage);
|
|
}
|
|
|
|
// We use mainPackage as the package we track for reporting new locales being
|
|
// registered. For most cases it will be "global", but for Fennec it will be
|
|
// "browser".
|
|
nsAutoCString mainPackage;
|
|
nsresult rv = OverrideLocalePackage(NS_LITERAL_CSTRING("global"), mainPackage);
|
|
if (NS_FAILED(rv)) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::ManifestSkin(ManifestProcessingContext& cx, int lineno,
|
|
char *const * argv, int flags)
|
|
{
|
|
char* package = argv[0];
|
|
char* provider = argv[1];
|
|
char* uri = argv[2];
|
|
|
|
EnsureLowerCase(package);
|
|
|
|
nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
|
|
if (!resolved) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, unable to create URI '%s'.", uri);
|
|
return;
|
|
}
|
|
|
|
if (!CanLoadResource(resolved)) {
|
|
LogMessageWithContext(resolved, lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, cannot register non-local URI '%s' as content.",
|
|
uri);
|
|
return;
|
|
}
|
|
|
|
nsDependentCString packageName(package);
|
|
PackageEntry* entry = mPackagesHash.LookupOrAdd(packageName);
|
|
entry->skins.SetBase(nsDependentCString(provider), resolved);
|
|
|
|
if (mDynamicRegistration) {
|
|
ChromePackage chromePackage;
|
|
ChromePackageFromPackageEntry(packageName, entry, &chromePackage,
|
|
mSelectedSkin);
|
|
SendManifestEntry(chromePackage);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::ManifestOverride(ManifestProcessingContext& cx, int lineno,
|
|
char *const * argv, int flags)
|
|
{
|
|
char* chrome = argv[0];
|
|
char* resolved = argv[1];
|
|
|
|
nsCOMPtr<nsIURI> chromeuri = cx.ResolveURI(chrome);
|
|
nsCOMPtr<nsIURI> resolveduri = cx.ResolveURI(resolved);
|
|
if (!chromeuri || !resolveduri) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, unable to create URI.");
|
|
return;
|
|
}
|
|
|
|
if (cx.mType == NS_SKIN_LOCATION) {
|
|
bool chromeSkinOnly = false;
|
|
nsresult rv = chromeuri->SchemeIs("chrome", &chromeSkinOnly);
|
|
chromeSkinOnly = chromeSkinOnly && NS_SUCCEEDED(rv);
|
|
if (chromeSkinOnly) {
|
|
rv = resolveduri->SchemeIs("chrome", &chromeSkinOnly);
|
|
chromeSkinOnly = chromeSkinOnly && NS_SUCCEEDED(rv);
|
|
}
|
|
if (chromeSkinOnly) {
|
|
nsAutoCString chromePath, resolvedPath;
|
|
chromeuri->GetPathQueryRef(chromePath);
|
|
resolveduri->GetPathQueryRef(resolvedPath);
|
|
chromeSkinOnly = StringBeginsWith(chromePath, NS_LITERAL_CSTRING("/skin/")) &&
|
|
StringBeginsWith(resolvedPath, NS_LITERAL_CSTRING("/skin/"));
|
|
}
|
|
if (!chromeSkinOnly) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"Cannot register non-chrome://.../skin/ URIs '%s' and '%s' as overrides and/or to be overridden from a skin manifest.",
|
|
chrome, resolved);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!CanLoadResource(resolveduri)) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"Cannot register non-local URI '%s' for an override.", resolved);
|
|
return;
|
|
}
|
|
mOverrideTable.Put(chromeuri, resolveduri);
|
|
|
|
if (mDynamicRegistration) {
|
|
SerializedURI serializedChrome;
|
|
SerializedURI serializedOverride;
|
|
|
|
SerializeURI(chromeuri, serializedChrome);
|
|
SerializeURI(resolveduri, serializedOverride);
|
|
|
|
OverrideMapping override = { serializedChrome, serializedOverride };
|
|
SendManifestEntry(override);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsChromeRegistryChrome::ManifestResource(ManifestProcessingContext& cx, int lineno,
|
|
char *const * argv, int flags)
|
|
{
|
|
char* package = argv[0];
|
|
char* uri = argv[1];
|
|
|
|
EnsureLowerCase(package);
|
|
nsDependentCString host(package);
|
|
|
|
nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
|
|
if (!io) {
|
|
NS_WARNING("No IO service trying to process chrome manifests");
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIProtocolHandler> ph;
|
|
nsresult rv = io->GetProtocolHandler("resource", getter_AddRefs(ph));
|
|
if (NS_FAILED(rv))
|
|
return;
|
|
|
|
nsCOMPtr<nsIResProtocolHandler> rph = do_QueryInterface(ph);
|
|
|
|
nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
|
|
if (!resolved) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"During chrome registration, unable to create URI '%s'.", uri);
|
|
return;
|
|
}
|
|
|
|
if (!CanLoadResource(resolved)) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"Warning: cannot register non-local URI '%s' as a resource.",
|
|
uri);
|
|
return;
|
|
}
|
|
|
|
// By default, Firefox resources are not content-accessible unless the
|
|
// manifests opts in.
|
|
bool contentAccessible = (flags & nsChromeRegistry::CONTENT_ACCESSIBLE);
|
|
|
|
uint32_t substitutionFlags = 0;
|
|
if (contentAccessible) {
|
|
substitutionFlags |= nsIResProtocolHandler::ALLOW_CONTENT_ACCESS;
|
|
}
|
|
rv = rph->SetSubstitutionWithFlags(host, resolved, substitutionFlags);
|
|
if (NS_FAILED(rv)) {
|
|
LogMessageWithContext(cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
|
|
"Warning: cannot set substitution for '%s'.",
|
|
uri);
|
|
}
|
|
}
|