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