dom/prototype/PrototypeDocumentContentSink.h

   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 https://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_PrototypeDocumentContentSink_h__
   8 #define mozilla_dom_PrototypeDocumentContentSink_h__
   9
  10 #include "mozilla/Attributes.h"
  11 #include "nsIContentSink.h"
  12 #include "nsTArray.h"
  13 #include "nsCOMPtr.h"
  14 #include "nsCRT.h"
  15 #include "nsCycleCollectionNoteChild.h"
  16 #include "nsCycleCollectionParticipant.h"
  17 #include "nsIDTD.h"
  18 #include "mozilla/dom/FromParser.h"
  19 #include "nsXULPrototypeDocument.h"
  20 #include "nsIStreamLoader.h"
  21 #include "nsIScriptContext.h"
  22 #include "nsICSSLoaderObserver.h"
  23 #include "mozilla/Logging.h"
  24 #include "js/experimental/JSStencil.h"
  25 #include "mozilla/RefPtr.h"
  26
  27 class nsIURI;
  28 class nsIChannel;
  29 class nsIContent;
  30 class nsIParser;
  31 class nsTextNode;
  32 class nsINode;
  33 class nsXULPrototypeElement;
  34 class nsXULPrototypePI;
  35 class nsXULPrototypeScript;
  36
  37 namespace mozilla::dom {
  38 class Element;
  39 class ScriptLoader;
  40 class Document;
  41 class XMLStylesheetProcessingInstruction;
  42 }  // namespace mozilla::dom
  43
  44 nsresult NS_NewPrototypeDocumentContentSink(nsIContentSink** aResult,
  45                                             mozilla::dom::Document* aDoc,
  46                                             nsIURI* aURI,
  47                                             nsISupports* aContainer,
  48                                             nsIChannel* aChannel);
  49
  50 namespace mozilla::dom {
  51
  52 class PrototypeDocumentContentSink final : public nsIStreamLoaderObserver,
  53                                            public nsIContentSink,
  54                                            public nsICSSLoaderObserver,
  55                                            public nsIOffThreadScriptReceiver {
  56  public:
  57   PrototypeDocumentContentSink();
  58
  59   nsresult Init(Document* aDoc, nsIURI* aURL, nsISupports* aContainer,
  60                 nsIChannel* aChannel);
  61
  62   // nsISupports
  63   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  64   NS_DECL_NSISTREAMLOADEROBSERVER
  65
  66   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(PrototypeDocumentContentSink,
  67                                            nsIContentSink)
  68
  69   // nsIContentSink
  70   NS_IMETHOD WillParse(void) override { return NS_OK; };
  71   NS_IMETHOD WillInterrupt(void) override { return NS_OK; };
  72   void WillResume() override{};
  73   NS_IMETHOD SetParser(nsParserBase* aParser) override;
  74   virtual void InitialTranslationCompleted() override;
  75   virtual void FlushPendingNotifications(FlushType aType) override{};
  76   virtual void SetDocumentCharset(NotNull<const Encoding*> aEncoding) override;
  77   virtual nsISupports* GetTarget() override;
  78   virtual bool IsScriptExecuting() override;
  79   virtual void ContinueInterruptedParsingAsync() override;
  80
  81   // nsICSSLoaderObserver
  82   NS_IMETHOD StyleSheetLoaded(StyleSheet* aSheet, bool aWasDeferred,
  83                               nsresult aStatus) override;
  84
  85   // nsIOffThreadScriptReceiver
  86   NS_IMETHOD OnScriptCompileComplete(JS::Stencil* aStencil,
  87                                      nsresult aStatus) override;
  88
  89   nsresult OnPrototypeLoadDone(nsXULPrototypeDocument* aPrototype);
  90
  91  protected:
  92   virtual ~PrototypeDocumentContentSink();
  93
  94   static LazyLogModule gLog;
  95
  96   nsIParser* GetParser();
  97
  98   void ContinueInterruptedParsingIfEnabled();
  99   void StartLayout();
 100
 101   virtual nsresult AddAttributes(nsXULPrototypeElement* aPrototype,
 102                                  Element* aElement);
 103
 104   RefPtr<nsParserBase> mParser;
 105   nsCOMPtr<nsIURI> mDocumentURI;
 106   RefPtr<Document> mDocument;
 107   RefPtr<ScriptLoader> mScriptLoader;
 108
 109   PrototypeDocumentContentSink* mNextSrcLoadWaiter;  // [OWNER] but not COMPtr
 110
 111   /**
 112    * The prototype-script of the current transcluded script that is being
 113    * loaded.  For document.write('<script src="nestedwrite.js"><\/script>')
 114    * to work, these need to be in a stack element type, and we need to hold
 115    * the top of stack here.
 116    */
 117   nsXULPrototypeScript* mCurrentScriptProto;
 118
 119   /**
 120    * Whether the current transcluded script is being compiled off thread.
 121    * The load event is blocked while this is in progress.
 122    */
 123   bool mOffThreadCompiling;
 124
 125   /**
 126    * If the current transcluded script is being compiled off thread, the
 127    * source for that script.
 128    */
 129   Utf8Unit* mOffThreadCompileStringBuf;
 130   size_t mOffThreadCompileStringLength;
 131
 132   /**
 133    * Wether the prototype document is still be traversed to create the DOM.
 134    * Layout will not be started until false.
 135    */
 136   bool mStillWalking;
 137
 138   /**
 139    * Number of style sheets still loading. Layout will not start until zero.
 140    */
 141   uint32_t mPendingSheets;
 142
 143   /**
 144    * Context stack, which maintains the state of the Builder and allows
 145    * it to be interrupted.
 146    */
 147   class ContextStack {
 148    protected:
 149     struct Entry {
 150       nsXULPrototypeElement* mPrototype;
 151       nsIContent* mElement;
 152       int32_t mIndex;
 153       Entry* mNext;
 154     };
 155
 156     Entry* mTop;
 157     int32_t mDepth;
 158
 159    public:
 160     ContextStack();
 161     ~ContextStack();
 162
 163     int32_t Depth() { return mDepth; }
 164
 165     nsresult Push(nsXULPrototypeElement* aPrototype, nsIContent* aElement);
 166     nsresult Pop();
 167     nsresult Peek(nsXULPrototypeElement** aPrototype, nsIContent** aElement,
 168                   int32_t* aIndex);
 169
 170     nsresult SetTopIndex(int32_t aIndex);
 171
 172     void Traverse(nsCycleCollectionTraversalCallback& aCallback,
 173                   const char* aName, uint32_t aFlags = 0);
 174     void Clear();
 175
 176     // Cycle collector helpers for ContextStack.
 177     friend void ImplCycleCollectionUnlink(
 178         PrototypeDocumentContentSink::ContextStack& aField) {
 179       aField.Clear();
 180     }
 181
 182     friend void ImplCycleCollectionTraverse(
 183         nsCycleCollectionTraversalCallback& aCallback,
 184         PrototypeDocumentContentSink::ContextStack& aField, const char* aName,
 185         uint32_t aFlags = 0) {
 186       aField.Traverse(aCallback, aName, aFlags);
 187     }
 188   };
 189
 190   friend class ContextStack;
 191   ContextStack mContextStack;
 192
 193   /**
 194    * The current prototype that we are walking to construct the
 195    * content model.
 196    */
 197   RefPtr<nsXULPrototypeDocument> mCurrentPrototype;
 198   nsresult CreateAndInsertPI(const nsXULPrototypePI* aProtoPI);
 199   nsresult ExecuteScript(nsXULPrototypeScript* aScript);
 200   nsresult LoadScript(nsXULPrototypeScript* aScriptProto, bool* aBlock);
 201
 202   /**
 203    * A wrapper around ResumeWalkInternal to report walking errors.
 204    */
 205   nsresult ResumeWalk();
 206
 207   /**
 208    * Resume (or initiate) an interrupted (or newly prepared)
 209    * prototype walk.
 210    */
 211   nsresult ResumeWalkInternal();
 212
 213   /**
 214    * Called at the end of ResumeWalk(), from StyleSheetLoaded(),
 215    * and from DocumentL10n.
 216    * If walking, stylesheets and l10n are not blocking, it
 217    * will trigger `DoneWalking()`.
 218    */
 219   nsresult MaybeDoneWalking();
 220
 221   /**
 222    * Called from `MaybeDoneWalking()`.
 223    * Expects that both the prototype document walk is complete and
 224    * all referenced stylesheets finished loading.
 225    */
 226   nsresult DoneWalking();
 227
 228   /**
 229    * Create a delegate content model element from a prototype.
 230    * Note that the resulting content node is not bound to any tree
 231    */
 232   nsresult CreateElementFromPrototype(nsXULPrototypeElement* aPrototype,
 233                                       Element** aResult, nsIContent* aParent);
 234   /**
 235    * Prepare to walk the current prototype.
 236    */
 237   nsresult PrepareToWalk();
 238   /**
 239    * Creates a processing instruction based on aProtoPI and inserts
 240    * it to the DOM.
 241    */
 242   nsresult CreateAndInsertPI(const nsXULPrototypePI* aProtoPI, nsINode* aParent,
 243                              nsINode* aBeforeThis);
 244
 245   /**
 246    * Inserts the passed <?xml-stylesheet ?> PI at the specified
 247    * index. Loads and applies the associated stylesheet
 248    * asynchronously.
 249    * The prototype document walk can happen before the stylesheets
 250    * are loaded, but the final steps in the load process (see
 251    * DoneWalking()) are not run before all the stylesheets are done
 252    * loading.
 253    */
 254   nsresult InsertXMLStylesheetPI(const nsXULPrototypePI* aProtoPI,
 255                                  nsINode* aParent, nsINode* aBeforeThis,
 256                                  XMLStylesheetProcessingInstruction* aPINode);
 257   void CloseElement(Element* aElement, bool aHadChildren);
 258 };
 259
 260 }  // namespace mozilla::dom
 261
 262 #endif  // mozilla_dom_PrototypeDocumentContentSink_h__