dom/base/nsNameSpaceManager.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 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 /*
   8  * A class for managing namespace IDs and mapping back and forth
   9  * between namespace IDs and namespace URIs.
  10  */
  11
  12 #include "nsNameSpaceManager.h"
  13
  14 #include "nscore.h"
  15 #include "mozilla/dom/NodeInfo.h"
  16 #include "nsAtom.h"
  17 #include "nsCOMArray.h"
  18 #include "nsContentCreatorFunctions.h"
  19 #include "nsGkAtoms.h"
  20 #include "mozilla/dom/Document.h"
  21 #include "nsString.h"
  22 #include "mozilla/ClearOnShutdown.h"
  23 #include "mozilla/dom/Element.h"
  24 #include "mozilla/Preferences.h"
  25
  26 using namespace mozilla;
  27 using namespace mozilla::dom;
  28
  29 static const char* kPrefSVGDisabled = "svg.disabled";
  30 static const char* kPrefMathMLDisabled = "mathml.disabled";
  31 static const char* kObservedNSPrefs[] = {kPrefMathMLDisabled, kPrefSVGDisabled,
  32                                          nullptr};
  33 StaticRefPtr<nsNameSpaceManager> nsNameSpaceManager::sInstance;
  34
  35 /* static */
  36 nsNameSpaceManager* nsNameSpaceManager::GetInstance() {
  37   if (!sInstance) {
  38     sInstance = new nsNameSpaceManager();
  39     if (sInstance->Init()) {
  40       ClearOnShutdown(&sInstance);
  41     } else {
  42       delete sInstance;
  43       sInstance = nullptr;
  44     }
  45   }
  46
  47   return sInstance;
  48 }
  49
  50 bool nsNameSpaceManager::Init() {
  51   nsresult rv;
  52 #define REGISTER_NAMESPACE(uri, id)        \
  53   rv = AddNameSpace(dont_AddRef(uri), id); \
  54   NS_ENSURE_SUCCESS(rv, false)
  55
  56 #define REGISTER_DISABLED_NAMESPACE(uri, id)       \
  57   rv = AddDisabledNameSpace(dont_AddRef(uri), id); \
  58   NS_ENSURE_SUCCESS(rv, false)
  59
  60   mozilla::Preferences::RegisterCallbacks(nsNameSpaceManager::PrefChanged,
  61                                           kObservedNSPrefs, this);
  62
  63   PrefChanged(nullptr);
  64
  65   // Need to be ordered according to ID.
  66   MOZ_ASSERT(mURIArray.IsEmpty());
  67   REGISTER_NAMESPACE(nsGkAtoms::_empty, kNameSpaceID_None);
  68   REGISTER_NAMESPACE(nsGkAtoms::nsuri_xmlns, kNameSpaceID_XMLNS);
  69   REGISTER_NAMESPACE(nsGkAtoms::nsuri_xml, kNameSpaceID_XML);
  70   REGISTER_NAMESPACE(nsGkAtoms::nsuri_xhtml, kNameSpaceID_XHTML);
  71   REGISTER_NAMESPACE(nsGkAtoms::nsuri_xlink, kNameSpaceID_XLink);
  72   REGISTER_NAMESPACE(nsGkAtoms::nsuri_xslt, kNameSpaceID_XSLT);
  73   REGISTER_NAMESPACE(nsGkAtoms::nsuri_mathml, kNameSpaceID_MathML);
  74   REGISTER_NAMESPACE(nsGkAtoms::nsuri_rdf, kNameSpaceID_RDF);
  75   REGISTER_NAMESPACE(nsGkAtoms::nsuri_xul, kNameSpaceID_XUL);
  76   REGISTER_NAMESPACE(nsGkAtoms::nsuri_svg, kNameSpaceID_SVG);
  77   REGISTER_DISABLED_NAMESPACE(nsGkAtoms::nsuri_mathml,
  78                               kNameSpaceID_disabled_MathML);
  79   REGISTER_DISABLED_NAMESPACE(nsGkAtoms::nsuri_svg, kNameSpaceID_disabled_SVG);
  80
  81 #undef REGISTER_NAMESPACE
  82 #undef REGISTER_DISABLED_NAMESPACE
  83
  84   return true;
  85 }
  86
  87 nsresult nsNameSpaceManager::RegisterNameSpace(const nsAString& aURI,
  88                                                int32_t& aNameSpaceID) {
  89   RefPtr<nsAtom> atom = NS_Atomize(aURI);
  90   return RegisterNameSpace(atom.forget(), aNameSpaceID);
  91 }
  92
  93 nsresult nsNameSpaceManager::RegisterNameSpace(already_AddRefed<nsAtom> aURI,
  94                                                int32_t& aNameSpaceID) {
  95   RefPtr<nsAtom> atom = aURI;
  96   nsresult rv = NS_OK;
  97   if (atom == nsGkAtoms::_empty) {
  98     aNameSpaceID = kNameSpaceID_None;  // xmlns="", see bug 75700 for details
  99     return NS_OK;
 100   }
 101
 102   if (!mURIToIDTable.Get(atom, &aNameSpaceID)) {
 103     aNameSpaceID = mURIArray.Length();
 104
 105     rv = AddNameSpace(atom.forget(), aNameSpaceID);
 106     if (NS_FAILED(rv)) {
 107       aNameSpaceID = kNameSpaceID_Unknown;
 108     }
 109   }
 110
 111   MOZ_ASSERT(aNameSpaceID >= -1, "Bogus namespace ID");
 112
 113   return rv;
 114 }
 115
 116 nsresult nsNameSpaceManager::GetNameSpaceURI(int32_t aNameSpaceID,
 117                                              nsAString& aURI) {
 118   MOZ_ASSERT(aNameSpaceID >= 0, "Bogus namespace ID");
 119
 120   // We have historically treated GetNameSpaceURI calls for kNameSpaceID_None
 121   // as erroneous.
 122   if (aNameSpaceID <= 0 || aNameSpaceID >= int32_t(mURIArray.Length())) {
 123     aURI.Truncate();
 124
 125     return NS_ERROR_ILLEGAL_VALUE;
 126   }
 127
 128   mURIArray.ElementAt(aNameSpaceID)->ToString(aURI);
 129
 130   return NS_OK;
 131 }
 132
 133 int32_t nsNameSpaceManager::GetNameSpaceID(const nsAString& aURI,
 134                                            bool aInChromeDoc) {
 135   if (aURI.IsEmpty()) {
 136     return kNameSpaceID_None;  // xmlns="", see bug 75700 for details
 137   }
 138
 139   RefPtr<nsAtom> atom = NS_Atomize(aURI);
 140   return GetNameSpaceID(atom, aInChromeDoc);
 141 }
 142
 143 int32_t nsNameSpaceManager::GetNameSpaceID(nsAtom* aURI, bool aInChromeDoc) {
 144   if (aURI == nsGkAtoms::_empty) {
 145     return kNameSpaceID_None;  // xmlns="", see bug 75700 for details
 146   }
 147
 148   int32_t nameSpaceID;
 149   if (!aInChromeDoc && (mMathMLDisabled || mSVGDisabled) &&
 150       mDisabledURIToIDTable.Get(aURI, &nameSpaceID) &&
 151       ((mMathMLDisabled && kNameSpaceID_disabled_MathML == nameSpaceID) ||
 152        (mSVGDisabled && kNameSpaceID_disabled_SVG == nameSpaceID))) {
 153     MOZ_ASSERT(nameSpaceID >= 0, "Bogus namespace ID");
 154     return nameSpaceID;
 155   }
 156   if (mURIToIDTable.Get(aURI, &nameSpaceID)) {
 157     MOZ_ASSERT(nameSpaceID >= 0, "Bogus namespace ID");
 158     return nameSpaceID;
 159   }
 160
 161   return kNameSpaceID_Unknown;
 162 }
 163
 164 // static
 165 const char* nsNameSpaceManager::GetNameSpaceDisplayName(uint32_t aNameSpaceID) {
 166   static const char* kNSURIs[] = {"([none])", "(xmlns)", "(xml)",    "(xhtml)",
 167                                   "(XLink)",  "(XSLT)",  "(MathML)", "(RDF)",
 168                                   "(XUL)",    "(SVG)"};
 169   if (aNameSpaceID < ArrayLength(kNSURIs)) {
 170     return kNSURIs[aNameSpaceID];
 171   }
 172   return "";
 173 }
 174
 175 nsresult NS_NewElement(Element** aResult,
 176                        already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
 177                        FromParser aFromParser, const nsAString* aIs) {
 178   RefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
 179   int32_t ns = ni->NamespaceID();
 180   RefPtr<nsAtom> isAtom = aIs ? NS_AtomizeMainThread(*aIs) : nullptr;
 181   if (ns == kNameSpaceID_XHTML) {
 182     return NS_NewHTMLElement(aResult, ni.forget(), aFromParser, isAtom);
 183   }
 184   if (ns == kNameSpaceID_XUL) {
 185     return NS_NewXULElement(aResult, ni.forget(), aFromParser, isAtom);
 186   }
 187   if (ns == kNameSpaceID_MathML) {
 188     // If the mathml.disabled pref. is true, convert all MathML nodes into
 189     // disabled MathML nodes by swapping the namespace.
 190     if (ni->NodeInfoManager()->MathMLEnabled()) {
 191       return NS_NewMathMLElement(aResult, ni.forget());
 192     }
 193
 194     RefPtr<mozilla::dom::NodeInfo> genericXMLNI =
 195         ni->NodeInfoManager()->GetNodeInfo(ni->NameAtom(), ni->GetPrefixAtom(),
 196                                            kNameSpaceID_disabled_MathML,
 197                                            ni->NodeType(), ni->GetExtraName());
 198     return NS_NewXMLElement(aResult, genericXMLNI.forget());
 199   }
 200   if (ns == kNameSpaceID_SVG) {
 201     // If the svg.disabled pref. is true, convert all SVG nodes into
 202     // disabled SVG nodes by swapping the namespace.
 203     if (ni->NodeInfoManager()->SVGEnabled()) {
 204       return NS_NewSVGElement(aResult, ni.forget(), aFromParser);
 205     }
 206     RefPtr<mozilla::dom::NodeInfo> genericXMLNI =
 207         ni->NodeInfoManager()->GetNodeInfo(ni->NameAtom(), ni->GetPrefixAtom(),
 208                                            kNameSpaceID_disabled_SVG,
 209                                            ni->NodeType(), ni->GetExtraName());
 210     return NS_NewXMLElement(aResult, genericXMLNI.forget());
 211   }
 212
 213   return NS_NewXMLElement(aResult, ni.forget());
 214 }
 215
 216 bool nsNameSpaceManager::HasElementCreator(int32_t aNameSpaceID) {
 217   return aNameSpaceID == kNameSpaceID_XHTML ||
 218          aNameSpaceID == kNameSpaceID_XUL ||
 219          aNameSpaceID == kNameSpaceID_MathML ||
 220          aNameSpaceID == kNameSpaceID_SVG || false;
 221 }
 222
 223 nsresult nsNameSpaceManager::AddNameSpace(already_AddRefed<nsAtom> aURI,
 224                                           const int32_t aNameSpaceID) {
 225   RefPtr<nsAtom> uri = aURI;
 226   if (aNameSpaceID < 0) {
 227     // We've wrapped...  Can't do anything else here; just bail.
 228     return NS_ERROR_OUT_OF_MEMORY;
 229   }
 230
 231   MOZ_ASSERT(aNameSpaceID == (int32_t)mURIArray.Length());
 232   mURIArray.AppendElement(uri.forget());
 233   mURIToIDTable.InsertOrUpdate(mURIArray.LastElement(), aNameSpaceID);
 234
 235   return NS_OK;
 236 }
 237
 238 nsresult nsNameSpaceManager::AddDisabledNameSpace(already_AddRefed<nsAtom> aURI,
 239                                                   const int32_t aNameSpaceID) {
 240   RefPtr<nsAtom> uri = aURI;
 241   if (aNameSpaceID < 0) {
 242     // We've wrapped...  Can't do anything else here; just bail.
 243     return NS_ERROR_OUT_OF_MEMORY;
 244   }
 245
 246   MOZ_ASSERT(aNameSpaceID == (int32_t)mURIArray.Length());
 247   mURIArray.AppendElement(uri.forget());
 248   mDisabledURIToIDTable.InsertOrUpdate(mURIArray.LastElement(), aNameSpaceID);
 249
 250   return NS_OK;
 251 }
 252
 253 // static
 254 void nsNameSpaceManager::PrefChanged(const char* aPref, void* aSelf) {
 255   static_cast<nsNameSpaceManager*>(aSelf)->PrefChanged(aPref);
 256 }
 257
 258 void nsNameSpaceManager::PrefChanged(const char* aPref) {
 259   mMathMLDisabled = mozilla::Preferences::GetBool(kPrefMathMLDisabled);
 260   mSVGDisabled = mozilla::Preferences::GetBool(kPrefSVGDisabled);
 261 }