chrome/nsChromeRegistryChrome.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 sts=2 sw=2 et tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/dom/ContentParent.h"
   8 #include "RegistryMessageUtils.h"
   9 #include "nsResProtocolHandler.h"
  10
  11 #include "nsChromeRegistryChrome.h"
  12
  13 #if defined(XP_WIN)
  14 #  include <windows.h>
  15 #elif defined(XP_MACOSX)
  16 #  include <CoreServices/CoreServices.h>
  17 #endif
  18
  19 #include "nsArrayEnumerator.h"
  20 #include "nsComponentManager.h"
  21 #include "nsEnumeratorUtils.h"
  22 #include "nsNetUtil.h"
  23 #include "nsStringEnumerator.h"
  24 #include "nsTextFormatter.h"
  25 #include "nsXPCOMCIDInternal.h"
  26
  27 #include "mozilla/LookAndFeel.h"
  28 #include "mozilla/Unused.h"
  29 #include "mozilla/intl/LocaleService.h"
  30
  31 #include "nsIAppStartup.h"
  32 #include "nsIObserverService.h"
  33 #include "nsIPrefBranch.h"
  34 #include "nsIPrefService.h"
  35 #include "mozilla/Preferences.h"
  36 #include "nsIResProtocolHandler.h"
  37 #include "nsIScriptError.h"
  38 #include "nsIXULRuntime.h"
  39
  40 #define PACKAGE_OVERRIDE_BRANCH "chrome.override_package."
  41 #define SKIN NS_LITERAL_CSTRING("classic/1.0")
  42
  43 using namespace mozilla;
  44 using mozilla::dom::ContentParent;
  45 using mozilla::dom::PContentParent;
  46 using mozilla::intl::LocaleService;
  47
  48 // We use a "best-fit" algorithm for matching locales and themes.
  49 // 1) the exact selected locale/theme
  50 // 2) (locales only) same language, different country
  51 //    e.g. en-GB is the selected locale, only en-US is available
  52 // 3) any available locale/theme
  53
  54 /**
  55  * Match the language-part of two lang-COUNTRY codes, hopefully but
  56  * not guaranteed to be in the form ab-CD or abz-CD. "ab" should also
  57  * work, any other garbage-in will produce undefined results as long
  58  * as it does not crash.
  59  */
  60 static bool LanguagesMatch(const nsACString& a, const nsACString& b) {
  61   if (a.Length() < 2 || b.Length() < 2) return false;
  62
  63   nsACString::const_iterator as, ae, bs, be;
  64   a.BeginReading(as);
  65   a.EndReading(ae);
  66   b.BeginReading(bs);
  67   b.EndReading(be);
  68
  69   while (*as == *bs) {
  70     if (*as == '-') return true;
  71
  72     ++as;
  73     ++bs;
  74
  75     // reached the end
  76     if (as == ae && bs == be) return true;
  77
  78     // "a" is short
  79     if (as == ae) return (*bs == '-');
  80
  81     // "b" is short
  82     if (bs == be) return (*as == '-');
  83   }
  84
  85   return false;
  86 }
  87
  88 nsChromeRegistryChrome::nsChromeRegistryChrome()
  89     : mProfileLoaded(false), mDynamicRegistration(true) {}
  90
  91 nsChromeRegistryChrome::~nsChromeRegistryChrome() {}
  92
  93 nsresult nsChromeRegistryChrome::Init() {
  94   nsresult rv = nsChromeRegistry::Init();
  95   if (NS_FAILED(rv)) return rv;
  96
  97   bool safeMode = false;
  98   nsCOMPtr<nsIXULRuntime> xulrun(do_GetService(XULAPPINFO_SERVICE_CONTRACTID));
  99   if (xulrun) xulrun->GetInSafeMode(&safeMode);
 100
 101   nsCOMPtr<nsIObserverService> obsService =
 102       mozilla::services::GetObserverService();
 103   if (obsService) {
 104     obsService->AddObserver(this, "profile-initial-state", true);
 105     obsService->AddObserver(this, "intl:app-locales-changed", true);
 106   }
 107
 108   return NS_OK;
 109 }
 110
 111 NS_IMETHODIMP
 112 nsChromeRegistryChrome::GetLocalesForPackage(
 113     const nsACString& aPackage, nsIUTF8StringEnumerator** aResult) {
 114   nsCString realpackage;
 115   nsresult rv = OverrideLocalePackage(aPackage, realpackage);
 116   if (NS_FAILED(rv)) return rv;
 117
 118   nsTArray<nsCString>* a = new nsTArray<nsCString>;
 119   if (!a) return NS_ERROR_OUT_OF_MEMORY;
 120
 121   PackageEntry* entry;
 122   if (mPackagesHash.Get(realpackage, &entry)) {
 123     entry->locales.EnumerateToArray(a);
 124   }
 125
 126   rv = NS_NewAdoptingUTF8StringEnumerator(aResult, a);
 127   if (NS_FAILED(rv)) delete a;
 128
 129   return rv;
 130 }
 131
 132 NS_IMETHODIMP
 133 nsChromeRegistryChrome::IsLocaleRTL(const nsACString& package, bool* aResult) {
 134   *aResult = false;
 135
 136   nsAutoCString locale;
 137   GetSelectedLocale(package, false, locale);
 138   if (locale.Length() < 2) return NS_OK;
 139
 140   *aResult = GetDirectionForLocale(locale);
 141   return NS_OK;
 142 }
 143
 144 /**
 145  * This method negotiates only between the app locale and the available
 146  * chrome packages.
 147  *
 148  * If you want to get the current application's UI locale, please use
 149  * LocaleService::GetAppLocaleAsLangTag.
 150  */
 151 nsresult nsChromeRegistryChrome::GetSelectedLocale(const nsACString& aPackage,
 152                                                    bool aAsBCP47,
 153                                                    nsACString& aLocale) {
 154   nsAutoCString reqLocale;
 155   if (aPackage.EqualsLiteral("global")) {
 156     LocaleService::GetInstance()->GetAppLocaleAsLangTag(reqLocale);
 157   } else {
 158     AutoTArray<nsCString, 10> requestedLocales;
 159     LocaleService::GetInstance()->GetRequestedLocales(requestedLocales);
 160     reqLocale.Assign(requestedLocales[0]);
 161   }
 162
 163   nsCString realpackage;
 164   nsresult rv = OverrideLocalePackage(aPackage, realpackage);
 165   if (NS_FAILED(rv)) return rv;
 166   PackageEntry* entry;
 167   if (!mPackagesHash.Get(realpackage, &entry)) return NS_ERROR_FILE_NOT_FOUND;
 168
 169   aLocale = entry->locales.GetSelected(reqLocale, nsProviderArray::LOCALE);
 170   if (aLocale.IsEmpty()) return NS_ERROR_FAILURE;
 171
 172   if (aAsBCP47) {
 173     SanitizeForBCP47(aLocale);
 174   }
 175
 176   return NS_OK;
 177 }
 178
 179 nsresult nsChromeRegistryChrome::OverrideLocalePackage(
 180     const nsACString& aPackage, nsACString& aOverride) {
 181   const nsACString& pref =
 182       NS_LITERAL_CSTRING(PACKAGE_OVERRIDE_BRANCH) + aPackage;
 183   nsAutoCString override;
 184   nsresult rv = mozilla::Preferences::GetCString(PromiseFlatCString(pref).get(),
 185                                                  override);
 186   if (NS_SUCCEEDED(rv)) {
 187     aOverride = override;
 188   } else {
 189     aOverride = aPackage;
 190   }
 191   return NS_OK;
 192 }
 193
 194 NS_IMETHODIMP
 195 nsChromeRegistryChrome::Observe(nsISupports* aSubject, const char* aTopic,
 196                                 const char16_t* someData) {
 197   nsresult rv = NS_OK;
 198
 199   if (!strcmp("profile-initial-state", aTopic)) {
 200     mProfileLoaded = true;
 201   } else if (!strcmp("intl:app-locales-changed", aTopic)) {
 202     if (mProfileLoaded) {
 203       FlushAllCaches();
 204     }
 205   } else {
 206     NS_ERROR("Unexpected observer topic!");
 207   }
 208
 209   return rv;
 210 }
 211
 212 NS_IMETHODIMP
 213 nsChromeRegistryChrome::CheckForNewChrome() {
 214   nsCOMPtr<nsIAppStartup> appStartup = components::AppStartup::Service();
 215   if (appStartup->GetShuttingDown()) {
 216     MOZ_ASSERT(false, "checking for new chrome during shutdown");
 217     return NS_ERROR_UNEXPECTED;
 218   }
 219
 220   mPackagesHash.Clear();
 221   mOverrideTable.Clear();
 222
 223   mDynamicRegistration = false;
 224
 225   nsComponentManagerImpl::gComponentManager->RereadChromeManifests();
 226
 227   mDynamicRegistration = true;
 228
 229   SendRegisteredChrome(nullptr);
 230   return NS_OK;
 231 }
 232
 233 static void SerializeURI(nsIURI* aURI, SerializedURI& aSerializedURI) {
 234   if (!aURI) return;
 235
 236   aURI->GetSpec(aSerializedURI.spec);
 237 }
 238
 239 void nsChromeRegistryChrome::SendRegisteredChrome(
 240     mozilla::dom::PContentParent* aParent) {
 241   nsTArray<ChromePackage> packages;
 242   nsTArray<SubstitutionMapping> resources;
 243   nsTArray<OverrideMapping> overrides;
 244
 245   for (auto iter = mPackagesHash.Iter(); !iter.Done(); iter.Next()) {
 246     ChromePackage chromePackage;
 247     ChromePackageFromPackageEntry(iter.Key(), iter.UserData(), &chromePackage,
 248                                   SKIN);
 249     packages.AppendElement(chromePackage);
 250   }
 251
 252   // If we were passed a parent then a new child process has been created and
 253   // has requested all of the chrome so send it the resources too. Otherwise
 254   // resource mappings are sent by the resource protocol handler dynamically.
 255   if (aParent) {
 256     nsCOMPtr<nsIIOService> io(do_GetIOService());
 257     NS_ENSURE_TRUE_VOID(io);
 258
 259     nsCOMPtr<nsIProtocolHandler> ph;
 260     nsresult rv = io->GetProtocolHandler("resource", getter_AddRefs(ph));
 261     NS_ENSURE_SUCCESS_VOID(rv);
 262
 263     nsCOMPtr<nsIResProtocolHandler> irph(do_QueryInterface(ph));
 264     nsResProtocolHandler* rph = static_cast<nsResProtocolHandler*>(irph.get());
 265     rv = rph->CollectSubstitutions(resources);
 266     NS_ENSURE_SUCCESS_VOID(rv);
 267   }
 268
 269   for (auto iter = mOverrideTable.Iter(); !iter.Done(); iter.Next()) {
 270     SerializedURI chromeURI, overrideURI;
 271
 272     SerializeURI(iter.Key(), chromeURI);
 273     SerializeURI(iter.UserData(), overrideURI);
 274
 275     OverrideMapping override = {chromeURI, overrideURI};
 276     overrides.AppendElement(override);
 277   }
 278
 279   nsAutoCString appLocale;
 280   LocaleService::GetInstance()->GetAppLocaleAsLangTag(appLocale);
 281
 282   if (aParent) {
 283     bool success = aParent->SendRegisterChrome(packages, resources, overrides,
 284                                                appLocale, false);
 285     NS_ENSURE_TRUE_VOID(success);
 286   } else {
 287     nsTArray<ContentParent*> parents;
 288     ContentParent::GetAll(parents);
 289     if (!parents.Length()) return;
 290
 291     for (uint32_t i = 0; i < parents.Length(); i++) {
 292       DebugOnly<bool> success = parents[i]->SendRegisterChrome(
 293           packages, resources, overrides, appLocale, true);
 294       NS_WARNING_ASSERTION(success,
 295                            "couldn't reset a child's registered chrome");
 296     }
 297   }
 298 }
 299
 300 /* static */
 301 void nsChromeRegistryChrome::ChromePackageFromPackageEntry(
 302     const nsACString& aPackageName, PackageEntry* aPackage,
 303     ChromePackage* aChromePackage, const nsCString& aSelectedSkin) {
 304   nsAutoCString appLocale;
 305   LocaleService::GetInstance()->GetAppLocaleAsLangTag(appLocale);
 306
 307   SerializeURI(aPackage->baseURI, aChromePackage->contentBaseURI);
 308   SerializeURI(aPackage->locales.GetBase(appLocale, nsProviderArray::LOCALE),
 309                aChromePackage->localeBaseURI);
 310   SerializeURI(aPackage->skins.GetBase(aSelectedSkin, nsProviderArray::ANY),
 311                aChromePackage->skinBaseURI);
 312   aChromePackage->package = aPackageName;
 313   aChromePackage->flags = aPackage->flags;
 314 }
 315
 316 static bool CanLoadResource(nsIURI* aResourceURI) {
 317   bool isLocalResource = false;
 318   (void)NS_URIChainHasFlags(aResourceURI,
 319                             nsIProtocolHandler::URI_IS_LOCAL_RESOURCE,
 320                             &isLocalResource);
 321   return isLocalResource;
 322 }
 323
 324 nsIURI* nsChromeRegistryChrome::GetBaseURIFromPackage(
 325     const nsCString& aPackage, const nsCString& aProvider,
 326     const nsCString& aPath) {
 327   PackageEntry* entry;
 328   if (!mPackagesHash.Get(aPackage, &entry)) {
 329     if (!mInitialized) return nullptr;
 330
 331     LogMessage("No chrome package registered for chrome://%s/%s/%s",
 332                aPackage.get(), aProvider.get(), aPath.get());
 333
 334     return nullptr;
 335   }
 336
 337   if (aProvider.EqualsLiteral("locale")) {
 338     nsAutoCString appLocale;
 339     LocaleService::GetInstance()->GetAppLocaleAsLangTag(appLocale);
 340     return entry->locales.GetBase(appLocale, nsProviderArray::LOCALE);
 341   } else if (aProvider.EqualsLiteral("skin")) {
 342     return entry->skins.GetBase(SKIN, nsProviderArray::ANY);
 343   } else if (aProvider.EqualsLiteral("content")) {
 344     return entry->baseURI;
 345   }
 346   return nullptr;
 347 }
 348
 349 nsresult nsChromeRegistryChrome::GetFlagsFromPackage(const nsCString& aPackage,
 350                                                      uint32_t* aFlags) {
 351   PackageEntry* entry;
 352   if (!mPackagesHash.Get(aPackage, &entry)) return NS_ERROR_FILE_NOT_FOUND;
 353
 354   *aFlags = entry->flags;
 355   return NS_OK;
 356 }
 357
 358 nsChromeRegistryChrome::ProviderEntry*
 359 nsChromeRegistryChrome::nsProviderArray::GetProvider(
 360     const nsACString& aPreferred, MatchType aType) {
 361   size_t i = mArray.Length();
 362   if (!i) return nullptr;
 363
 364   ProviderEntry* found = nullptr;  // Only set if we find a partial-match locale
 365   ProviderEntry* entry = nullptr;
 366
 367   while (i--) {
 368     entry = &mArray[i];
 369     if (aPreferred.Equals(entry->provider)) return entry;
 370
 371     if (aType != LOCALE) continue;
 372
 373     if (LanguagesMatch(aPreferred, entry->provider)) {
 374       found = entry;
 375       continue;
 376     }
 377
 378     if (!found && entry->provider.EqualsLiteral("en-US")) found = entry;
 379   }
 380
 381   if (!found && aType != EXACT) return entry;
 382
 383   return found;
 384 }
 385
 386 nsIURI* nsChromeRegistryChrome::nsProviderArray::GetBase(
 387     const nsACString& aPreferred, MatchType aType) {
 388   ProviderEntry* provider = GetProvider(aPreferred, aType);
 389
 390   if (!provider) return nullptr;
 391
 392   return provider->baseURI;
 393 }
 394
 395 const nsACString& nsChromeRegistryChrome::nsProviderArray::GetSelected(
 396     const nsACString& aPreferred, MatchType aType) {
 397   ProviderEntry* entry = GetProvider(aPreferred, aType);
 398
 399   if (entry) return entry->provider;
 400
 401   return EmptyCString();
 402 }
 403
 404 void nsChromeRegistryChrome::nsProviderArray::SetBase(
 405     const nsACString& aProvider, nsIURI* aBaseURL) {
 406   ProviderEntry* provider = GetProvider(aProvider, EXACT);
 407
 408   if (provider) {
 409     provider->baseURI = aBaseURL;
 410     return;
 411   }
 412
 413   // no existing entries, add a new one
 414   mArray.AppendElement(ProviderEntry(aProvider, aBaseURL));
 415 }
 416
 417 void nsChromeRegistryChrome::nsProviderArray::EnumerateToArray(
 418     nsTArray<nsCString>* a) {
 419   int32_t i = mArray.Length();
 420   while (i--) {
 421     a->AppendElement(mArray[i].provider);
 422   }
 423 }
 424
 425 nsIURI* nsChromeRegistry::ManifestProcessingContext::GetManifestURI() {
 426   if (!mManifestURI) {
 427     nsCString uri;
 428     mFile.GetURIString(uri);
 429     NS_NewURI(getter_AddRefs(mManifestURI), uri);
 430   }
 431   return mManifestURI;
 432 }
 433
 434 already_AddRefed<nsIURI>
 435 nsChromeRegistry::ManifestProcessingContext::ResolveURI(const char* uri) {
 436   nsIURI* baseuri = GetManifestURI();
 437   if (!baseuri) return nullptr;
 438
 439   nsCOMPtr<nsIURI> resolved;
 440   nsresult rv = NS_NewURI(getter_AddRefs(resolved), uri, baseuri);
 441   if (NS_FAILED(rv)) return nullptr;
 442
 443   return resolved.forget();
 444 }
 445
 446 static void EnsureLowerCase(char* aBuf) {
 447   for (; *aBuf; ++aBuf) {
 448     char ch = *aBuf;
 449     if (ch >= 'A' && ch <= 'Z') *aBuf = ch + 'a' - 'A';
 450   }
 451 }
 452
 453 static void SendManifestEntry(const ChromeRegistryItem& aItem) {
 454   nsTArray<ContentParent*> parents;
 455   ContentParent::GetAll(parents);
 456   if (!parents.Length()) return;
 457
 458   for (uint32_t i = 0; i < parents.Length(); i++) {
 459     Unused << parents[i]->SendRegisterChromeItem(aItem);
 460   }
 461 }
 462
 463 void nsChromeRegistryChrome::ManifestContent(ManifestProcessingContext& cx,
 464                                              int lineno, char* const* argv,
 465                                              int flags) {
 466   char* package = argv[0];
 467   char* uri = argv[1];
 468
 469   EnsureLowerCase(package);
 470
 471   nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
 472   if (!resolved) {
 473     LogMessageWithContext(
 474         cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 475         "During chrome registration, unable to create URI '%s'.", uri);
 476     return;
 477   }
 478
 479   if (!CanLoadResource(resolved)) {
 480     LogMessageWithContext(resolved, lineno, nsIScriptError::warningFlag,
 481                           "During chrome registration, cannot register "
 482                           "non-local URI '%s' as content.",
 483                           uri);
 484     return;
 485   }
 486
 487   nsDependentCString packageName(package);
 488   PackageEntry* entry = mPackagesHash.LookupOrAdd(packageName);
 489   entry->baseURI = resolved;
 490   entry->flags = flags;
 491
 492   if (mDynamicRegistration) {
 493     ChromePackage chromePackage;
 494     ChromePackageFromPackageEntry(packageName, entry, &chromePackage, SKIN);
 495     SendManifestEntry(chromePackage);
 496   }
 497 }
 498
 499 void nsChromeRegistryChrome::ManifestLocale(ManifestProcessingContext& cx,
 500                                             int lineno, char* const* argv,
 501                                             int flags) {
 502   char* package = argv[0];
 503   char* provider = argv[1];
 504   char* uri = argv[2];
 505
 506   EnsureLowerCase(package);
 507
 508   nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
 509   if (!resolved) {
 510     LogMessageWithContext(
 511         cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 512         "During chrome registration, unable to create URI '%s'.", uri);
 513     return;
 514   }
 515
 516   if (!CanLoadResource(resolved)) {
 517     LogMessageWithContext(resolved, lineno, nsIScriptError::warningFlag,
 518                           "During chrome registration, cannot register "
 519                           "non-local URI '%s' as content.",
 520                           uri);
 521     return;
 522   }
 523
 524   nsDependentCString packageName(package);
 525   PackageEntry* entry = mPackagesHash.LookupOrAdd(packageName);
 526   entry->locales.SetBase(nsDependentCString(provider), resolved);
 527
 528   if (mDynamicRegistration) {
 529     ChromePackage chromePackage;
 530     ChromePackageFromPackageEntry(packageName, entry, &chromePackage, SKIN);
 531     SendManifestEntry(chromePackage);
 532   }
 533
 534   // We use mainPackage as the package we track for reporting new locales being
 535   // registered. For most cases it will be "global", but for Fennec it will be
 536   // "browser".
 537   nsAutoCString mainPackage;
 538   nsresult rv =
 539       OverrideLocalePackage(NS_LITERAL_CSTRING("global"), mainPackage);
 540   if (NS_FAILED(rv)) {
 541     return;
 542   }
 543 }
 544
 545 void nsChromeRegistryChrome::ManifestSkin(ManifestProcessingContext& cx,
 546                                           int lineno, char* const* argv,
 547                                           int flags) {
 548   char* package = argv[0];
 549   char* provider = argv[1];
 550   char* uri = argv[2];
 551
 552   EnsureLowerCase(package);
 553
 554   nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
 555   if (!resolved) {
 556     LogMessageWithContext(
 557         cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 558         "During chrome registration, unable to create URI '%s'.", uri);
 559     return;
 560   }
 561
 562   if (!CanLoadResource(resolved)) {
 563     LogMessageWithContext(resolved, lineno, nsIScriptError::warningFlag,
 564                           "During chrome registration, cannot register "
 565                           "non-local URI '%s' as content.",
 566                           uri);
 567     return;
 568   }
 569
 570   nsDependentCString packageName(package);
 571   PackageEntry* entry = mPackagesHash.LookupOrAdd(packageName);
 572   entry->skins.SetBase(nsDependentCString(provider), resolved);
 573
 574   if (mDynamicRegistration) {
 575     ChromePackage chromePackage;
 576     ChromePackageFromPackageEntry(packageName, entry, &chromePackage, SKIN);
 577     SendManifestEntry(chromePackage);
 578   }
 579 }
 580
 581 void nsChromeRegistryChrome::ManifestOverride(ManifestProcessingContext& cx,
 582                                               int lineno, char* const* argv,
 583                                               int flags) {
 584   char* chrome = argv[0];
 585   char* resolved = argv[1];
 586
 587   nsCOMPtr<nsIURI> chromeuri = cx.ResolveURI(chrome);
 588   nsCOMPtr<nsIURI> resolveduri = cx.ResolveURI(resolved);
 589   if (!chromeuri || !resolveduri) {
 590     LogMessageWithContext(cx.GetManifestURI(), lineno,
 591                           nsIScriptError::warningFlag,
 592                           "During chrome registration, unable to create URI.");
 593     return;
 594   }
 595
 596   if (cx.mType == NS_SKIN_LOCATION) {
 597     bool chromeSkinOnly =
 598         chromeuri->SchemeIs("chrome") && resolveduri->SchemeIs("chrome");
 599     if (chromeSkinOnly) {
 600       nsAutoCString chromePath, resolvedPath;
 601       chromeuri->GetPathQueryRef(chromePath);
 602       resolveduri->GetPathQueryRef(resolvedPath);
 603       chromeSkinOnly =
 604           StringBeginsWith(chromePath, NS_LITERAL_CSTRING("/skin/")) &&
 605           StringBeginsWith(resolvedPath, NS_LITERAL_CSTRING("/skin/"));
 606     }
 607     if (!chromeSkinOnly) {
 608       LogMessageWithContext(
 609           cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 610           "Cannot register non-chrome://.../skin/ URIs '%s' and '%s' as "
 611           "overrides and/or to be overridden from a skin manifest.",
 612           chrome, resolved);
 613       return;
 614     }
 615   }
 616
 617   if (!CanLoadResource(resolveduri)) {
 618     LogMessageWithContext(
 619         cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 620         "Cannot register non-local URI '%s' for an override.", resolved);
 621     return;
 622   }
 623   mOverrideTable.Put(chromeuri, resolveduri);
 624
 625   if (mDynamicRegistration) {
 626     SerializedURI serializedChrome;
 627     SerializedURI serializedOverride;
 628
 629     SerializeURI(chromeuri, serializedChrome);
 630     SerializeURI(resolveduri, serializedOverride);
 631
 632     OverrideMapping override = {serializedChrome, serializedOverride};
 633     SendManifestEntry(override);
 634   }
 635 }
 636
 637 void nsChromeRegistryChrome::ManifestResource(ManifestProcessingContext& cx,
 638                                               int lineno, char* const* argv,
 639                                               int flags) {
 640   char* package = argv[0];
 641   char* uri = argv[1];
 642
 643   EnsureLowerCase(package);
 644   nsDependentCString host(package);
 645
 646   nsCOMPtr<nsIIOService> io = mozilla::services::GetIOService();
 647   if (!io) {
 648     NS_WARNING("No IO service trying to process chrome manifests");
 649     return;
 650   }
 651
 652   nsCOMPtr<nsIProtocolHandler> ph;
 653   nsresult rv = io->GetProtocolHandler("resource", getter_AddRefs(ph));
 654   if (NS_FAILED(rv)) return;
 655
 656   nsCOMPtr<nsIResProtocolHandler> rph = do_QueryInterface(ph);
 657
 658   nsCOMPtr<nsIURI> resolved = cx.ResolveURI(uri);
 659   if (!resolved) {
 660     LogMessageWithContext(
 661         cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 662         "During chrome registration, unable to create URI '%s'.", uri);
 663     return;
 664   }
 665
 666   if (!CanLoadResource(resolved)) {
 667     LogMessageWithContext(
 668         cx.GetManifestURI(), lineno, nsIScriptError::warningFlag,
 669         "Warning: cannot register non-local URI '%s' as a resource.", uri);
 670     return;
 671   }
 672
 673   // By default, Firefox resources are not content-accessible unless the
 674   // manifests opts in.
 675   bool contentAccessible = (flags & nsChromeRegistry::CONTENT_ACCESSIBLE);
 676
 677   uint32_t substitutionFlags = 0;
 678   if (contentAccessible) {
 679     substitutionFlags |= nsIResProtocolHandler::ALLOW_CONTENT_ACCESS;
 680   }
 681   rv = rph->SetSubstitutionWithFlags(host, resolved, substitutionFlags);
 682   if (NS_FAILED(rv)) {
 683     LogMessageWithContext(cx.GetManifestURI(), lineno,
 684                           nsIScriptError::warningFlag,
 685                           "Warning: cannot set substitution for '%s'.", uri);
 686   }
 687 }