parser/html/nsHtml5TreeOperation.h

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #ifndef nsHtml5TreeOperation_h
   6 #define nsHtml5TreeOperation_h
   7
   8 #include "nsHtml5DocumentMode.h"
   9 #include "nsHtml5HtmlAttributes.h"
  10 #include "mozilla/dom/FromParser.h"
  11 #include "mozilla/dom/ShadowRootBinding.h"
  12 #include "mozilla/NotNull.h"
  13 #include "mozilla/Variant.h"
  14 #include "nsCharsetSource.h"
  15
  16 class nsIContent;
  17 class nsHtml5TreeOpExecutor;
  18 class nsHtml5DocumentBuilder;
  19 namespace mozilla {
  20 class Encoding;
  21
  22 namespace dom {
  23 class Text;
  24 }  // namespace dom
  25 }  // namespace mozilla
  26
  27 struct uninitialized {};
  28
  29 // main HTML5 ops
  30 struct opDetach {
  31   nsIContent** mElement;
  32
  33   explicit opDetach(nsIContentHandle* aElement) {
  34     mElement = static_cast<nsIContent**>(aElement);
  35   };
  36 };
  37
  38 struct opAppend {
  39   nsIContent** mChild;
  40   nsIContent** mParent;
  41   mozilla::dom::FromParser mFromNetwork;
  42
  43   explicit opAppend(nsIContentHandle* aChild, nsIContentHandle* aParent,
  44                     mozilla::dom::FromParser aFromNetwork)
  45       : mFromNetwork(aFromNetwork) {
  46     mChild = static_cast<nsIContent**>(aChild);
  47     mParent = static_cast<nsIContent**>(aParent);
  48   };
  49 };
  50
  51 struct opAppendChildrenToNewParent {
  52   nsIContent** mOldParent;
  53   nsIContent** mNewParent;
  54
  55   explicit opAppendChildrenToNewParent(nsIContentHandle* aOldParent,
  56                                        nsIContentHandle* aNewParent) {
  57     mOldParent = static_cast<nsIContent**>(aOldParent);
  58     mNewParent = static_cast<nsIContent**>(aNewParent);
  59   };
  60 };
  61
  62 struct opFosterParent {
  63   nsIContent** mChild;
  64   nsIContent** mStackParent;
  65   nsIContent** mTable;
  66
  67   explicit opFosterParent(nsIContentHandle* aChild,
  68                           nsIContentHandle* aStackParent,
  69                           nsIContentHandle* aTable) {
  70     mChild = static_cast<nsIContent**>(aChild);
  71     mStackParent = static_cast<nsIContent**>(aStackParent);
  72     mTable = static_cast<nsIContent**>(aTable);
  73   };
  74 };
  75
  76 struct opAppendToDocument {
  77   nsIContent** mContent;
  78
  79   explicit opAppendToDocument(nsIContentHandle* aContent) {
  80     mContent = static_cast<nsIContent**>(aContent);
  81   };
  82 };
  83
  84 struct opAddAttributes {
  85   nsIContent** mElement;
  86   nsHtml5HtmlAttributes* mAttributes;
  87
  88   explicit opAddAttributes(nsIContentHandle* aElement,
  89                            nsHtml5HtmlAttributes* aAttributes)
  90       : mAttributes(aAttributes) {
  91     mElement = static_cast<nsIContent**>(aElement);
  92   };
  93 };
  94
  95 struct opCreateHTMLElement {
  96   nsIContent** mContent;
  97   nsAtom* mName;
  98   nsHtml5HtmlAttributes* mAttributes;
  99   mozilla::dom::HTMLContentCreatorFunction mCreator;
 100   nsIContent** mIntendedParent;
 101   mozilla::dom::FromParser mFromNetwork;
 102
 103   explicit opCreateHTMLElement(
 104       nsIContentHandle* aContent, nsAtom* aName,
 105       nsHtml5HtmlAttributes* aAttributes,
 106       mozilla::dom::HTMLContentCreatorFunction aCreator,
 107       nsIContentHandle* aIntendedParent, mozilla::dom::FromParser mFromNetwork)
 108       : mName(aName),
 109         mAttributes(aAttributes),
 110         mCreator(aCreator),
 111         mFromNetwork(mFromNetwork) {
 112     mContent = static_cast<nsIContent**>(aContent);
 113     mIntendedParent = static_cast<nsIContent**>(aIntendedParent);
 114     aName->AddRef();
 115     if (mAttributes == nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES) {
 116       mAttributes = nullptr;
 117     }
 118   };
 119 };
 120
 121 struct opCreateSVGElement {
 122   nsIContent** mContent;
 123   nsAtom* mName;
 124   nsHtml5HtmlAttributes* mAttributes;
 125   mozilla::dom::SVGContentCreatorFunction mCreator;
 126   nsIContent** mIntendedParent;
 127   mozilla::dom::FromParser mFromNetwork;
 128
 129   explicit opCreateSVGElement(nsIContentHandle* aContent, nsAtom* aName,
 130                               nsHtml5HtmlAttributes* aAttributes,
 131                               mozilla::dom::SVGContentCreatorFunction aCreator,
 132                               nsIContentHandle* aIntendedParent,
 133                               mozilla::dom::FromParser mFromNetwork)
 134       : mName(aName),
 135         mAttributes(aAttributes),
 136         mCreator(aCreator),
 137         mFromNetwork(mFromNetwork) {
 138     mContent = static_cast<nsIContent**>(aContent);
 139     mIntendedParent = static_cast<nsIContent**>(aIntendedParent);
 140     aName->AddRef();
 141     if (mAttributes == nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES) {
 142       mAttributes = nullptr;
 143     }
 144   };
 145 };
 146
 147 struct opCreateMathMLElement {
 148   nsIContent** mContent;
 149   nsAtom* mName;
 150   nsHtml5HtmlAttributes* mAttributes;
 151   nsIContent** mIntendedParent;
 152
 153   explicit opCreateMathMLElement(nsIContentHandle* aContent, nsAtom* aName,
 154                                  nsHtml5HtmlAttributes* aAttributes,
 155                                  nsIContentHandle* aIntendedParent)
 156       : mName(aName), mAttributes(aAttributes) {
 157     mContent = static_cast<nsIContent**>(aContent);
 158     mIntendedParent = static_cast<nsIContent**>(aIntendedParent);
 159     aName->AddRef();
 160     if (mAttributes == nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES) {
 161       mAttributes = nullptr;
 162     }
 163   };
 164 };
 165
 166 struct opSetFormElement {
 167   nsIContent** mContent;
 168   nsIContent** mFormElement;
 169
 170   explicit opSetFormElement(nsIContentHandle* aContent,
 171                             nsIContentHandle* aFormElement) {
 172     mContent = static_cast<nsIContent**>(aContent);
 173     mFormElement = static_cast<nsIContent**>(aFormElement);
 174   };
 175 };
 176
 177 struct opAppendText {
 178   nsIContent** mParent;
 179   char16_t* mBuffer;
 180   int32_t mLength;
 181
 182   explicit opAppendText(nsIContentHandle* aParent, char16_t* aBuffer,
 183                         int32_t aLength)
 184       : mBuffer(aBuffer), mLength(aLength) {
 185     mParent = static_cast<nsIContent**>(aParent);
 186   };
 187 };
 188
 189 struct opFosterParentText {
 190   nsIContent** mStackParent;
 191   char16_t* mBuffer;
 192   nsIContent** mTable;
 193   int32_t mLength;
 194
 195   explicit opFosterParentText(nsIContentHandle* aStackParent, char16_t* aBuffer,
 196                               nsIContentHandle* aTable, int32_t aLength)
 197       : mBuffer(aBuffer), mLength(aLength) {
 198     mStackParent = static_cast<nsIContent**>(aStackParent);
 199     mTable = static_cast<nsIContent**>(aTable);
 200   };
 201 };
 202
 203 struct opAppendComment {
 204   nsIContent** mParent;
 205   char16_t* mBuffer;
 206   int32_t mLength;
 207
 208   explicit opAppendComment(nsIContentHandle* aParent, char16_t* aBuffer,
 209                            int32_t aLength)
 210       : mBuffer(aBuffer), mLength(aLength) {
 211     mParent = static_cast<nsIContent**>(aParent);
 212   };
 213 };
 214
 215 struct opAppendCommentToDocument {
 216   char16_t* mBuffer;
 217   int32_t mLength;
 218
 219   explicit opAppendCommentToDocument(char16_t* aBuffer, int32_t aLength)
 220       : mBuffer(aBuffer), mLength(aLength){};
 221 };
 222
 223 class nsHtml5TreeOperationStringPair {
 224  private:
 225   nsString mPublicId;
 226   nsString mSystemId;
 227
 228  public:
 229   nsHtml5TreeOperationStringPair(const nsAString& aPublicId,
 230                                  const nsAString& aSystemId)
 231       : mPublicId(aPublicId), mSystemId(aSystemId) {
 232     MOZ_COUNT_CTOR(nsHtml5TreeOperationStringPair);
 233   }
 234
 235   ~nsHtml5TreeOperationStringPair() {
 236     MOZ_COUNT_DTOR(nsHtml5TreeOperationStringPair);
 237   }
 238
 239   inline void Get(nsAString& aPublicId, nsAString& aSystemId) {
 240     aPublicId.Assign(mPublicId);
 241     aSystemId.Assign(mSystemId);
 242   }
 243 };
 244
 245 struct opAppendDoctypeToDocument {
 246   nsAtom* mName;
 247   nsHtml5TreeOperationStringPair* mStringPair;
 248
 249   explicit opAppendDoctypeToDocument(nsAtom* aName, const nsAString& aPublicId,
 250                                      const nsAString& aSystemId) {
 251     mName = aName;
 252     aName->AddRef();
 253     mStringPair = new nsHtml5TreeOperationStringPair(aPublicId, aSystemId);
 254   }
 255 };
 256
 257 struct opGetDocumentFragmentForTemplate {
 258   nsIContent** mTemplate;
 259   nsIContent** mFragHandle;
 260
 261   explicit opGetDocumentFragmentForTemplate(nsIContentHandle* aTemplate,
 262                                             nsIContentHandle* aFragHandle) {
 263     mTemplate = static_cast<nsIContent**>(aTemplate);
 264     mFragHandle = static_cast<nsIContent**>(aFragHandle);
 265   }
 266 };
 267
 268 struct opSetDocumentFragmentForTemplate {
 269   nsIContent** mTemplate;
 270   nsIContent** mFragment;
 271
 272   explicit opSetDocumentFragmentForTemplate(nsIContentHandle* aTemplate,
 273                                             nsIContentHandle* aFragment) {
 274     mTemplate = static_cast<nsIContent**>(aTemplate);
 275     mFragment = static_cast<nsIContent**>(aFragment);
 276   }
 277 };
 278
 279 struct opGetShadowRootFromHost {
 280   nsIContent** mHost;
 281   nsIContent** mFragHandle;
 282   nsIContent** mTemplateNode;
 283   mozilla::dom::ShadowRootMode mShadowRootMode;
 284   bool mShadowRootIsClonable;
 285   bool mShadowRootDelegatesFocus;
 286
 287   explicit opGetShadowRootFromHost(nsIContentHandle* aHost,
 288                                    nsIContentHandle* aFragHandle,
 289                                    nsIContentHandle* aTemplateNode,
 290                                    mozilla::dom::ShadowRootMode aShadowRootMode,
 291                                    bool aShadowRootIsClonable,
 292                                    bool aShadowRootDelegatesFocus) {
 293     mHost = static_cast<nsIContent**>(aHost);
 294     mFragHandle = static_cast<nsIContent**>(aFragHandle);
 295     mTemplateNode = static_cast<nsIContent**>(aTemplateNode);
 296     mShadowRootMode = aShadowRootMode;
 297     mShadowRootIsClonable = aShadowRootIsClonable;
 298     mShadowRootDelegatesFocus = aShadowRootDelegatesFocus;
 299   }
 300 };
 301
 302 struct opGetFosterParent {
 303   nsIContent** mTable;
 304   nsIContent** mStackParent;
 305   nsIContent** mParentHandle;
 306
 307   explicit opGetFosterParent(nsIContentHandle* aTable,
 308                              nsIContentHandle* aStackParent,
 309                              nsIContentHandle* aParentHandle) {
 310     mTable = static_cast<nsIContent**>(aTable);
 311     mStackParent = static_cast<nsIContent**>(aStackParent);
 312     mParentHandle = static_cast<nsIContent**>(aParentHandle);
 313   };
 314 };
 315
 316 // Gecko-specific on-pop ops
 317 struct opMarkAsBroken {
 318   nsresult mResult;
 319
 320   explicit opMarkAsBroken(nsresult aResult) : mResult(aResult){};
 321 };
 322
 323 struct opRunScriptThatMayDocumentWriteOrBlock {
 324   nsIContent** mElement;
 325   nsAHtml5TreeBuilderState* mBuilderState;
 326   int32_t mLineNumber;
 327
 328   explicit opRunScriptThatMayDocumentWriteOrBlock(
 329       nsIContentHandle* aElement, nsAHtml5TreeBuilderState* aBuilderState)
 330       : mBuilderState(aBuilderState), mLineNumber(0) {
 331     mElement = static_cast<nsIContent**>(aElement);
 332   };
 333 };
 334
 335 struct opRunScriptThatCannotDocumentWriteOrBlock {
 336   nsIContent** mElement;
 337
 338   explicit opRunScriptThatCannotDocumentWriteOrBlock(
 339       nsIContentHandle* aElement) {
 340     mElement = static_cast<nsIContent**>(aElement);
 341   };
 342 };
 343
 344 struct opPreventScriptExecution {
 345   nsIContent** mElement;
 346
 347   explicit opPreventScriptExecution(nsIContentHandle* aElement) {
 348     mElement = static_cast<nsIContent**>(aElement);
 349   };
 350 };
 351
 352 struct opDoneAddingChildren {
 353   nsIContent** mElement;
 354
 355   explicit opDoneAddingChildren(nsIContentHandle* aElement) {
 356     mElement = static_cast<nsIContent**>(aElement);
 357   };
 358 };
 359
 360 struct opDoneCreatingElement {
 361   nsIContent** mElement;
 362
 363   explicit opDoneCreatingElement(nsIContentHandle* aElement) {
 364     mElement = static_cast<nsIContent**>(aElement);
 365   };
 366 };
 367
 368 struct opUpdateCharsetSource {
 369   nsCharsetSource mCharsetSource;
 370
 371   explicit opUpdateCharsetSource(nsCharsetSource aCharsetSource)
 372       : mCharsetSource(aCharsetSource){};
 373 };
 374
 375 struct opCharsetSwitchTo {
 376   const mozilla::Encoding* mEncoding;
 377   int32_t mCharsetSource;
 378   int32_t mLineNumber;
 379
 380   explicit opCharsetSwitchTo(const mozilla::Encoding* aEncoding,
 381                              int32_t aCharsetSource, int32_t aLineNumber)
 382       : mEncoding(aEncoding),
 383         mCharsetSource(aCharsetSource),
 384         mLineNumber(aLineNumber){};
 385 };
 386
 387 struct opUpdateStyleSheet {
 388   nsIContent** mElement;
 389
 390   explicit opUpdateStyleSheet(nsIContentHandle* aElement) {
 391     mElement = static_cast<nsIContent**>(aElement);
 392   };
 393 };
 394
 395 struct opProcessOfflineManifest {
 396   char16_t* mUrl;
 397
 398   explicit opProcessOfflineManifest(char16_t* aUrl) : mUrl(aUrl){};
 399 };
 400
 401 struct opMarkMalformedIfScript {
 402   nsIContent** mElement;
 403
 404   explicit opMarkMalformedIfScript(nsIContentHandle* aElement) {
 405     mElement = static_cast<nsIContent**>(aElement);
 406   }
 407 };
 408
 409 struct opStreamEnded {};
 410
 411 struct opSetStyleLineNumber {
 412   nsIContent** mContent;
 413   int32_t mLineNumber;
 414
 415   explicit opSetStyleLineNumber(nsIContentHandle* aContent, int32_t aLineNumber)
 416       : mLineNumber(aLineNumber) {
 417     mContent = static_cast<nsIContent**>(aContent);
 418   };
 419 };
 420
 421 struct opSetScriptLineAndColumnNumberAndFreeze {
 422   nsIContent** mContent;
 423   int32_t mLineNumber;
 424   int32_t mColumnNumber;
 425
 426   explicit opSetScriptLineAndColumnNumberAndFreeze(nsIContentHandle* aContent,
 427                                                    int32_t aLineNumber,
 428                                                    int32_t aColumnNumber)
 429       : mLineNumber(aLineNumber), mColumnNumber(aColumnNumber) {
 430     mContent = static_cast<nsIContent**>(aContent);
 431   };
 432 };
 433
 434 struct opSvgLoad {
 435   nsIContent** mElement;
 436
 437   explicit opSvgLoad(nsIContentHandle* aElement) {
 438     mElement = static_cast<nsIContent**>(aElement);
 439   };
 440 };
 441
 442 struct opMaybeComplainAboutCharset {
 443   char* mMsgId;
 444   bool mError;
 445   int32_t mLineNumber;
 446
 447   explicit opMaybeComplainAboutCharset(char* aMsgId, bool aError,
 448                                        int32_t aLineNumber)
 449       : mMsgId(aMsgId), mError(aError), mLineNumber(aLineNumber){};
 450 };
 451
 452 struct opMaybeComplainAboutDeepTree {
 453   int32_t mLineNumber;
 454
 455   explicit opMaybeComplainAboutDeepTree(int32_t aLineNumber)
 456       : mLineNumber(aLineNumber){};
 457 };
 458
 459 struct opAddClass {
 460   nsIContent** mElement;
 461   char16_t* mClass;
 462
 463   explicit opAddClass(nsIContentHandle* aElement, char16_t* aClass)
 464       : mClass(aClass) {
 465     mElement = static_cast<nsIContent**>(aElement);
 466   };
 467 };
 468
 469 struct opAddViewSourceHref {
 470   nsIContent** mElement;
 471   char16_t* mBuffer;
 472   int32_t mLength;
 473
 474   explicit opAddViewSourceHref(nsIContentHandle* aElement, char16_t* aBuffer,
 475                                int32_t aLength)
 476       : mBuffer(aBuffer), mLength(aLength) {
 477     mElement = static_cast<nsIContent**>(aElement);
 478   };
 479 };
 480
 481 struct opAddViewSourceBase {
 482   char16_t* mBuffer;
 483   int32_t mLength;
 484
 485   explicit opAddViewSourceBase(char16_t* aBuffer, int32_t aLength)
 486       : mBuffer(aBuffer), mLength(aLength){};
 487 };
 488
 489 struct opAddErrorType {
 490   nsIContent** mElement;
 491   char* mMsgId;
 492   nsAtom* mName;
 493   nsAtom* mOther;
 494
 495   explicit opAddErrorType(nsIContentHandle* aElement, char* aMsgId,
 496                           nsAtom* aName = nullptr, nsAtom* aOther = nullptr)
 497       : mMsgId(aMsgId), mName(aName), mOther(aOther) {
 498     mElement = static_cast<nsIContent**>(aElement);
 499     if (aName) {
 500       aName->AddRef();
 501     }
 502     if (aOther) {
 503       aOther->AddRef();
 504     }
 505   };
 506 };
 507
 508 struct opAddLineNumberId {
 509   nsIContent** mElement;
 510   int32_t mLineNumber;
 511
 512   explicit opAddLineNumberId(nsIContentHandle* aElement, int32_t aLineNumber)
 513       : mLineNumber(aLineNumber) {
 514     mElement = static_cast<nsIContent**>(aElement);
 515   };
 516 };
 517
 518 struct opStartLayout {};
 519
 520 struct opEnableEncodingMenu {};
 521
 522 typedef mozilla::Variant<
 523     uninitialized,
 524     // main HTML5 ops
 525     opAppend, opDetach, opAppendChildrenToNewParent, opFosterParent,
 526     opAppendToDocument, opAddAttributes, nsHtml5DocumentMode,
 527     opCreateHTMLElement, opCreateSVGElement, opCreateMathMLElement,
 528     opSetFormElement, opAppendText, opFosterParentText, opAppendComment,
 529     opAppendCommentToDocument, opAppendDoctypeToDocument,
 530     opGetDocumentFragmentForTemplate, opSetDocumentFragmentForTemplate,
 531     opGetShadowRootFromHost, opGetFosterParent,
 532     // Gecko-specific on-pop ops
 533     opMarkAsBroken, opRunScriptThatMayDocumentWriteOrBlock,
 534     opRunScriptThatCannotDocumentWriteOrBlock, opPreventScriptExecution,
 535     opDoneAddingChildren, opDoneCreatingElement, opUpdateCharsetSource,
 536     opCharsetSwitchTo, opUpdateStyleSheet, opProcessOfflineManifest,
 537     opMarkMalformedIfScript, opStreamEnded, opSetStyleLineNumber,
 538     opSetScriptLineAndColumnNumberAndFreeze, opSvgLoad,
 539     opMaybeComplainAboutCharset, opMaybeComplainAboutDeepTree, opAddClass,
 540     opAddViewSourceHref, opAddViewSourceBase, opAddErrorType, opAddLineNumberId,
 541     opStartLayout, opEnableEncodingMenu>
 542     treeOperation;
 543
 544 class nsHtml5TreeOperation final {
 545   template <typename T>
 546   using NotNull = mozilla::NotNull<T>;
 547   using Encoding = mozilla::Encoding;
 548
 549  public:
 550   static nsresult AppendTextToTextNode(const char16_t* aBuffer,
 551                                        uint32_t aLength,
 552                                        mozilla::dom::Text* aTextNode,
 553                                        nsHtml5DocumentBuilder* aBuilder);
 554
 555   static nsresult AppendText(const char16_t* aBuffer, uint32_t aLength,
 556                              nsIContent* aParent,
 557                              nsHtml5DocumentBuilder* aBuilder);
 558
 559   static nsresult Append(nsIContent* aNode, nsIContent* aParent,
 560                          nsHtml5DocumentBuilder* aBuilder);
 561
 562   static nsresult Append(nsIContent* aNode, nsIContent* aParent,
 563                          mozilla::dom::FromParser aFromParser,
 564                          nsHtml5DocumentBuilder* aBuilder);
 565
 566   static nsresult AppendToDocument(nsIContent* aNode,
 567                                    nsHtml5DocumentBuilder* aBuilder);
 568
 569   static void Detach(nsIContent* aNode, nsHtml5DocumentBuilder* aBuilder);
 570
 571   static nsresult AppendChildrenToNewParent(nsIContent* aNode,
 572                                             nsIContent* aParent,
 573                                             nsHtml5DocumentBuilder* aBuilder);
 574
 575   static nsresult FosterParent(nsIContent* aNode, nsIContent* aParent,
 576                                nsIContent* aTable,
 577                                nsHtml5DocumentBuilder* aBuilder);
 578
 579   static nsresult AddAttributes(nsIContent* aNode,
 580                                 nsHtml5HtmlAttributes* aAttributes,
 581                                 nsHtml5DocumentBuilder* aBuilder);
 582
 583   static void SetHTMLElementAttributes(mozilla::dom::Element* aElement,
 584                                        nsAtom* aName,
 585                                        nsHtml5HtmlAttributes* aAttributes);
 586
 587   static nsIContent* CreateHTMLElement(
 588       nsAtom* aName, nsHtml5HtmlAttributes* aAttributes,
 589       mozilla::dom::FromParser aFromParser, nsNodeInfoManager* aNodeInfoManager,
 590       nsHtml5DocumentBuilder* aBuilder,
 591       mozilla::dom::HTMLContentCreatorFunction aCreator);
 592
 593   static nsIContent* CreateSVGElement(
 594       nsAtom* aName, nsHtml5HtmlAttributes* aAttributes,
 595       mozilla::dom::FromParser aFromParser, nsNodeInfoManager* aNodeInfoManager,
 596       nsHtml5DocumentBuilder* aBuilder,
 597       mozilla::dom::SVGContentCreatorFunction aCreator);
 598
 599   static nsIContent* CreateMathMLElement(nsAtom* aName,
 600                                          nsHtml5HtmlAttributes* aAttributes,
 601                                          nsNodeInfoManager* aNodeInfoManager,
 602                                          nsHtml5DocumentBuilder* aBuilder);
 603
 604   static void SetFormElement(nsIContent* aNode, nsIContent* aParent);
 605
 606   static nsresult AppendIsindexPrompt(nsIContent* parent,
 607                                       nsHtml5DocumentBuilder* aBuilder);
 608
 609   static nsresult FosterParentText(nsIContent* aStackParent, char16_t* aBuffer,
 610                                    uint32_t aLength, nsIContent* aTable,
 611                                    nsHtml5DocumentBuilder* aBuilder);
 612
 613   static nsresult AppendComment(nsIContent* aParent, char16_t* aBuffer,
 614                                 int32_t aLength,
 615                                 nsHtml5DocumentBuilder* aBuilder);
 616
 617   static nsresult AppendCommentToDocument(char16_t* aBuffer, int32_t aLength,
 618                                           nsHtml5DocumentBuilder* aBuilder);
 619
 620   static nsresult AppendDoctypeToDocument(nsAtom* aName,
 621                                           const nsAString& aPublicId,
 622                                           const nsAString& aSystemId,
 623                                           nsHtml5DocumentBuilder* aBuilder);
 624
 625   static nsIContent* GetDocumentFragmentForTemplate(nsIContent* aNode);
 626   static void SetDocumentFragmentForTemplate(nsIContent* aNode,
 627                                              nsIContent* aDocumentFragment);
 628
 629   static nsIContent* GetFosterParent(nsIContent* aTable,
 630                                      nsIContent* aStackParent);
 631
 632   static void PreventScriptExecution(nsIContent* aNode);
 633
 634   static void DoneAddingChildren(nsIContent* aNode);
 635
 636   static void DoneCreatingElement(nsIContent* aNode);
 637
 638   static void SvgLoad(nsIContent* aNode);
 639
 640   static void MarkMalformedIfScript(nsIContent* aNode);
 641
 642   nsHtml5TreeOperation();
 643
 644   ~nsHtml5TreeOperation();
 645
 646   inline void Init(const treeOperation& aOperation) {
 647     NS_ASSERTION(mOperation.is<uninitialized>(),
 648                  "Op code must be uninitialized when initializing.");
 649     mOperation = aOperation;
 650   }
 651
 652   inline bool IsRunScriptThatMayDocumentWriteOrBlock() {
 653     return mOperation.is<opRunScriptThatMayDocumentWriteOrBlock>();
 654   }
 655
 656   inline bool IsMarkAsBroken() { return mOperation.is<opMarkAsBroken>(); }
 657
 658   inline void SetSnapshot(nsAHtml5TreeBuilderState* aSnapshot, int32_t aLine) {
 659     MOZ_ASSERT(
 660         IsRunScriptThatMayDocumentWriteOrBlock(),
 661         "Setting a snapshot for a tree operation other than eTreeOpRunScript!");
 662     MOZ_ASSERT(aSnapshot, "Initialized tree op with null snapshot.");
 663     opRunScriptThatMayDocumentWriteOrBlock data =
 664         mOperation.as<opRunScriptThatMayDocumentWriteOrBlock>();
 665     data.mBuilderState = aSnapshot;
 666     data.mLineNumber = aLine;
 667     mOperation = mozilla::AsVariant(data);
 668   }
 669
 670   nsresult Perform(nsHtml5TreeOpExecutor* aBuilder, nsIContent** aScriptElement,
 671                    bool* aInterrupted, bool* aStreamEnded);
 672
 673  private:
 674   nsHtml5TreeOperation(const nsHtml5TreeOperation&) = delete;
 675   nsHtml5TreeOperation& operator=(const nsHtml5TreeOperation&) = delete;
 676
 677   treeOperation mOperation;
 678 };
 679
 680 #endif  // nsHtml5TreeOperation_h