dom/base/nsStyleLinkElement.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  *
   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 base class which implements nsIStyleSheetLinkingElement and can
   9  * be subclassed by various content nodes that want to load
  10  * stylesheets (<style>, <link>, processing instructions, etc).
  11  */
  12
  13 #include "nsStyleLinkElement.h"
  14
  15 #include "mozilla/CSSStyleSheet.h"
  16 #include "mozilla/css/Loader.h"
  17 #include "mozilla/dom/Element.h"
  18 #include "mozilla/dom/FragmentOrElement.h"
  19 #include "mozilla/dom/ShadowRoot.h"
  20 #include "mozilla/Preferences.h"
  21 #include "nsIContent.h"
  22 #include "nsIDocument.h"
  23 #include "nsIDOMComment.h"
  24 #include "nsIDOMNode.h"
  25 #include "nsIDOMStyleSheet.h"
  26 #include "nsNetUtil.h"
  27 #include "nsUnicharUtils.h"
  28 #include "nsCRT.h"
  29 #include "nsXPCOMCIDInternal.h"
  30 #include "nsUnicharInputStream.h"
  31 #include "nsContentUtils.h"
  32 #include "nsStyleUtil.h"
  33
  34 using namespace mozilla;
  35 using namespace mozilla::dom;
  36
  37 nsStyleLinkElement::nsStyleLinkElement()
  38   : mDontLoadStyle(false)
  39   , mUpdatesEnabled(true)
  40   , mLineNumber(1)
  41 {
  42 }
  43
  44 nsStyleLinkElement::~nsStyleLinkElement()
  45 {
  46   nsStyleLinkElement::SetStyleSheet(nullptr);
  47 }
  48
  49 void
  50 nsStyleLinkElement::Unlink()
  51 {
  52   mStyleSheet = nullptr;
  53 }
  54
  55 void
  56 nsStyleLinkElement::Traverse(nsCycleCollectionTraversalCallback &cb)
  57 {
  58   nsStyleLinkElement* tmp = this;
  59   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheet);
  60 }
  61
  62 NS_IMETHODIMP
  63 nsStyleLinkElement::SetStyleSheet(CSSStyleSheet* aStyleSheet)
  64 {
  65   if (mStyleSheet) {
  66     mStyleSheet->SetOwningNode(nullptr);
  67   }
  68
  69   mStyleSheet = aStyleSheet;
  70   if (mStyleSheet) {
  71     nsCOMPtr<nsINode> node = do_QueryObject(this);
  72     if (node) {
  73       mStyleSheet->SetOwningNode(node);
  74     }
  75   }
  76
  77   return NS_OK;
  78 }
  79
  80 NS_IMETHODIMP_(CSSStyleSheet*)
  81 nsStyleLinkElement::GetStyleSheet()
  82 {
  83   return mStyleSheet;
  84 }
  85
  86 NS_IMETHODIMP
  87 nsStyleLinkElement::InitStyleLinkElement(bool aDontLoadStyle)
  88 {
  89   mDontLoadStyle = aDontLoadStyle;
  90
  91   return NS_OK;
  92 }
  93
  94 NS_IMETHODIMP
  95 nsStyleLinkElement::SetEnableUpdates(bool aEnableUpdates)
  96 {
  97   mUpdatesEnabled = aEnableUpdates;
  98
  99   return NS_OK;
 100 }
 101
 102 NS_IMETHODIMP
 103 nsStyleLinkElement::GetCharset(nsAString& aCharset)
 104 {
 105   // descendants have to implement this themselves
 106   return NS_ERROR_NOT_IMPLEMENTED;
 107 }
 108
 109 /* virtual */ void
 110 nsStyleLinkElement::OverrideBaseURI(nsIURI* aNewBaseURI)
 111 {
 112   NS_NOTREACHED("Base URI can't be overriden in this implementation "
 113                 "of nsIStyleSheetLinkingElement.");
 114 }
 115
 116 /* virtual */ void
 117 nsStyleLinkElement::SetLineNumber(uint32_t aLineNumber)
 118 {
 119   mLineNumber = aLineNumber;
 120 }
 121
 122 /* static */ bool
 123 nsStyleLinkElement::IsImportEnabled(nsIPrincipal* aPrincipal)
 124 {
 125   static bool sAdded = false;
 126   static bool sWebComponentsEnabled;
 127   if (!sAdded) {
 128     // This part runs only once because of the static flag.
 129     Preferences::AddBoolVarCache(&sWebComponentsEnabled,
 130                                  "dom.webcomponents.enabled",
 131                                  false);
 132     sAdded = true;
 133   }
 134
 135   if (sWebComponentsEnabled) {
 136     return true;
 137   }
 138
 139   // If the web components pref is not enabled, check
 140   // if we are in a certified app because imports is enabled
 141   // for certified apps.
 142   return aPrincipal &&
 143     aPrincipal->GetAppStatus() == nsIPrincipal::APP_STATUS_CERTIFIED;
 144 }
 145
 146 static uint32_t ToLinkMask(const nsAString& aLink, nsIPrincipal* aPrincipal)
 147 {
 148   if (aLink.EqualsLiteral("prefetch"))
 149     return nsStyleLinkElement::ePREFETCH;
 150   else if (aLink.EqualsLiteral("dns-prefetch"))
 151     return nsStyleLinkElement::eDNS_PREFETCH;
 152   else if (aLink.EqualsLiteral("stylesheet"))
 153     return nsStyleLinkElement::eSTYLESHEET;
 154   else if (aLink.EqualsLiteral("next"))
 155     return nsStyleLinkElement::eNEXT;
 156   else if (aLink.EqualsLiteral("alternate"))
 157     return nsStyleLinkElement::eALTERNATE;
 158   else if (aLink.EqualsLiteral("import") && aPrincipal &&
 159            nsStyleLinkElement::IsImportEnabled(aPrincipal))
 160     return nsStyleLinkElement::eHTMLIMPORT;
 161   else
 162     return 0;
 163 }
 164
 165 uint32_t nsStyleLinkElement::ParseLinkTypes(const nsAString& aTypes, nsIPrincipal* aPrincipal)
 166 {
 167   uint32_t linkMask = 0;
 168   nsAString::const_iterator start, done;
 169   aTypes.BeginReading(start);
 170   aTypes.EndReading(done);
 171   if (start == done)
 172     return linkMask;
 173
 174   nsAString::const_iterator current(start);
 175   bool inString = !nsContentUtils::IsHTMLWhitespace(*current);
 176   nsAutoString subString;
 177
 178   while (current != done) {
 179     if (nsContentUtils::IsHTMLWhitespace(*current)) {
 180       if (inString) {
 181         nsContentUtils::ASCIIToLower(Substring(start, current), subString);
 182         linkMask |= ToLinkMask(subString, aPrincipal);
 183         inString = false;
 184       }
 185     }
 186     else {
 187       if (!inString) {
 188         start = current;
 189         inString = true;
 190       }
 191     }
 192     ++current;
 193   }
 194   if (inString) {
 195     nsContentUtils::ASCIIToLower(Substring(start, current), subString);
 196     linkMask |= ToLinkMask(subString, aPrincipal);
 197   }
 198   return linkMask;
 199 }
 200
 201 NS_IMETHODIMP
 202 nsStyleLinkElement::UpdateStyleSheet(nsICSSLoaderObserver* aObserver,
 203                                      bool* aWillNotify,
 204                                      bool* aIsAlternate,
 205                                      bool aForceReload)
 206 {
 207   if (aForceReload) {
 208     // We remove this stylesheet from the cache to load a new version.
 209     nsCOMPtr<nsIContent> thisContent;
 210     CallQueryInterface(this, getter_AddRefs(thisContent));
 211     nsCOMPtr<nsIDocument> doc = thisContent->IsInShadowTree() ?
 212       thisContent->OwnerDoc() : thisContent->GetUncomposedDoc();
 213     if (doc && doc->CSSLoader()->GetEnabled() &&
 214         mStyleSheet && mStyleSheet->GetOriginalURI()) {
 215       doc->CSSLoader()->ObsoleteSheet(mStyleSheet->GetOriginalURI());
 216     }
 217   }
 218   return DoUpdateStyleSheet(nullptr, nullptr, aObserver, aWillNotify,
 219                             aIsAlternate, aForceReload);
 220 }
 221
 222 nsresult
 223 nsStyleLinkElement::UpdateStyleSheetInternal(nsIDocument *aOldDocument,
 224                                              ShadowRoot *aOldShadowRoot,
 225                                              bool aForceUpdate)
 226 {
 227   bool notify, alternate;
 228   return DoUpdateStyleSheet(aOldDocument, aOldShadowRoot, nullptr, &notify,
 229                             &alternate, aForceUpdate);
 230 }
 231
 232 static bool
 233 IsScopedStyleElement(nsIContent* aContent)
 234 {
 235   // This is quicker than, say, QIing aContent to nsStyleLinkElement
 236   // and then calling its virtual GetStyleSheetInfo method to find out
 237   // if it is scoped.
 238   return (aContent->IsHTML(nsGkAtoms::style) ||
 239           aContent->IsSVG(nsGkAtoms::style)) &&
 240          aContent->HasAttr(kNameSpaceID_None, nsGkAtoms::scoped);
 241 }
 242
 243 static bool
 244 HasScopedStyleSheetChild(nsIContent* aContent)
 245 {
 246   for (nsIContent* n = aContent->GetFirstChild(); n; n = n->GetNextSibling()) {
 247     if (IsScopedStyleElement(n)) {
 248       return true;
 249     }
 250   }
 251   return false;
 252 }
 253
 254 // Called when aElement has had a <style scoped> child removed.
 255 static void
 256 UpdateIsElementInStyleScopeFlagOnSubtree(Element* aElement)
 257 {
 258   NS_ASSERTION(aElement->IsElementInStyleScope(),
 259                "only call UpdateIsElementInStyleScopeFlagOnSubtree on a "
 260                "subtree that has IsElementInStyleScope boolean flag set");
 261
 262   if (HasScopedStyleSheetChild(aElement)) {
 263     return;
 264   }
 265
 266   aElement->ClearIsElementInStyleScope();
 267
 268   nsIContent* n = aElement->GetNextNode(aElement);
 269   while (n) {
 270     if (HasScopedStyleSheetChild(n)) {
 271       n = n->GetNextNonChildNode(aElement);
 272     } else {
 273       if (n->IsElement()) {
 274         n->ClearIsElementInStyleScope();
 275       }
 276       n = n->GetNextNode(aElement);
 277     }
 278   }
 279 }
 280
 281 static Element*
 282 GetScopeElement(nsIStyleSheet* aSheet)
 283 {
 284   nsRefPtr<CSSStyleSheet> cssStyleSheet = do_QueryObject(aSheet);
 285   if (!cssStyleSheet) {
 286     return nullptr;
 287   }
 288
 289   return cssStyleSheet->GetScopeElement();
 290 }
 291
 292 nsresult
 293 nsStyleLinkElement::DoUpdateStyleSheet(nsIDocument* aOldDocument,
 294                                        ShadowRoot* aOldShadowRoot,
 295                                        nsICSSLoaderObserver* aObserver,
 296                                        bool* aWillNotify,
 297                                        bool* aIsAlternate,
 298                                        bool aForceUpdate)
 299 {
 300   *aWillNotify = false;
 301
 302   nsCOMPtr<nsIContent> thisContent;
 303   CallQueryInterface(this, getter_AddRefs(thisContent));
 304
 305   // All instances of nsStyleLinkElement should implement nsIContent.
 306   NS_ENSURE_TRUE(thisContent, NS_ERROR_FAILURE);
 307
 308   if (thisContent->IsInAnonymousSubtree() &&
 309       thisContent->IsAnonymousContentInSVGUseSubtree()) {
 310     // Stylesheets in <use>-cloned subtrees are disabled until we figure out
 311     // how they should behave.
 312     return NS_OK;
 313   }
 314
 315   // Check for a ShadowRoot because link elements are inert in a
 316   // ShadowRoot.
 317   ShadowRoot* containingShadow = thisContent->GetContainingShadow();
 318   if (thisContent->IsHTML(nsGkAtoms::link) &&
 319       (aOldShadowRoot || containingShadow)) {
 320     return NS_OK;
 321   }
 322
 323   Element* oldScopeElement = GetScopeElement(mStyleSheet);
 324
 325   if (mStyleSheet && (aOldDocument || aOldShadowRoot)) {
 326     MOZ_ASSERT(!(aOldDocument && aOldShadowRoot),
 327                "ShadowRoot content is never in document, thus "
 328                "there should not be a old document and old "
 329                "ShadowRoot simultaneously.");
 330
 331     // We're removing the link element from the document or shadow tree,
 332     // unload the stylesheet.  We want to do this even if updates are
 333     // disabled, since otherwise a sheet with a stale linking element pointer
 334     // will be hanging around -- not good!
 335     if (aOldShadowRoot) {
 336       aOldShadowRoot->RemoveSheet(mStyleSheet);
 337     } else {
 338       aOldDocument->BeginUpdate(UPDATE_STYLE);
 339       aOldDocument->RemoveStyleSheet(mStyleSheet);
 340       aOldDocument->EndUpdate(UPDATE_STYLE);
 341     }
 342
 343     nsStyleLinkElement::SetStyleSheet(nullptr);
 344     if (oldScopeElement) {
 345       UpdateIsElementInStyleScopeFlagOnSubtree(oldScopeElement);
 346     }
 347   }
 348
 349   // When static documents are created, stylesheets are cloned manually.
 350   if (mDontLoadStyle || !mUpdatesEnabled ||
 351       thisContent->OwnerDoc()->IsStaticDocument()) {
 352     return NS_OK;
 353   }
 354
 355   nsCOMPtr<nsIDocument> doc = thisContent->IsInShadowTree() ?
 356     thisContent->OwnerDoc() : thisContent->GetUncomposedDoc();
 357   if (!doc || !doc->CSSLoader()->GetEnabled()) {
 358     return NS_OK;
 359   }
 360
 361   bool isInline;
 362   nsCOMPtr<nsIURI> uri = GetStyleSheetURL(&isInline);
 363
 364   if (!aForceUpdate && mStyleSheet && !isInline && uri) {
 365     nsIURI* oldURI = mStyleSheet->GetSheetURI();
 366     if (oldURI) {
 367       bool equal;
 368       nsresult rv = oldURI->Equals(uri, &equal);
 369       if (NS_SUCCEEDED(rv) && equal) {
 370         return NS_OK; // We already loaded this stylesheet
 371       }
 372     }
 373   }
 374
 375   if (mStyleSheet) {
 376     if (thisContent->IsInShadowTree()) {
 377       ShadowRoot* containingShadow = thisContent->GetContainingShadow();
 378       containingShadow->RemoveSheet(mStyleSheet);
 379     } else {
 380       doc->BeginUpdate(UPDATE_STYLE);
 381       doc->RemoveStyleSheet(mStyleSheet);
 382       doc->EndUpdate(UPDATE_STYLE);
 383     }
 384
 385     nsStyleLinkElement::SetStyleSheet(nullptr);
 386   }
 387
 388   if (!uri && !isInline) {
 389     return NS_OK; // If href is empty and this is not inline style then just bail
 390   }
 391
 392   nsAutoString title, type, media;
 393   bool isScoped;
 394   bool isAlternate;
 395
 396   GetStyleSheetInfo(title, type, media, &isScoped, &isAlternate);
 397
 398   if (!type.LowerCaseEqualsLiteral("text/css")) {
 399     return NS_OK;
 400   }
 401
 402   Element* scopeElement = isScoped ? thisContent->GetParentElement() : nullptr;
 403   if (scopeElement) {
 404     NS_ASSERTION(isInline, "non-inline style must not have scope element");
 405     scopeElement->SetIsElementInStyleScopeFlagOnSubtree(true);
 406   }
 407
 408   bool doneLoading = false;
 409   nsresult rv = NS_OK;
 410   if (isInline) {
 411     nsAutoString text;
 412     if (!nsContentUtils::GetNodeTextContent(thisContent, false, text)) {
 413       return NS_ERROR_OUT_OF_MEMORY;
 414     }
 415
 416     MOZ_ASSERT(thisContent->Tag() != nsGkAtoms::link,
 417                "<link> is not 'inline', and needs different CSP checks");
 418     if (!nsStyleUtil::CSPAllowsInlineStyle(thisContent,
 419                                            thisContent->NodePrincipal(),
 420                                            doc->GetDocumentURI(),
 421                                            mLineNumber, text, &rv))
 422       return rv;
 423
 424     // Parse the style sheet.
 425     rv = doc->CSSLoader()->
 426       LoadInlineStyle(thisContent, text, mLineNumber, title, media,
 427                       scopeElement, aObserver, &doneLoading, &isAlternate);
 428   }
 429   else {
 430     // XXXbz clone the URI here to work around content policies modifying URIs.
 431     nsCOMPtr<nsIURI> clonedURI;
 432     uri->Clone(getter_AddRefs(clonedURI));
 433     NS_ENSURE_TRUE(clonedURI, NS_ERROR_OUT_OF_MEMORY);
 434     rv = doc->CSSLoader()->
 435       LoadStyleLink(thisContent, clonedURI, title, media, isAlternate,
 436                     GetCORSMode(), doc->GetReferrerPolicy(),
 437                     aObserver, &isAlternate);
 438     if (NS_FAILED(rv)) {
 439       // Don't propagate LoadStyleLink() errors further than this, since some
 440       // consumers (e.g. nsXMLContentSink) will completely abort on innocuous
 441       // things like a stylesheet load being blocked by the security system.
 442       doneLoading = true;
 443       isAlternate = false;
 444       rv = NS_OK;
 445     }
 446   }
 447
 448   NS_ENSURE_SUCCESS(rv, rv);
 449
 450   *aWillNotify = !doneLoading;
 451   *aIsAlternate = isAlternate;
 452
 453   return NS_OK;
 454 }
 455
 456 void
 457 nsStyleLinkElement::UpdateStyleSheetScopedness(bool aIsNowScoped)
 458 {
 459   if (!mStyleSheet) {
 460     return;
 461   }
 462
 463   nsCOMPtr<nsIContent> thisContent;
 464   CallQueryInterface(this, getter_AddRefs(thisContent));
 465
 466   Element* oldScopeElement = mStyleSheet->GetScopeElement();
 467   Element* newScopeElement = aIsNowScoped ?
 468                                thisContent->GetParentElement() :
 469                                nullptr;
 470
 471   if (oldScopeElement == newScopeElement) {
 472     return;
 473   }
 474
 475   nsIDocument* document = thisContent->GetOwnerDocument();
 476
 477   if (thisContent->IsInShadowTree()) {
 478     ShadowRoot* containingShadow = thisContent->GetContainingShadow();
 479     containingShadow->RemoveSheet(mStyleSheet);
 480
 481     mStyleSheet->SetScopeElement(newScopeElement);
 482
 483     containingShadow->InsertSheet(mStyleSheet, thisContent);
 484   } else {
 485     document->BeginUpdate(UPDATE_STYLE);
 486     document->RemoveStyleSheet(mStyleSheet);
 487
 488     mStyleSheet->SetScopeElement(newScopeElement);
 489
 490     document->AddStyleSheet(mStyleSheet);
 491     document->EndUpdate(UPDATE_STYLE);
 492   }
 493
 494   if (oldScopeElement) {
 495     UpdateIsElementInStyleScopeFlagOnSubtree(oldScopeElement);
 496   }
 497   if (newScopeElement) {
 498     newScopeElement->SetIsElementInStyleScopeFlagOnSubtree(true);
 499   }
 500 }