chrome/nsChromeRegistryContent.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 "RegistryMessageUtils.h"
   8 #include "nsChromeRegistryContent.h"
   9 #include "nsString.h"
  10 #include "nsNetUtil.h"
  11 #include "nsIResProtocolHandler.h"
  12
  13 nsChromeRegistryContent::nsChromeRegistryContent() {}
  14
  15 void nsChromeRegistryContent::RegisterRemoteChrome(
  16     const InfallibleTArray<ChromePackage>& aPackages,
  17     const InfallibleTArray<SubstitutionMapping>& aSubstitutions,
  18     const InfallibleTArray<OverrideMapping>& aOverrides,
  19     const nsACString& aLocale, bool aReset) {
  20   MOZ_ASSERT(aReset || mLocale.IsEmpty(), "RegisterChrome twice?");
  21
  22   if (aReset) {
  23     mPackagesHash.Clear();
  24     mOverrideTable.Clear();
  25     // XXX Can't clear resources.
  26   }
  27
  28   for (uint32_t i = aPackages.Length(); i > 0;) {
  29     --i;
  30     RegisterPackage(aPackages[i]);
  31   }
  32
  33   for (uint32_t i = aSubstitutions.Length(); i > 0;) {
  34     --i;
  35     RegisterSubstitution(aSubstitutions[i]);
  36   }
  37
  38   for (uint32_t i = aOverrides.Length(); i > 0;) {
  39     --i;
  40     RegisterOverride(aOverrides[i]);
  41   }
  42
  43   mLocale = aLocale;
  44 }
  45
  46 void nsChromeRegistryContent::RegisterPackage(const ChromePackage& aPackage) {
  47   nsCOMPtr<nsIIOService> io(do_GetIOService());
  48   if (!io) return;
  49
  50   nsCOMPtr<nsIURI> content, locale, skin;
  51
  52   if (aPackage.contentBaseURI.spec.Length()) {
  53     nsresult rv = NS_NewURI(getter_AddRefs(content),
  54                             aPackage.contentBaseURI.spec, nullptr, nullptr, io);
  55     if (NS_FAILED(rv)) return;
  56   }
  57   if (aPackage.localeBaseURI.spec.Length()) {
  58     nsresult rv = NS_NewURI(getter_AddRefs(locale), aPackage.localeBaseURI.spec,
  59                             nullptr, nullptr, io);
  60     if (NS_FAILED(rv)) return;
  61   }
  62   if (aPackage.skinBaseURI.spec.Length()) {
  63     nsresult rv = NS_NewURI(getter_AddRefs(skin), aPackage.skinBaseURI.spec,
  64                             nullptr, nullptr, io);
  65     if (NS_FAILED(rv)) return;
  66   }
  67
  68   PackageEntry* entry = new PackageEntry;
  69   entry->flags = aPackage.flags;
  70   entry->contentBaseURI = content;
  71   entry->localeBaseURI = locale;
  72   entry->skinBaseURI = skin;
  73
  74   mPackagesHash.Put(aPackage.package, entry);
  75 }
  76
  77 void nsChromeRegistryContent::RegisterSubstitution(
  78     const SubstitutionMapping& aSubstitution) {
  79   nsCOMPtr<nsIIOService> io(do_GetIOService());
  80   if (!io) return;
  81
  82   nsCOMPtr<nsIProtocolHandler> ph;
  83   nsresult rv =
  84       io->GetProtocolHandler(aSubstitution.scheme.get(), getter_AddRefs(ph));
  85   if (NS_FAILED(rv)) return;
  86
  87   nsCOMPtr<nsISubstitutingProtocolHandler> sph(do_QueryInterface(ph));
  88   if (!sph) return;
  89
  90   nsCOMPtr<nsIURI> resolvedURI;
  91   if (aSubstitution.resolvedURI.spec.Length()) {
  92     rv = NS_NewURI(getter_AddRefs(resolvedURI), aSubstitution.resolvedURI.spec,
  93                    nullptr, nullptr, io);
  94     if (NS_FAILED(rv)) return;
  95   }
  96
  97   rv = sph->SetSubstitutionWithFlags(aSubstitution.path, resolvedURI,
  98                                      aSubstitution.flags);
  99   if (NS_FAILED(rv)) return;
 100 }
 101
 102 void nsChromeRegistryContent::RegisterOverride(
 103     const OverrideMapping& aOverride) {
 104   nsCOMPtr<nsIIOService> io(do_GetIOService());
 105   if (!io) return;
 106
 107   nsCOMPtr<nsIURI> chromeURI, overrideURI;
 108   nsresult rv = NS_NewURI(getter_AddRefs(chromeURI), aOverride.originalURI.spec,
 109                           nullptr, nullptr, io);
 110   if (NS_FAILED(rv)) return;
 111
 112   rv = NS_NewURI(getter_AddRefs(overrideURI), aOverride.overrideURI.spec,
 113                  nullptr, nullptr, io);
 114   if (NS_FAILED(rv)) return;
 115
 116   mOverrideTable.Put(chromeURI, overrideURI);
 117 }
 118
 119 nsIURI* nsChromeRegistryContent::GetBaseURIFromPackage(
 120     const nsCString& aPackage, const nsCString& aProvider,
 121     const nsCString& aPath) {
 122   PackageEntry* entry;
 123   if (!mPackagesHash.Get(aPackage, &entry)) {
 124     return nullptr;
 125   }
 126
 127   if (aProvider.EqualsLiteral("locale")) {
 128     return entry->localeBaseURI;
 129   } else if (aProvider.EqualsLiteral("skin")) {
 130     return entry->skinBaseURI;
 131   } else if (aProvider.EqualsLiteral("content")) {
 132     return entry->contentBaseURI;
 133   }
 134   return nullptr;
 135 }
 136
 137 nsresult nsChromeRegistryContent::GetFlagsFromPackage(const nsCString& aPackage,
 138                                                       uint32_t* aFlags) {
 139   PackageEntry* entry;
 140   if (!mPackagesHash.Get(aPackage, &entry)) {
 141     return NS_ERROR_FAILURE;
 142   }
 143   *aFlags = entry->flags;
 144   return NS_OK;
 145 }
 146
 147 // All functions following only make sense in chrome, and therefore assert
 148
 149 #define CONTENT_NOTREACHED() \
 150   MOZ_ASSERT_UNREACHABLE("Content should not be calling this")
 151
 152 #define CONTENT_NOT_IMPLEMENTED() \
 153   CONTENT_NOTREACHED();           \
 154   return NS_ERROR_NOT_IMPLEMENTED;
 155
 156 NS_IMETHODIMP
 157 nsChromeRegistryContent::GetLocalesForPackage(
 158     const nsACString& aPackage, nsIUTF8StringEnumerator** aResult) {
 159   CONTENT_NOT_IMPLEMENTED();
 160 }
 161
 162 NS_IMETHODIMP
 163 nsChromeRegistryContent::CheckForOSAccessibility() {
 164   CONTENT_NOT_IMPLEMENTED();
 165 }
 166
 167 NS_IMETHODIMP
 168 nsChromeRegistryContent::CheckForNewChrome() { CONTENT_NOT_IMPLEMENTED(); }
 169
 170 NS_IMETHODIMP
 171 nsChromeRegistryContent::IsLocaleRTL(const nsACString& aPackage,
 172                                      bool* aResult) {
 173   if (aPackage != nsDependentCString("global")) {
 174     NS_ERROR("Packages other than global unavailable");
 175     return NS_ERROR_NOT_AVAILABLE;
 176   }
 177   *aResult = GetDirectionForLocale(mLocale);
 178   return NS_OK;
 179 }
 180
 181 NS_IMETHODIMP
 182 nsChromeRegistryContent::GetSelectedLocale(const nsACString& aPackage,
 183                                            bool aAsBCP47, nsACString& aLocale) {
 184   if (aPackage != nsDependentCString("global")) {
 185     NS_ERROR("Uh-oh, caller wanted something other than 'some local'");
 186     return NS_ERROR_NOT_AVAILABLE;
 187   }
 188   aLocale = mLocale;
 189   if (aAsBCP47) {
 190     SanitizeForBCP47(aLocale);
 191   }
 192   return NS_OK;
 193 }
 194
 195 NS_IMETHODIMP
 196 nsChromeRegistryContent::Observe(nsISupports* aSubject, const char* aTopic,
 197                                  const char16_t* aData) {
 198   CONTENT_NOT_IMPLEMENTED();
 199 }
 200
 201 void nsChromeRegistryContent::ManifestContent(ManifestProcessingContext& cx,
 202                                               int lineno, char* const* argv,
 203                                               int flags) {
 204   CONTENT_NOTREACHED();
 205 }
 206
 207 void nsChromeRegistryContent::ManifestLocale(ManifestProcessingContext& cx,
 208                                              int lineno, char* const* argv,
 209                                              int flags) {
 210   CONTENT_NOTREACHED();
 211 }
 212
 213 void nsChromeRegistryContent::ManifestSkin(ManifestProcessingContext& cx,
 214                                            int lineno, char* const* argv,
 215                                            int flags) {
 216   CONTENT_NOTREACHED();
 217 }
 218
 219 void nsChromeRegistryContent::ManifestOverride(ManifestProcessingContext& cx,
 220                                                int lineno, char* const* argv,
 221                                                int flags) {
 222   CONTENT_NOTREACHED();
 223 }
 224
 225 void nsChromeRegistryContent::ManifestResource(ManifestProcessingContext& cx,
 226                                                int lineno, char* const* argv,
 227                                                int flags) {
 228   CONTENT_NOTREACHED();
 229 }