dom/xml/nsXMLContentSink.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 #include "nsCOMPtr.h"
   8 #include "nsXMLContentSink.h"
   9 #include "nsIParser.h"
  10 #include "mozilla/dom/Document.h"
  11 #include "nsIContent.h"
  12 #include "nsIURI.h"
  13 #include "nsNetUtil.h"
  14 #include "nsHTMLParts.h"
  15 #include "nsCRT.h"
  16 #include "mozilla/StyleSheetInlines.h"
  17 #include "mozilla/css/Loader.h"
  18 #include "nsGkAtoms.h"
  19 #include "nsContentUtils.h"
  20 #include "nsDocElementCreatedNotificationRunner.h"
  21 #include "nsIDocShell.h"
  22 #include "nsIScriptContext.h"
  23 #include "nsNameSpaceManager.h"
  24 #include "nsIScriptSecurityManager.h"
  25 #include "nsIContentViewer.h"
  26 #include "prtime.h"
  27 #include "mozilla/Logging.h"
  28 #include "nsRect.h"
  29 #include "nsIScriptElement.h"
  30 #include "nsReadableUtils.h"
  31 #include "nsUnicharUtils.h"
  32 #include "nsIChannel.h"
  33 #include "nsXMLPrettyPrinter.h"
  34 #include "nsNodeInfoManager.h"
  35 #include "nsContentCreatorFunctions.h"
  36 #include "nsIContentPolicy.h"
  37 #include "nsContentPolicyUtils.h"
  38 #include "nsError.h"
  39 #include "nsIScriptGlobalObject.h"
  40 #include "mozAutoDocUpdate.h"
  41 #include "nsMimeTypes.h"
  42 #include "nsHtml5SVGLoadDispatcher.h"
  43 #include "nsTextNode.h"
  44 #include "mozilla/dom/CDATASection.h"
  45 #include "mozilla/dom/Comment.h"
  46 #include "mozilla/dom/DocumentType.h"
  47 #include "mozilla/dom/Element.h"
  48 #include "mozilla/dom/HTMLTemplateElement.h"
  49 #include "mozilla/dom/MutationObservers.h"
  50 #include "mozilla/dom/ProcessingInstruction.h"
  51 #include "mozilla/dom/ScriptLoader.h"
  52 #include "mozilla/dom/txMozillaXSLTProcessor.h"
  53 #include "mozilla/CycleCollectedJSContext.h"
  54 #include "mozilla/LoadInfo.h"
  55 #include "mozilla/UseCounter.h"
  56
  57 using namespace mozilla;
  58 using namespace mozilla::dom;
  59
  60 // XXX Open Issues:
  61 // 1) what's not allowed - We need to figure out which HTML tags
  62 //    (prefixed with a HTML namespace qualifier) are explicitly not
  63 //    allowed (if any).
  64 // 2) factoring code with nsHTMLContentSink - There's some amount of
  65 //    common code between this and the HTML content sink. This will
  66 //    increase as we support more and more HTML elements. How can code
  67 //    from the code be factored?
  68
  69 nsresult NS_NewXMLContentSink(nsIXMLContentSink** aResult, Document* aDoc,
  70                               nsIURI* aURI, nsISupports* aContainer,
  71                               nsIChannel* aChannel) {
  72   MOZ_ASSERT(nullptr != aResult, "null ptr");
  73   if (nullptr == aResult) {
  74     return NS_ERROR_NULL_POINTER;
  75   }
  76   RefPtr<nsXMLContentSink> it = new nsXMLContentSink();
  77
  78   nsresult rv = it->Init(aDoc, aURI, aContainer, aChannel);
  79   NS_ENSURE_SUCCESS(rv, rv);
  80
  81   it.forget(aResult);
  82   return NS_OK;
  83 }
  84
  85 nsXMLContentSink::nsXMLContentSink()
  86     : mState(eXMLContentSinkState_InProlog),
  87       mTextLength(0),
  88       mNotifyLevel(0),
  89       mPrettyPrintXML(true),
  90       mPrettyPrintHasSpecialRoot(0),
  91       mPrettyPrintHasFactoredElements(0),
  92       mPrettyPrinting(0),
  93       mPreventScriptExecution(0) {
  94   PodArrayZero(mText);
  95 }
  96
  97 nsXMLContentSink::~nsXMLContentSink() = default;
  98
  99 nsresult nsXMLContentSink::Init(Document* aDoc, nsIURI* aURI,
 100                                 nsISupports* aContainer, nsIChannel* aChannel) {
 101   nsresult rv = nsContentSink::Init(aDoc, aURI, aContainer, aChannel);
 102   NS_ENSURE_SUCCESS(rv, rv);
 103
 104   aDoc->AddObserver(this);
 105   mIsDocumentObserver = true;
 106
 107   if (!mDocShell) {
 108     mPrettyPrintXML = false;
 109   }
 110
 111   mState = eXMLContentSinkState_InProlog;
 112   mDocElement = nullptr;
 113
 114   return NS_OK;
 115 }
 116
 117 inline void ImplCycleCollectionTraverse(
 118     nsCycleCollectionTraversalCallback& aCallback,
 119     nsXMLContentSink::StackNode& aField, const char* aName,
 120     uint32_t aFlags = 0) {
 121   ImplCycleCollectionTraverse(aCallback, aField.mContent, aName, aFlags);
 122 }
 123
 124 inline void ImplCycleCollectionUnlink(nsXMLContentSink::StackNode& aField) {
 125   ImplCycleCollectionUnlink(aField.mContent);
 126 }
 127
 128 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsXMLContentSink)
 129   NS_INTERFACE_MAP_ENTRY(nsIContentSink)
 130   NS_INTERFACE_MAP_ENTRY(nsIXMLContentSink)
 131   NS_INTERFACE_MAP_ENTRY(nsIExpatSink)
 132   NS_INTERFACE_MAP_ENTRY(nsITransformObserver)
 133 NS_INTERFACE_MAP_END_INHERITING(nsContentSink)
 134
 135 NS_IMPL_ADDREF_INHERITED(nsXMLContentSink, nsContentSink)
 136 NS_IMPL_RELEASE_INHERITED(nsXMLContentSink, nsContentSink)
 137
 138 NS_IMPL_CYCLE_COLLECTION_INHERITED(nsXMLContentSink, nsContentSink,
 139                                    mCurrentHead, mDocElement, mLastTextNode,
 140                                    mContentStack, mDocumentChildren)
 141
 142 // nsIContentSink
 143 NS_IMETHODIMP
 144 nsXMLContentSink::WillParse(void) { return WillParseImpl(); }
 145
 146 NS_IMETHODIMP
 147 nsXMLContentSink::WillBuildModel(nsDTDMode aDTDMode) {
 148   WillBuildModelImpl();
 149
 150   // Notify document that the load is beginning
 151   mDocument->BeginLoad();
 152
 153   // Check for correct load-command for maybe prettyprinting
 154   if (mPrettyPrintXML) {
 155     nsAutoCString command;
 156     GetParser()->GetCommand(command);
 157     if (!command.EqualsLiteral("view")) {
 158       mPrettyPrintXML = false;
 159     }
 160   }
 161
 162   return NS_OK;
 163 }
 164
 165 bool nsXMLContentSink::CanStillPrettyPrint() {
 166   return mPrettyPrintXML &&
 167          (!mPrettyPrintHasFactoredElements || mPrettyPrintHasSpecialRoot);
 168 }
 169
 170 nsresult nsXMLContentSink::MaybePrettyPrint() {
 171   if (!CanStillPrettyPrint()) {
 172     mPrettyPrintXML = false;
 173
 174     return NS_OK;
 175   }
 176
 177   {
 178     // Try to perform a microtask checkpoint; this avoids always breaking
 179     // pretty-printing if webextensions insert new content right after the
 180     // document loads.
 181     nsAutoMicroTask mt;
 182   }
 183
 184   // stop observing in order to avoid crashing when replacing content
 185   mDocument->RemoveObserver(this);
 186   mIsDocumentObserver = false;
 187
 188   // Reenable the CSSLoader so that the prettyprinting stylesheets can load
 189   if (mCSSLoader) {
 190     mCSSLoader->SetEnabled(true);
 191   }
 192
 193   RefPtr<nsXMLPrettyPrinter> printer;
 194   nsresult rv = NS_NewXMLPrettyPrinter(getter_AddRefs(printer));
 195   NS_ENSURE_SUCCESS(rv, rv);
 196
 197   bool isPrettyPrinting;
 198   rv = printer->PrettyPrint(mDocument, &isPrettyPrinting);
 199   NS_ENSURE_SUCCESS(rv, rv);
 200
 201   mPrettyPrinting = isPrettyPrinting;
 202   return NS_OK;
 203 }
 204
 205 static void CheckXSLTParamPI(ProcessingInstruction* aPi,
 206                              nsIDocumentTransformer* aProcessor,
 207                              nsINode* aSource) {
 208   nsAutoString target, data;
 209   aPi->GetTarget(target);
 210
 211   // Check for namespace declarations
 212   if (target.EqualsLiteral("xslt-param-namespace")) {
 213     aPi->GetData(data);
 214     nsAutoString prefix, namespaceAttr;
 215     nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::prefix, prefix);
 216     if (!prefix.IsEmpty() && nsContentUtils::GetPseudoAttributeValue(
 217                                  data, nsGkAtoms::_namespace, namespaceAttr)) {
 218       aProcessor->AddXSLTParamNamespace(prefix, namespaceAttr);
 219     }
 220   }
 221
 222   // Check for actual parameters
 223   else if (target.EqualsLiteral("xslt-param")) {
 224     aPi->GetData(data);
 225     nsAutoString name, namespaceAttr, select, value;
 226     nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::name, name);
 227     nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::_namespace,
 228                                             namespaceAttr);
 229     if (!nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::select,
 230                                                  select)) {
 231       select.SetIsVoid(true);
 232     }
 233     if (!nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::value,
 234                                                  value)) {
 235       value.SetIsVoid(true);
 236     }
 237     if (!name.IsEmpty()) {
 238       aProcessor->AddXSLTParam(name, namespaceAttr, select, value, aSource);
 239     }
 240   }
 241 }
 242
 243 NS_IMETHODIMP
 244 nsXMLContentSink::DidBuildModel(bool aTerminated) {
 245   if (!mParser) {
 246     // If mParser is null, this parse has already been terminated and must
 247     // not been terminated again. However, Document may still think that
 248     // the parse has not been terminated and call back into here in the case
 249     // where the XML parser has finished but the XSLT transform associated
 250     // with the document has not.
 251     return NS_OK;
 252   }
 253
 254   FlushTags();
 255
 256   DidBuildModelImpl(aTerminated);
 257
 258   if (mXSLTProcessor) {
 259     // stop observing in order to avoid crashing when replacing content
 260     mDocument->RemoveObserver(this);
 261     mIsDocumentObserver = false;
 262
 263     ErrorResult rv;
 264     RefPtr<DocumentFragment> source = mDocument->CreateDocumentFragment();
 265     for (nsIContent* child : mDocumentChildren) {
 266       // XPath data model doesn't have DocumentType nodes.
 267       if (child->NodeType() != nsINode::DOCUMENT_TYPE_NODE) {
 268         source->AppendChild(*child, rv);
 269         if (rv.Failed()) {
 270           return rv.StealNSResult();
 271         }
 272       }
 273     }
 274
 275     // Check for xslt-param and xslt-param-namespace PIs
 276     for (nsIContent* child : mDocumentChildren) {
 277       if (auto pi = ProcessingInstruction::FromNode(child)) {
 278         CheckXSLTParamPI(pi, mXSLTProcessor, source);
 279       } else if (child->IsElement()) {
 280         // Only honor PIs in the prolog
 281         break;
 282       }
 283     }
 284
 285     mXSLTProcessor->SetSourceContentModel(source);
 286     // Since the processor now holds a reference to us we drop our reference
 287     // to it to avoid owning cycles
 288     mXSLTProcessor = nullptr;
 289   } else {
 290     // Kick off layout for non-XSLT transformed documents.
 291
 292     // Check if we want to prettyprint
 293     MaybePrettyPrint();
 294
 295     bool startLayout = true;
 296
 297     if (mPrettyPrinting) {
 298       NS_ASSERTION(!mPendingSheetCount, "Shouldn't have pending sheets here!");
 299
 300       // We're pretty-printing now.  See whether we should wait up on
 301       // stylesheet loads
 302       if (mDocument->CSSLoader()->HasPendingLoads()) {
 303         mDocument->CSSLoader()->AddObserver(this);
 304         // wait for those sheets to load
 305         startLayout = false;
 306       }
 307     }
 308
 309     if (startLayout) {
 310       StartLayout(false);
 311
 312       ScrollToRef();
 313     }
 314
 315     mDocument->RemoveObserver(this);
 316     mIsDocumentObserver = false;
 317
 318     mDocument->EndLoad();
 319
 320     DropParserAndPerfHint();
 321   }
 322
 323   return NS_OK;
 324 }
 325
 326 nsresult nsXMLContentSink::OnDocumentCreated(Document* aSourceDocument,
 327                                              Document* aResultDocument) {
 328   aResultDocument->SetDocWriteDisabled(true);
 329
 330   nsCOMPtr<nsIContentViewer> contentViewer;
 331   mDocShell->GetContentViewer(getter_AddRefs(contentViewer));
 332   // Make sure that we haven't loaded a new document into the contentviewer
 333   // after starting the XSLT transform.
 334   if (contentViewer && contentViewer->GetDocument() == aSourceDocument) {
 335     return contentViewer->SetDocumentInternal(aResultDocument, true);
 336   }
 337   return NS_OK;
 338 }
 339
 340 nsresult nsXMLContentSink::OnTransformDone(Document* aSourceDocument,
 341                                            nsresult aResult,
 342                                            Document* aResultDocument) {
 343   MOZ_ASSERT(aResultDocument,
 344              "Don't notify about transform end without a document.");
 345
 346   mDocumentChildren.Clear();
 347
 348   nsCOMPtr<nsIContentViewer> contentViewer;
 349   mDocShell->GetContentViewer(getter_AddRefs(contentViewer));
 350
 351   RefPtr<Document> originalDocument = mDocument;
 352   bool blockingOnload = mIsBlockingOnload;
 353
 354   // Make sure that we haven't loaded a new document into the contentviewer
 355   // after starting the XSLT transform.
 356   if (contentViewer && (contentViewer->GetDocument() == aSourceDocument ||
 357                         contentViewer->GetDocument() == aResultDocument)) {
 358     if (NS_FAILED(aResult)) {
 359       // Transform failed.
 360       aResultDocument->SetMayStartLayout(false);
 361       // We have an error document.
 362       contentViewer->SetDocument(aResultDocument);
 363     }
 364
 365     if (!mRunsToCompletion) {
 366       // This BlockOnload call corresponds to the UnblockOnload call in
 367       // nsContentSink::DropParserAndPerfHint.
 368       aResultDocument->BlockOnload();
 369       mIsBlockingOnload = true;
 370     }
 371     // Transform succeeded, or it failed and we have an error document to
 372     // display.
 373     mDocument = aResultDocument;
 374     aResultDocument->SetDocWriteDisabled(false);
 375
 376     // Notify document observers that all the content has been stuck
 377     // into the document.
 378     // XXX do we need to notify for things like PIs?  Or just the
 379     // documentElement?
 380     nsIContent* rootElement = mDocument->GetRootElement();
 381     if (rootElement) {
 382       NS_ASSERTION(mDocument->ComputeIndexOf(rootElement).isSome(),
 383                    "rootElement not in doc?");
 384       mDocument->BeginUpdate();
 385       MutationObservers::NotifyContentInserted(mDocument, rootElement);
 386       mDocument->EndUpdate();
 387     }
 388
 389     // Start the layout process
 390     StartLayout(false);
 391
 392     ScrollToRef();
 393   }
 394
 395   originalDocument->EndLoad();
 396   if (blockingOnload) {
 397     // This UnblockOnload call corresponds to the BlockOnload call in
 398     // nsContentSink::WillBuildModelImpl.
 399     originalDocument->UnblockOnload(true);
 400   }
 401
 402   DropParserAndPerfHint();
 403
 404   // By this point, the result document has been set in the content viewer.  But
 405   // the content viewer does not call Destroy on the original document, so we
 406   // won't end up reporting document use counters.  It's possible we should be
 407   // detaching the document from the window, but for now, we call
 408   // ReportDocumentUseCounters on the original document here, to avoid
 409   // assertions in ~Document about not having reported them.
 410   originalDocument->ReportDocumentUseCounters();
 411
 412   return NS_OK;
 413 }
 414
 415 NS_IMETHODIMP
 416 nsXMLContentSink::StyleSheetLoaded(StyleSheet* aSheet, bool aWasDeferred,
 417                                    nsresult aStatus) {
 418   if (!mPrettyPrinting) {
 419     return nsContentSink::StyleSheetLoaded(aSheet, aWasDeferred, aStatus);
 420   }
 421
 422   if (!mDocument->CSSLoader()->HasPendingLoads()) {
 423     mDocument->CSSLoader()->RemoveObserver(this);
 424     StartLayout(false);
 425     ScrollToRef();
 426   }
 427
 428   return NS_OK;
 429 }
 430
 431 NS_IMETHODIMP
 432 nsXMLContentSink::WillInterrupt(void) { return WillInterruptImpl(); }
 433
 434 void nsXMLContentSink::WillResume() { WillResumeImpl(); }
 435
 436 NS_IMETHODIMP
 437 nsXMLContentSink::SetParser(nsParserBase* aParser) {
 438   MOZ_ASSERT(aParser, "Should have a parser here!");
 439   mParser = aParser;
 440   return NS_OK;
 441 }
 442
 443 static bool FindIsAttrValue(const char16_t** aAtts, const char16_t** aResult) {
 444   RefPtr<nsAtom> prefix, localName;
 445   for (; *aAtts; aAtts += 2) {
 446     int32_t nameSpaceID;
 447     nsContentUtils::SplitExpatName(aAtts[0], getter_AddRefs(prefix),
 448                                    getter_AddRefs(localName), &nameSpaceID);
 449     if (nameSpaceID == kNameSpaceID_None && localName == nsGkAtoms::is) {
 450       *aResult = aAtts[1];
 451
 452       return true;
 453     }
 454   }
 455
 456   return false;
 457 }
 458
 459 nsresult nsXMLContentSink::CreateElement(
 460     const char16_t** aAtts, uint32_t aAttsCount,
 461     mozilla::dom::NodeInfo* aNodeInfo, uint32_t aLineNumber,
 462     uint32_t aColumnNumber, nsIContent** aResult, bool* aAppendContent,
 463     FromParser aFromParser) {
 464   NS_ASSERTION(aNodeInfo, "can't create element without nodeinfo");
 465
 466   *aResult = nullptr;
 467   *aAppendContent = true;
 468   nsresult rv = NS_OK;
 469
 470   RefPtr<mozilla::dom::NodeInfo> ni = aNodeInfo;
 471   RefPtr<Element> element;
 472
 473   const char16_t* is = nullptr;
 474   if ((aNodeInfo->NamespaceEquals(kNameSpaceID_XHTML) ||
 475        aNodeInfo->NamespaceEquals(kNameSpaceID_XUL)) &&
 476       FindIsAttrValue(aAtts, &is)) {
 477     const nsDependentString isStr(is);
 478     rv = NS_NewElement(getter_AddRefs(element), ni.forget(), aFromParser,
 479                        &isStr);
 480   } else {
 481     rv = NS_NewElement(getter_AddRefs(element), ni.forget(), aFromParser);
 482   }
 483
 484   NS_ENSURE_SUCCESS(rv, rv);
 485
 486   if (aNodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_XHTML) ||
 487       aNodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_SVG)) {
 488     if (nsCOMPtr<nsIScriptElement> sele = do_QueryInterface(element)) {
 489       sele->SetScriptLineNumber(aLineNumber);
 490       sele->SetScriptColumnNumber(aColumnNumber);
 491       sele->SetCreatorParser(GetParser());
 492     } else {
 493       MOZ_ASSERT(nsNameSpaceManager::GetInstance()->mSVGDisabled,
 494                  "Node didn't QI to script, but SVG wasn't disabled.");
 495     }
 496   }
 497
 498   // XHTML needs some special attention
 499   if (aNodeInfo->NamespaceEquals(kNameSpaceID_XHTML)) {
 500     mPrettyPrintHasFactoredElements = true;
 501   } else {
 502     // If we care, find out if we just used a special factory.
 503     if (!mPrettyPrintHasFactoredElements && !mPrettyPrintHasSpecialRoot &&
 504         mPrettyPrintXML) {
 505       mPrettyPrintHasFactoredElements =
 506           nsNameSpaceManager::GetInstance()->HasElementCreator(
 507               aNodeInfo->NamespaceID());
 508     }
 509
 510     if (!aNodeInfo->NamespaceEquals(kNameSpaceID_SVG)) {
 511       element.forget(aResult);
 512       return NS_OK;
 513     }
 514   }
 515
 516   if (auto* linkStyle = LinkStyle::FromNode(*element)) {
 517     if (aFromParser) {
 518       linkStyle->DisableUpdates();
 519     }
 520     if (!aNodeInfo->Equals(nsGkAtoms::link, kNameSpaceID_XHTML)) {
 521       linkStyle->SetLineNumber(aFromParser ? aLineNumber : 0);
 522       linkStyle->SetColumnNumber(aFromParser ? aColumnNumber : 0);
 523     }
 524   }
 525
 526   element.forget(aResult);
 527   return NS_OK;
 528 }
 529
 530 nsresult nsXMLContentSink::CloseElement(nsIContent* aContent) {
 531   NS_ASSERTION(aContent, "missing element to close");
 532
 533   mozilla::dom::NodeInfo* nodeInfo = aContent->NodeInfo();
 534
 535   // Some HTML nodes need DoneAddingChildren() called to initialize
 536   // properly (eg form state restoration).
 537   if (nsIContent::RequiresDoneAddingChildren(nodeInfo->NamespaceID(),
 538                                              nodeInfo->NameAtom())) {
 539     aContent->DoneAddingChildren(HaveNotifiedForCurrentContent());
 540   }
 541
 542   if (IsMonolithicContainer(nodeInfo)) {
 543     mInMonolithicContainer--;
 544   }
 545
 546   if (!nodeInfo->NamespaceEquals(kNameSpaceID_XHTML) &&
 547       !nodeInfo->NamespaceEquals(kNameSpaceID_SVG)) {
 548     return NS_OK;
 549   }
 550
 551   if (nodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_XHTML) ||
 552       nodeInfo->Equals(nsGkAtoms::script, kNameSpaceID_SVG)) {
 553     nsCOMPtr<nsIScriptElement> sele = do_QueryInterface(aContent);
 554     if (!sele) {
 555       MOZ_ASSERT(nsNameSpaceManager::GetInstance()->mSVGDisabled,
 556                  "Node didn't QI to script, but SVG wasn't disabled.");
 557       return NS_OK;
 558     }
 559
 560     if (mPreventScriptExecution) {
 561       sele->PreventExecution();
 562       return NS_OK;
 563     }
 564
 565     // Always check the clock in nsContentSink right after a script
 566     StopDeflecting();
 567
 568     // Now tell the script that it's ready to go. This may execute the script
 569     // or return true, or neither if the script doesn't need executing.
 570     bool block = sele->AttemptToExecute();
 571     if (mParser) {
 572       if (block) {
 573         GetParser()->BlockParser();
 574       }
 575
 576       // If the parser got blocked, make sure to return the appropriate rv.
 577       // I'm not sure if this is actually needed or not.
 578       if (!mParser->IsParserEnabled()) {
 579         block = true;
 580       }
 581     }
 582
 583     return block ? NS_ERROR_HTMLPARSER_BLOCK : NS_OK;
 584   }
 585
 586   nsresult rv = NS_OK;
 587   if (auto* linkStyle = LinkStyle::FromNode(*aContent)) {
 588     auto updateOrError = linkStyle->EnableUpdatesAndUpdateStyleSheet(
 589         mRunsToCompletion ? nullptr : this);
 590     if (updateOrError.isErr()) {
 591       rv = updateOrError.unwrapErr();
 592     } else if (updateOrError.unwrap().ShouldBlock() && !mRunsToCompletion) {
 593       ++mPendingSheetCount;
 594       mScriptLoader->AddParserBlockingScriptExecutionBlocker();
 595     }
 596   }
 597
 598   return rv;
 599 }
 600
 601 nsresult nsXMLContentSink::AddContentAsLeaf(nsIContent* aContent) {
 602   nsresult result = NS_OK;
 603
 604   if (mState == eXMLContentSinkState_InProlog) {
 605     NS_ASSERTION(mDocument, "Fragments have no prolog");
 606     mDocumentChildren.AppendElement(aContent);
 607   } else if (mState == eXMLContentSinkState_InEpilog) {
 608     NS_ASSERTION(mDocument, "Fragments have no epilog");
 609     if (mXSLTProcessor) {
 610       mDocumentChildren.AppendElement(aContent);
 611     } else {
 612       mDocument->AppendChildTo(aContent, false, IgnoreErrors());
 613     }
 614   } else {
 615     nsCOMPtr<nsIContent> parent = GetCurrentContent();
 616
 617     if (parent) {
 618       ErrorResult rv;
 619       parent->AppendChildTo(aContent, false, rv);
 620       result = rv.StealNSResult();
 621     }
 622   }
 623   return result;
 624 }
 625
 626 // Create an XML parser and an XSL content sink and start parsing
 627 // the XSL stylesheet located at the given URI.
 628 nsresult nsXMLContentSink::LoadXSLStyleSheet(nsIURI* aUrl) {
 629   nsCOMPtr<nsIDocumentTransformer> processor = new txMozillaXSLTProcessor();
 630   mDocument->SetUseCounter(eUseCounter_custom_XSLStylesheet);
 631
 632   processor->SetTransformObserver(this);
 633
 634   if (NS_SUCCEEDED(processor->LoadStyleSheet(aUrl, mDocument))) {
 635     mXSLTProcessor.swap(processor);
 636   }
 637
 638   // Intentionally ignore errors here, we should continue loading the
 639   // XML document whether we're able to load the XSLT stylesheet or
 640   // not.
 641
 642   return NS_OK;
 643 }
 644
 645 nsresult nsXMLContentSink::ProcessStyleLinkFromHeader(
 646     const nsAString& aHref, bool aAlternate, const nsAString& aTitle,
 647     const nsAString& aIntegrity, const nsAString& aType,
 648     const nsAString& aMedia, const nsAString& aReferrerPolicy) {
 649   mPrettyPrintXML = false;
 650
 651   nsAutoCString cmd;
 652   if (mParser) GetParser()->GetCommand(cmd);
 653   if (cmd.EqualsASCII(kLoadAsData))
 654     return NS_OK;  // Do not load stylesheets when loading as data
 655
 656   bool wasXSLT;
 657   nsresult rv = MaybeProcessXSLTLink(nullptr, aHref, aAlternate, aType, aType,
 658                                      aMedia, aReferrerPolicy, &wasXSLT);
 659   NS_ENSURE_SUCCESS(rv, rv);
 660   if (wasXSLT) {
 661     // We're done here.
 662     return NS_OK;
 663   }
 664
 665   // Otherwise fall through to nsContentSink to handle CSS Link headers.
 666   return nsContentSink::ProcessStyleLinkFromHeader(
 667       aHref, aAlternate, aTitle, aIntegrity, aType, aMedia, aReferrerPolicy);
 668 }
 669
 670 nsresult nsXMLContentSink::MaybeProcessXSLTLink(
 671     ProcessingInstruction* aProcessingInstruction, const nsAString& aHref,
 672     bool aAlternate, const nsAString& aTitle, const nsAString& aType,
 673     const nsAString& aMedia, const nsAString& aReferrerPolicy, bool* aWasXSLT) {
 674   bool wasXSLT = aType.LowerCaseEqualsLiteral(TEXT_XSL) ||
 675                  aType.LowerCaseEqualsLiteral(APPLICATION_XSLT_XML) ||
 676                  aType.LowerCaseEqualsLiteral(TEXT_XML) ||
 677                  aType.LowerCaseEqualsLiteral(APPLICATION_XML);
 678
 679   if (aWasXSLT) {
 680     *aWasXSLT = wasXSLT;
 681   }
 682
 683   if (!wasXSLT) {
 684     return NS_OK;
 685   }
 686
 687   if (aAlternate) {
 688     // don't load alternate XSLT
 689     return NS_OK;
 690   }
 691   // LoadXSLStyleSheet needs a mDocShell.
 692   if (!mDocShell) {
 693     return NS_OK;
 694   }
 695
 696   nsCOMPtr<nsIURI> url;
 697   nsresult rv = NS_NewURI(getter_AddRefs(url), aHref, nullptr,
 698                           mDocument->GetDocBaseURI());
 699   NS_ENSURE_SUCCESS(rv, rv);
 700
 701   // Do security check
 702   nsIScriptSecurityManager* secMan = nsContentUtils::GetSecurityManager();
 703   rv = secMan->CheckLoadURIWithPrincipal(mDocument->NodePrincipal(), url,
 704                                          nsIScriptSecurityManager::ALLOW_CHROME,
 705                                          mDocument->InnerWindowID());
 706   NS_ENSURE_SUCCESS(rv, NS_OK);
 707
 708   nsCOMPtr<nsILoadInfo> secCheckLoadInfo =
 709       new net::LoadInfo(mDocument->NodePrincipal(),  // loading principal
 710                         mDocument->NodePrincipal(),  // triggering principal
 711                         aProcessingInstruction,
 712                         nsILoadInfo::SEC_ONLY_FOR_EXPLICIT_CONTENTSEC_CHECK,
 713                         nsIContentPolicy::TYPE_XSLT);
 714
 715   // Do content policy check
 716   int16_t decision = nsIContentPolicy::ACCEPT;
 717   rv = NS_CheckContentLoadPolicy(url, secCheckLoadInfo,
 718                                  NS_ConvertUTF16toUTF8(aType), &decision,
 719                                  nsContentUtils::GetContentPolicy());
 720
 721   NS_ENSURE_SUCCESS(rv, rv);
 722
 723   if (NS_CP_REJECTED(decision)) {
 724     return NS_OK;
 725   }
 726
 727   return LoadXSLStyleSheet(url);
 728 }
 729
 730 void nsXMLContentSink::SetDocumentCharset(NotNull<const Encoding*> aEncoding) {
 731   if (mDocument) {
 732     mDocument->SetDocumentCharacterSet(aEncoding);
 733   }
 734 }
 735
 736 nsISupports* nsXMLContentSink::GetTarget() { return ToSupports(mDocument); }
 737
 738 bool nsXMLContentSink::IsScriptExecuting() { return IsScriptExecutingImpl(); }
 739
 740 nsresult nsXMLContentSink::FlushText(bool aReleaseTextNode) {
 741   nsresult rv = NS_OK;
 742
 743   if (mTextLength != 0) {
 744     if (mLastTextNode) {
 745       bool notify = HaveNotifiedForCurrentContent();
 746       // We could probably always increase mInNotification here since
 747       // if AppendText doesn't notify it shouldn't trigger evil code.
 748       // But just in case it does, we don't want to mask any notifications.
 749       if (notify) {
 750         ++mInNotification;
 751       }
 752       rv = mLastTextNode->AppendText(mText, mTextLength, notify);
 753       if (notify) {
 754         --mInNotification;
 755       }
 756
 757       mTextLength = 0;
 758     } else {
 759       RefPtr<nsTextNode> textContent =
 760           new (mNodeInfoManager) nsTextNode(mNodeInfoManager);
 761
 762       mLastTextNode = textContent;
 763
 764       // Set the text in the text node
 765       textContent->SetText(mText, mTextLength, false);
 766       mTextLength = 0;
 767
 768       // Add text to its parent
 769       rv = AddContentAsLeaf(textContent);
 770     }
 771   }
 772
 773   if (aReleaseTextNode) {
 774     mLastTextNode = nullptr;
 775   }
 776
 777   return rv;
 778 }
 779
 780 nsIContent* nsXMLContentSink::GetCurrentContent() {
 781   if (mContentStack.Length() == 0) {
 782     return nullptr;
 783   }
 784   return GetCurrentStackNode()->mContent;
 785 }
 786
 787 nsXMLContentSink::StackNode* nsXMLContentSink::GetCurrentStackNode() {
 788   int32_t count = mContentStack.Length();
 789   return count != 0 ? &mContentStack[count - 1] : nullptr;
 790 }
 791
 792 nsresult nsXMLContentSink::PushContent(nsIContent* aContent) {
 793   MOZ_ASSERT(aContent, "Null content being pushed!");
 794   StackNode* sn = mContentStack.AppendElement();
 795   NS_ENSURE_TRUE(sn, NS_ERROR_OUT_OF_MEMORY);
 796
 797   nsIContent* contentToPush = aContent;
 798
 799   // When an XML parser would append a node to a template element, it
 800   // must instead append it to the template element's template contents.
 801   if (contentToPush->IsHTMLElement(nsGkAtoms::_template)) {
 802     HTMLTemplateElement* templateElement =
 803         static_cast<HTMLTemplateElement*>(contentToPush);
 804     contentToPush = templateElement->Content();
 805   }
 806
 807   sn->mContent = contentToPush;
 808   sn->mNumFlushed = 0;
 809   return NS_OK;
 810 }
 811
 812 void nsXMLContentSink::PopContent() {
 813   if (mContentStack.IsEmpty()) {
 814     NS_WARNING("Popping empty stack");
 815     return;
 816   }
 817
 818   mContentStack.RemoveLastElement();
 819 }
 820
 821 bool nsXMLContentSink::HaveNotifiedForCurrentContent() const {
 822   uint32_t stackLength = mContentStack.Length();
 823   if (stackLength) {
 824     const StackNode& stackNode = mContentStack[stackLength - 1];
 825     nsIContent* parent = stackNode.mContent;
 826     return stackNode.mNumFlushed == parent->GetChildCount();
 827   }
 828   return true;
 829 }
 830
 831 void nsXMLContentSink::MaybeStartLayout(bool aIgnorePendingSheets) {
 832   // XXXbz if aIgnorePendingSheets is true, what should we do when
 833   // mXSLTProcessor or CanStillPrettyPrint()?
 834   if (mLayoutStarted || mXSLTProcessor || CanStillPrettyPrint()) {
 835     return;
 836   }
 837   StartLayout(aIgnorePendingSheets);
 838 }
 839
 840 ////////////////////////////////////////////////////////////////////////
 841
 842 bool nsXMLContentSink::SetDocElement(int32_t aNameSpaceID, nsAtom* aTagName,
 843                                      nsIContent* aContent) {
 844   if (mDocElement) return false;
 845
 846   mDocElement = aContent;
 847
 848   if (mXSLTProcessor) {
 849     mDocumentChildren.AppendElement(aContent);
 850     return true;
 851   }
 852
 853   if (!mDocumentChildren.IsEmpty()) {
 854     for (nsIContent* child : mDocumentChildren) {
 855       mDocument->AppendChildTo(child, false, IgnoreErrors());
 856     }
 857     mDocumentChildren.Clear();
 858   }
 859
 860   // check for root elements that needs special handling for
 861   // prettyprinting
 862   if (aNameSpaceID == kNameSpaceID_XSLT &&
 863       (aTagName == nsGkAtoms::stylesheet || aTagName == nsGkAtoms::transform)) {
 864     mPrettyPrintHasSpecialRoot = true;
 865     if (mPrettyPrintXML) {
 866       // In this case, disable script execution, stylesheet
 867       // loading, and auto XLinks since we plan to prettyprint.
 868       mDocument->ScriptLoader()->SetEnabled(false);
 869       if (mCSSLoader) {
 870         mCSSLoader->SetEnabled(false);
 871       }
 872     }
 873   }
 874
 875   IgnoredErrorResult rv;
 876   mDocument->AppendChildTo(mDocElement, NotifyForDocElement(), rv);
 877   if (rv.Failed()) {
 878     // If we return false here, the caller will bail out because it won't
 879     // find a parent content node to append to, which is fine.
 880     return false;
 881   }
 882
 883   return true;
 884 }
 885
 886 NS_IMETHODIMP
 887 nsXMLContentSink::HandleStartElement(const char16_t* aName,
 888                                      const char16_t** aAtts,
 889                                      uint32_t aAttsCount, uint32_t aLineNumber,
 890                                      uint32_t aColumnNumber) {
 891   return HandleStartElement(aName, aAtts, aAttsCount, aLineNumber,
 892                             aColumnNumber, true);
 893 }
 894
 895 nsresult nsXMLContentSink::HandleStartElement(
 896     const char16_t* aName, const char16_t** aAtts, uint32_t aAttsCount,
 897     uint32_t aLineNumber, uint32_t aColumnNumber, bool aInterruptable) {
 898   MOZ_ASSERT(aAttsCount % 2 == 0, "incorrect aAttsCount");
 899   // Adjust aAttsCount so it's the actual number of attributes
 900   aAttsCount /= 2;
 901
 902   nsresult result = NS_OK;
 903   bool appendContent = true;
 904   nsCOMPtr<nsIContent> content;
 905
 906   // XXX Hopefully the parser will flag this before we get
 907   // here. If we're in the epilog, there should be no
 908   // new elements
 909   MOZ_ASSERT(eXMLContentSinkState_InEpilog != mState);
 910
 911   FlushText();
 912   DidAddContent();
 913
 914   mState = eXMLContentSinkState_InDocumentElement;
 915
 916   int32_t nameSpaceID;
 917   RefPtr<nsAtom> prefix, localName;
 918   nsContentUtils::SplitExpatName(aName, getter_AddRefs(prefix),
 919                                  getter_AddRefs(localName), &nameSpaceID);
 920
 921   if (!OnOpenContainer(aAtts, aAttsCount, nameSpaceID, localName,
 922                        aLineNumber)) {
 923     return NS_OK;
 924   }
 925
 926   RefPtr<mozilla::dom::NodeInfo> nodeInfo;
 927   nodeInfo = mNodeInfoManager->GetNodeInfo(localName, prefix, nameSpaceID,
 928                                            nsINode::ELEMENT_NODE);
 929
 930   result = CreateElement(aAtts, aAttsCount, nodeInfo, aLineNumber,
 931                          aColumnNumber, getter_AddRefs(content), &appendContent,
 932                          FROM_PARSER_NETWORK);
 933   NS_ENSURE_SUCCESS(result, result);
 934
 935   // Have to do this before we push the new content on the stack... and have to
 936   // do that before we set attributes, call BindToTree, etc.  Ideally we'd push
 937   // on the stack inside CreateElement (which is effectively what the HTML sink
 938   // does), but that's hard with all the subclass overrides going on.
 939   nsCOMPtr<nsIContent> parent = GetCurrentContent();
 940
 941   result = PushContent(content);
 942   NS_ENSURE_SUCCESS(result, result);
 943
 944   // Set the attributes on the new content element
 945   result = AddAttributes(aAtts, content->AsElement());
 946
 947   if (NS_OK == result) {
 948     // Store the element
 949     if (!SetDocElement(nameSpaceID, localName, content) && appendContent) {
 950       NS_ENSURE_TRUE(parent, NS_ERROR_UNEXPECTED);
 951
 952       parent->AppendChildTo(content, false, IgnoreErrors());
 953     }
 954   }
 955
 956   // Some HTML nodes need DoneCreatingElement() called to initialize
 957   // properly (eg form state restoration).
 958   if (nsIContent::RequiresDoneCreatingElement(nodeInfo->NamespaceID(),
 959                                               nodeInfo->NameAtom())) {
 960     content->DoneCreatingElement();
 961   }
 962
 963   if (nodeInfo->NamespaceID() == kNameSpaceID_XHTML &&
 964       nodeInfo->NameAtom() == nsGkAtoms::head && !mCurrentHead) {
 965     mCurrentHead = content;
 966   }
 967
 968   if (IsMonolithicContainer(nodeInfo)) {
 969     mInMonolithicContainer++;
 970   }
 971
 972   if (!mXSLTProcessor) {
 973     if (content == mDocElement) {
 974       nsContentUtils::AddScriptRunner(
 975           new nsDocElementCreatedNotificationRunner(mDocument));
 976
 977       if (aInterruptable && NS_SUCCEEDED(result) && mParser &&
 978           !mParser->IsParserEnabled()) {
 979         return NS_ERROR_HTMLPARSER_BLOCK;
 980       }
 981     } else if (!mCurrentHead) {
 982       // This isn't the root and we're not inside an XHTML <head>.
 983       // Might need to start layout
 984       MaybeStartLayout(false);
 985     }
 986   }
 987
 988   return aInterruptable && NS_SUCCEEDED(result) ? DidProcessATokenImpl()
 989                                                 : result;
 990 }
 991
 992 NS_IMETHODIMP
 993 nsXMLContentSink::HandleEndElement(const char16_t* aName) {
 994   return HandleEndElement(aName, true);
 995 }
 996
 997 nsresult nsXMLContentSink::HandleEndElement(const char16_t* aName,
 998                                             bool aInterruptable) {
 999   nsresult result = NS_OK;
1000
1001   // XXX Hopefully the parser will flag this before we get
1002   // here. If we're in the prolog or epilog, there should be
1003   // no close tags for elements.
1004   MOZ_ASSERT(eXMLContentSinkState_InDocumentElement == mState);
1005
1006   FlushText();
1007
1008   StackNode* sn = GetCurrentStackNode();
1009   if (!sn) {
1010     return NS_ERROR_UNEXPECTED;
1011   }
1012
1013   nsCOMPtr<nsIContent> content;
1014   sn->mContent.swap(content);
1015   uint32_t numFlushed = sn->mNumFlushed;
1016
1017   PopContent();
1018   NS_ASSERTION(content, "failed to pop content");
1019 #ifdef DEBUG
1020   // Check that we're closing the right thing
1021   RefPtr<nsAtom> debugNameSpacePrefix, debugTagAtom;
1022   int32_t debugNameSpaceID;
1023   nsContentUtils::SplitExpatName(aName, getter_AddRefs(debugNameSpacePrefix),
1024                                  getter_AddRefs(debugTagAtom),
1025                                  &debugNameSpaceID);
1026   // Check if we are closing a template element because template
1027   // elements do not get pushed on the stack, the template
1028   // element content is pushed instead.
1029   bool isTemplateElement = debugTagAtom == nsGkAtoms::_template &&
1030                            debugNameSpaceID == kNameSpaceID_XHTML;
1031   NS_ASSERTION(
1032       content->NodeInfo()->Equals(debugTagAtom, debugNameSpaceID) ||
1033           (debugNameSpaceID == kNameSpaceID_MathML &&
1034            content->NodeInfo()->NamespaceID() == kNameSpaceID_disabled_MathML &&
1035            content->NodeInfo()->Equals(debugTagAtom)) ||
1036           (debugNameSpaceID == kNameSpaceID_SVG &&
1037            content->NodeInfo()->NamespaceID() == kNameSpaceID_disabled_SVG &&
1038            content->NodeInfo()->Equals(debugTagAtom)) ||
1039           isTemplateElement,
1040       "Wrong element being closed");
1041 #endif
1042
1043   // Make sure to notify on our kids before we call out to any other code that
1044   // might reenter us and call FlushTags, in a state in which we've already
1045   // popped "content" from the stack but haven't notified on its kids yet.
1046   int32_t stackLen = mContentStack.Length();
1047   if (mNotifyLevel >= stackLen) {
1048     if (numFlushed < content->GetChildCount()) {
1049       NotifyAppend(content, numFlushed);
1050     }
1051     mNotifyLevel = stackLen - 1;
1052   }
1053
1054   result = CloseElement(content);
1055
1056   if (mCurrentHead == content) {
1057     mCurrentHead = nullptr;
1058   }
1059
1060   if (mDocElement == content) {
1061     // XXXbz for roots that don't want to be appended on open, we
1062     // probably need to deal here.... (and stop appending them on open).
1063     mState = eXMLContentSinkState_InEpilog;
1064
1065     mDocument->OnParsingCompleted();
1066
1067     // We might have had no occasion to start layout yet.  Do so now.
1068     MaybeStartLayout(false);
1069   }
1070
1071   DidAddContent();
1072
1073   if (content->IsSVGElement(nsGkAtoms::svg)) {
1074     FlushTags();
1075     nsCOMPtr<nsIRunnable> event = new nsHtml5SVGLoadDispatcher(content);
1076     if (NS_FAILED(content->OwnerDoc()->Dispatch(event.forget()))) {
1077       NS_WARNING("failed to dispatch svg load dispatcher");
1078     }
1079   }
1080
1081   return aInterruptable && NS_SUCCEEDED(result) ? DidProcessATokenImpl()
1082                                                 : result;
1083 }
1084
1085 NS_IMETHODIMP
1086 nsXMLContentSink::HandleComment(const char16_t* aName) {
1087   FlushText();
1088
1089   RefPtr<Comment> comment = new (mNodeInfoManager) Comment(mNodeInfoManager);
1090   comment->SetText(nsDependentString(aName), false);
1091   nsresult rv = AddContentAsLeaf(comment);
1092   DidAddContent();
1093
1094   return NS_SUCCEEDED(rv) ? DidProcessATokenImpl() : rv;
1095 }
1096
1097 NS_IMETHODIMP
1098 nsXMLContentSink::HandleCDataSection(const char16_t* aData, uint32_t aLength) {
1099   // XSLT doesn't differentiate between text and cdata and wants adjacent
1100   // textnodes merged, so add as text.
1101   if (mXSLTProcessor) {
1102     return AddText(aData, aLength);
1103   }
1104
1105   FlushText();
1106
1107   RefPtr<CDATASection> cdata =
1108       new (mNodeInfoManager) CDATASection(mNodeInfoManager);
1109   cdata->SetText(aData, aLength, false);
1110   nsresult rv = AddContentAsLeaf(cdata);
1111   DidAddContent();
1112
1113   return NS_SUCCEEDED(rv) ? DidProcessATokenImpl() : rv;
1114 }
1115
1116 NS_IMETHODIMP
1117 nsXMLContentSink::HandleDoctypeDecl(const nsAString& aSubset,
1118                                     const nsAString& aName,
1119                                     const nsAString& aSystemId,
1120                                     const nsAString& aPublicId,
1121                                     nsISupports* aCatalogData) {
1122   FlushText();
1123
1124   NS_ASSERTION(mDocument, "Shouldn't get here from a document fragment");
1125
1126   RefPtr<nsAtom> name = NS_Atomize(aName);
1127   NS_ENSURE_TRUE(name, NS_ERROR_OUT_OF_MEMORY);
1128
1129   // Create a new doctype node
1130   RefPtr<DocumentType> docType = NS_NewDOMDocumentType(
1131       mNodeInfoManager, name, aPublicId, aSystemId, aSubset);
1132
1133   MOZ_ASSERT(!aCatalogData,
1134              "Need to add back support for catalog style "
1135              "sheets");
1136
1137   mDocumentChildren.AppendElement(docType);
1138   DidAddContent();
1139   return DidProcessATokenImpl();
1140 }
1141
1142 NS_IMETHODIMP
1143 nsXMLContentSink::HandleCharacterData(const char16_t* aData, uint32_t aLength) {
1144   return HandleCharacterData(aData, aLength, true);
1145 }
1146
1147 nsresult nsXMLContentSink::HandleCharacterData(const char16_t* aData,
1148                                                uint32_t aLength,
1149                                                bool aInterruptable) {
1150   nsresult rv = NS_OK;
1151   if (aData && mState != eXMLContentSinkState_InProlog &&
1152       mState != eXMLContentSinkState_InEpilog) {
1153     rv = AddText(aData, aLength);
1154   }
1155   return aInterruptable && NS_SUCCEEDED(rv) ? DidProcessATokenImpl() : rv;
1156 }
1157
1158 NS_IMETHODIMP
1159 nsXMLContentSink::HandleProcessingInstruction(const char16_t* aTarget,
1160                                               const char16_t* aData) {
1161   FlushText();
1162
1163   const nsDependentString target(aTarget);
1164   const nsDependentString data(aData);
1165
1166   RefPtr<ProcessingInstruction> node =
1167       NS_NewXMLProcessingInstruction(mNodeInfoManager, target, data);
1168
1169   auto* linkStyle = LinkStyle::FromNode(*node);
1170   if (linkStyle) {
1171     linkStyle->DisableUpdates();
1172     mPrettyPrintXML = false;
1173   }
1174
1175   nsresult rv = AddContentAsLeaf(node);
1176   NS_ENSURE_SUCCESS(rv, rv);
1177   DidAddContent();
1178
1179   if (linkStyle) {
1180     // This is an xml-stylesheet processing instruction... but it might not be
1181     // a CSS one if the type is set to something else.
1182     auto updateOrError = linkStyle->EnableUpdatesAndUpdateStyleSheet(
1183         mRunsToCompletion ? nullptr : this);
1184     if (updateOrError.isErr()) {
1185       return updateOrError.unwrapErr();
1186     }
1187
1188     auto update = updateOrError.unwrap();
1189     if (update.WillNotify()) {
1190       // Successfully started a stylesheet load
1191       if (update.ShouldBlock() && !mRunsToCompletion) {
1192         ++mPendingSheetCount;
1193         mScriptLoader->AddParserBlockingScriptExecutionBlocker();
1194       }
1195       return NS_OK;
1196     }
1197   }
1198
1199   // Check whether this is a CSS stylesheet PI.  Make sure the type
1200   // handling here matches
1201   // XMLStylesheetProcessingInstruction::GetStyleSheetInfo.
1202   nsAutoString type;
1203   nsContentUtils::GetPseudoAttributeValue(data, nsGkAtoms::type, type);
1204   nsAutoString mimeType, notUsed;
1205   nsContentUtils::SplitMimeType(type, mimeType, notUsed);
1206
1207   if (mState != eXMLContentSinkState_InProlog ||
1208       !target.EqualsLiteral("xml-stylesheet") || mimeType.IsEmpty() ||
1209       mimeType.LowerCaseEqualsLiteral("text/css")) {
1210     // Either not a useful stylesheet PI, or a CSS stylesheet PI that
1211     // got handled above by the "ssle" bits.  We're done here.
1212     return DidProcessATokenImpl();
1213   }
1214
1215   // If it's not a CSS stylesheet PI...
1216   nsAutoString href, title, media;
1217   bool isAlternate = false;
1218
1219   // If there was no href, we can't do anything with this PI
1220   if (!ParsePIData(data, href, title, media, isAlternate)) {
1221     return DidProcessATokenImpl();
1222   }
1223
1224   // <?xml-stylesheet?> processing instructions don't have a referrerpolicy
1225   // pseudo-attribute, so we pass in an empty string
1226   rv =
1227       MaybeProcessXSLTLink(node, href, isAlternate, title, type, media, u""_ns);
1228   return NS_SUCCEEDED(rv) ? DidProcessATokenImpl() : rv;
1229 }
1230
1231 /* static */
1232 bool nsXMLContentSink::ParsePIData(const nsString& aData, nsString& aHref,
1233                                    nsString& aTitle, nsString& aMedia,
1234                                    bool& aIsAlternate) {
1235   // If there was no href, we can't do anything with this PI
1236   if (!nsContentUtils::GetPseudoAttributeValue(aData, nsGkAtoms::href, aHref)) {
1237     return false;
1238   }
1239
1240   nsContentUtils::GetPseudoAttributeValue(aData, nsGkAtoms::title, aTitle);
1241
1242   nsContentUtils::GetPseudoAttributeValue(aData, nsGkAtoms::media, aMedia);
1243
1244   nsAutoString alternate;
1245   nsContentUtils::GetPseudoAttributeValue(aData, nsGkAtoms::alternate,
1246                                           alternate);
1247
1248   aIsAlternate = alternate.EqualsLiteral("yes");
1249
1250   return true;
1251 }
1252
1253 NS_IMETHODIMP
1254 nsXMLContentSink::HandleXMLDeclaration(const char16_t* aVersion,
1255                                        const char16_t* aEncoding,
1256                                        int32_t aStandalone) {
1257   mDocument->SetXMLDeclaration(aVersion, aEncoding, aStandalone);
1258
1259   return DidProcessATokenImpl();
1260 }
1261
1262 NS_IMETHODIMP
1263 nsXMLContentSink::ReportError(const char16_t* aErrorText,
1264                               const char16_t* aSourceText,
1265                               nsIScriptError* aError, bool* _retval) {
1266   MOZ_ASSERT(aError && aSourceText && aErrorText, "Check arguments!!!");
1267   nsresult rv = NS_OK;
1268
1269   // The expat driver should report the error.  We're just cleaning up the mess.
1270   *_retval = true;
1271
1272   mPrettyPrintXML = false;
1273
1274   mState = eXMLContentSinkState_InProlog;
1275
1276   // XXX need to stop scripts here -- hsivonen
1277
1278   // stop observing in order to avoid crashing when removing content
1279   mDocument->RemoveObserver(this);
1280   mIsDocumentObserver = false;
1281
1282   // Clear the current content
1283   mDocumentChildren.Clear();
1284   while (mDocument->GetLastChild()) {
1285     mDocument->GetLastChild()->Remove();
1286   }
1287   mDocElement = nullptr;
1288
1289   // Clear any buffered-up text we have.  It's enough to set the length to 0.
1290   // The buffer itself is allocated when we're created and deleted in our
1291   // destructor, so don't mess with it.
1292   mTextLength = 0;
1293
1294   if (mXSLTProcessor) {
1295     // Get rid of the XSLT processor.
1296     mXSLTProcessor->CancelLoads();
1297     mXSLTProcessor = nullptr;
1298   }
1299
1300   // release the nodes on stack
1301   mContentStack.Clear();
1302   mNotifyLevel = 0;
1303
1304   // return leaving the document empty if we're asked to not add a <parsererror>
1305   // root node
1306   if (mDocument->SuppressParserErrorElement()) {
1307     return NS_OK;
1308   }
1309
1310   // prepare to set <parsererror> as the document root
1311   rv = HandleProcessingInstruction(
1312       u"xml-stylesheet",
1313       u"href=\"chrome://global/locale/intl.css\" type=\"text/css\"");
1314   NS_ENSURE_SUCCESS(rv, rv);
1315
1316   const char16_t* noAtts[] = {0, 0};
1317
1318   constexpr auto errorNs =
1319       u"http://www.mozilla.org/newlayout/xml/parsererror.xml"_ns;
1320
1321   nsAutoString parsererror(errorNs);
1322   parsererror.Append((char16_t)0xFFFF);
1323   parsererror.AppendLiteral("parsererror");
1324
1325   rv = HandleStartElement(parsererror.get(), noAtts, 0, (uint32_t)-1, false);
1326   NS_ENSURE_SUCCESS(rv, rv);
1327
1328   rv = HandleCharacterData(aErrorText, NS_strlen(aErrorText), false);
1329   NS_ENSURE_SUCCESS(rv, rv);
1330
1331   nsAutoString sourcetext(errorNs);
1332   sourcetext.Append((char16_t)0xFFFF);
1333   sourcetext.AppendLiteral("sourcetext");
1334
1335   rv = HandleStartElement(sourcetext.get(), noAtts, 0, (uint32_t)-1, false);
1336   NS_ENSURE_SUCCESS(rv, rv);
1337
1338   rv = HandleCharacterData(aSourceText, NS_strlen(aSourceText), false);
1339   NS_ENSURE_SUCCESS(rv, rv);
1340
1341   rv = HandleEndElement(sourcetext.get(), false);
1342   NS_ENSURE_SUCCESS(rv, rv);
1343
1344   rv = HandleEndElement(parsererror.get(), false);
1345   NS_ENSURE_SUCCESS(rv, rv);
1346
1347   FlushTags();
1348
1349   return NS_OK;
1350 }
1351
1352 nsresult nsXMLContentSink::AddAttributes(const char16_t** aAtts,
1353                                          Element* aContent) {
1354   // Add tag attributes to the content attributes
1355   RefPtr<nsAtom> prefix, localName;
1356   while (*aAtts) {
1357     int32_t nameSpaceID;
1358     nsContentUtils::SplitExpatName(aAtts[0], getter_AddRefs(prefix),
1359                                    getter_AddRefs(localName), &nameSpaceID);
1360
1361     // Add attribute to content
1362     aContent->SetAttr(nameSpaceID, localName, prefix,
1363                       nsDependentString(aAtts[1]), false);
1364     aAtts += 2;
1365   }
1366
1367   return NS_OK;
1368 }
1369
1370 #define NS_ACCUMULATION_BUFFER_SIZE 4096
1371
1372 nsresult nsXMLContentSink::AddText(const char16_t* aText, int32_t aLength) {
1373   // Copy data from string into our buffer; flush buffer when it fills up.
1374   int32_t offset = 0;
1375   while (0 != aLength) {
1376     int32_t amount = NS_ACCUMULATION_BUFFER_SIZE - mTextLength;
1377     if (0 == amount) {
1378       nsresult rv = FlushText(false);
1379       if (NS_WARN_IF(NS_FAILED(rv))) {
1380         return rv;
1381       }
1382       MOZ_ASSERT(mTextLength == 0);
1383       amount = NS_ACCUMULATION_BUFFER_SIZE;
1384     }
1385
1386     if (amount > aLength) {
1387       amount = aLength;
1388     }
1389     memcpy(&mText[mTextLength], &aText[offset], sizeof(char16_t) * amount);
1390     mTextLength += amount;
1391     offset += amount;
1392     aLength -= amount;
1393   }
1394
1395   return NS_OK;
1396 }
1397
1398 void nsXMLContentSink::InitialTranslationCompleted() { StartLayout(false); }
1399
1400 void nsXMLContentSink::FlushPendingNotifications(FlushType aType) {
1401   // Only flush tags if we're not doing the notification ourselves
1402   // (since we aren't reentrant)
1403   if (!mInNotification) {
1404     if (mIsDocumentObserver) {
1405       // Only flush if we're still a document observer (so that our child
1406       // counts should be correct).
1407       if (aType >= FlushType::ContentAndNotify) {
1408         FlushTags();
1409       } else {
1410         FlushText(false);
1411       }
1412     }
1413     if (aType >= FlushType::EnsurePresShellInitAndFrames) {
1414       // Make sure that layout has started so that the reflow flush
1415       // will actually happen.
1416       MaybeStartLayout(true);
1417     }
1418   }
1419 }
1420
1421 /**
1422  * NOTE!! Forked from SinkContext. Please keep in sync.
1423  *
1424  * Flush all elements that have been seen so far such that
1425  * they are visible in the tree. Specifically, make sure
1426  * that they are all added to their respective parents.
1427  * Also, do notification at the top for all content that
1428  * has been newly added so that the frame tree is complete.
1429  */
1430 nsresult nsXMLContentSink::FlushTags() {
1431   mDeferredFlushTags = false;
1432   uint32_t oldUpdates = mUpdatesInNotification;
1433
1434   mUpdatesInNotification = 0;
1435   ++mInNotification;
1436   {
1437     // Scope so we call EndUpdate before we decrease mInNotification
1438     mozAutoDocUpdate updateBatch(mDocument, true);
1439
1440     // Don't release last text node in case we need to add to it again
1441     FlushText(false);
1442
1443     // Start from the base of the stack (growing downward) and do
1444     // a notification from the node that is closest to the root of
1445     // tree for any content that has been added.
1446
1447     int32_t stackPos;
1448     int32_t stackLen = mContentStack.Length();
1449     bool flushed = false;
1450     uint32_t childCount;
1451     nsIContent* content;
1452
1453     for (stackPos = 0; stackPos < stackLen; ++stackPos) {
1454       content = mContentStack[stackPos].mContent;
1455       childCount = content->GetChildCount();
1456
1457       if (!flushed && (mContentStack[stackPos].mNumFlushed < childCount)) {
1458         NotifyAppend(content, mContentStack[stackPos].mNumFlushed);
1459         flushed = true;
1460       }
1461
1462       mContentStack[stackPos].mNumFlushed = childCount;
1463     }
1464     mNotifyLevel = stackLen - 1;
1465   }
1466   --mInNotification;
1467
1468   if (mUpdatesInNotification > 1) {
1469     UpdateChildCounts();
1470   }
1471
1472   mUpdatesInNotification = oldUpdates;
1473   return NS_OK;
1474 }
1475
1476 /**
1477  * NOTE!! Forked from SinkContext. Please keep in sync.
1478  */
1479 void nsXMLContentSink::UpdateChildCounts() {
1480   // Start from the top of the stack (growing upwards) and see if any
1481   // new content has been appended. If so, we recognize that reflows
1482   // have been generated for it and we should make sure that no
1483   // further reflows occur.  Note that we have to include stackPos == 0
1484   // to properly notify on kids of <html>.
1485   int32_t stackLen = mContentStack.Length();
1486   int32_t stackPos = stackLen - 1;
1487   while (stackPos >= 0) {
1488     StackNode& node = mContentStack[stackPos];
1489     node.mNumFlushed = node.mContent->GetChildCount();
1490
1491     stackPos--;
1492   }
1493   mNotifyLevel = stackLen - 1;
1494 }
1495
1496 bool nsXMLContentSink::IsMonolithicContainer(
1497     mozilla::dom::NodeInfo* aNodeInfo) {
1498   return ((aNodeInfo->NamespaceID() == kNameSpaceID_XHTML &&
1499            (aNodeInfo->NameAtom() == nsGkAtoms::tr ||
1500             aNodeInfo->NameAtom() == nsGkAtoms::select ||
1501             aNodeInfo->NameAtom() == nsGkAtoms::object)) ||
1502           (aNodeInfo->NamespaceID() == kNameSpaceID_MathML &&
1503            (aNodeInfo->NameAtom() == nsGkAtoms::math)));
1504 }
1505
1506 void nsXMLContentSink::ContinueInterruptedParsingIfEnabled() {
1507   if (mParser && mParser->IsParserEnabled()) {
1508     GetParser()->ContinueInterruptedParsing();
1509   }
1510 }
1511
1512 void nsXMLContentSink::ContinueInterruptedParsingAsync() {
1513   nsCOMPtr<nsIRunnable> ev = NewRunnableMethod(
1514       "nsXMLContentSink::ContinueInterruptedParsingIfEnabled", this,
1515       &nsXMLContentSink::ContinueInterruptedParsingIfEnabled);
1516   mDocument->Dispatch(ev.forget());
1517 }
1518
1519 nsIParser* nsXMLContentSink::GetParser() {
1520   return static_cast<nsIParser*>(mParser.get());
1521 }