parser/html/nsHtml5Parser.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef NS_HTML5_PARSER
   7 #define NS_HTML5_PARSER
   8
   9 #include "mozilla/UniquePtr.h"
  10 #include "nsIParser.h"
  11 #include "nsDeque.h"
  12 #include "nsIContentSink.h"
  13 #include "nsIRequest.h"
  14 #include "nsIChannel.h"
  15 #include "nsCOMArray.h"
  16 #include "nsContentSink.h"
  17 #include "nsCycleCollectionParticipant.h"
  18 #include "nsHtml5OwningUTF16Buffer.h"
  19 #include "nsHtml5TreeOpExecutor.h"
  20 #include "nsHtml5StreamParser.h"
  21 #include "nsHtml5AtomTable.h"
  22 #include "nsWeakReference.h"
  23 #include "nsHtml5StreamListener.h"
  24 #include "nsCharsetSource.h"
  25
  26 class nsHtml5Parser final : public nsIParser, public nsSupportsWeakReference {
  27  public:
  28   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  29
  30   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsHtml5Parser, nsIParser)
  31
  32   nsHtml5Parser();
  33
  34   /* Start nsIParser */
  35   /**
  36    * No-op for backwards compat.
  37    */
  38   NS_IMETHOD_(void) SetContentSink(nsIContentSink* aSink) override;
  39
  40   /**
  41    * Returns the tree op executor for backwards compat.
  42    */
  43   NS_IMETHOD_(nsIContentSink*) GetContentSink() override;
  44
  45   /**
  46    * Always returns "view" for backwards compat.
  47    */
  48   NS_IMETHOD_(void) GetCommand(nsCString& aCommand) override;
  49
  50   /**
  51    * No-op for backwards compat.
  52    */
  53   NS_IMETHOD_(void) SetCommand(const char* aCommand) override;
  54
  55   /**
  56    * No-op for backwards compat.
  57    */
  58   NS_IMETHOD_(void) SetCommand(eParserCommands aParserCommand) override;
  59
  60   /**
  61    *  Call this method once you've created a parser, and want to instruct it
  62    *  about what charset to load
  63    *
  64    *  @param   aEncoding the charset of a document
  65    *  @param   aCharsetSource the source of the charset
  66    */
  67   virtual void SetDocumentCharset(NotNull<const Encoding*> aEncoding,
  68                                   int32_t aSource,
  69                                   bool aForceAutoDetection) override;
  70
  71   /**
  72    * Get the channel associated with this parser
  73    * @param aChannel out param that will contain the result
  74    * @return NS_OK if successful or NS_NOT_AVAILABLE if not
  75    */
  76   nsresult GetChannel(nsIChannel** aChannel);
  77
  78   /**
  79    * Get the stream parser for this parser
  80    */
  81   virtual nsIStreamListener* GetStreamListener() override;
  82
  83   /**
  84    * Don't call. For interface compat only.
  85    */
  86   NS_IMETHOD ContinueInterruptedParsing() override;
  87
  88   /**
  89    * Blocks the parser.
  90    */
  91   NS_IMETHOD_(void) BlockParser() override;
  92
  93   /**
  94    * Unblocks the parser.
  95    */
  96   NS_IMETHOD_(void) UnblockParser() override;
  97
  98   /**
  99    * Asynchronously continues parsing.
 100    */
 101   NS_IMETHOD_(void) ContinueInterruptedParsingAsync() override;
 102
 103   /**
 104    * Query whether the parser is enabled (i.e. not blocked) or not.
 105    */
 106   NS_IMETHOD_(bool) IsParserEnabled() override;
 107
 108   /**
 109    * Query whether the parser is closed (i.e. document.closed() is called) or
 110    * not.
 111    */
 112   NS_IMETHOD_(bool) IsParserClosed() override;
 113
 114   /**
 115    * Query whether the parser thinks it's done with parsing.
 116    */
 117   NS_IMETHOD_(bool) IsComplete() override;
 118
 119   /**
 120    * Set up request observer.
 121    *
 122    * @param   aURL used for View Source title
 123    */
 124   NS_IMETHOD Parse(nsIURI* aURL) override;
 125
 126   /**
 127    * document.write and document.close
 128    *
 129    * @param   aSourceBuffer the argument of document.write (empty for .close())
 130    * @param   aKey a key unique to the script element that caused this call
 131    * @param   aLastCall true if .close() false if .write()
 132    */
 133   nsresult Parse(const nsAString& aSourceBuffer, void* aKey, bool aLastCall);
 134
 135   /**
 136    * Stops the parser prematurely
 137    */
 138   NS_IMETHOD Terminate() override;
 139
 140   /**
 141    * True if the insertion point (per HTML5) is defined.
 142    */
 143   virtual bool IsInsertionPointDefined() override;
 144
 145   /**
 146    * Call immediately before starting to evaluate a parser-inserted script or
 147    * in general when the spec says to increment the script nesting level.
 148    */
 149   void IncrementScriptNestingLevel() final;
 150
 151   /**
 152    * Call immediately after having evaluated a parser-inserted script or
 153    * generally want to restore to the state before the last
 154    * IncrementScriptNestingLevel call.
 155    */
 156   void DecrementScriptNestingLevel() final;
 157
 158   /**
 159    * True if this is an HTML5 parser whose script nesting level (in
 160    * the sense of
 161    * <https://html.spec.whatwg.org/multipage/parsing.html#script-nesting-level>)
 162    * is nonzero.
 163    */
 164   bool HasNonzeroScriptNestingLevel() const final;
 165
 166   /**
 167    * Marks the HTML5 parser as not a script-created parser: Prepares the
 168    * parser to be able to read a stream.
 169    *
 170    * @param aCommand the parser command (Yeah, this is bad API design. Let's
 171    * make this better when retiring nsIParser)
 172    */
 173   void MarkAsNotScriptCreated(const char* aCommand);
 174
 175   /**
 176    * True if this is a script-created HTML5 parser.
 177    */
 178   virtual bool IsScriptCreated() override;
 179
 180   /* End nsIParser  */
 181
 182   // Not from an external interface
 183   // Non-inherited methods
 184
 185  public:
 186   /**
 187    * Initializes the parser to load from a channel.
 188    */
 189   virtual nsresult Initialize(mozilla::dom::Document* aDoc, nsIURI* aURI,
 190                               nsISupports* aContainer, nsIChannel* aChannel);
 191
 192   inline nsHtml5Tokenizer* GetTokenizer() { return mTokenizer.get(); }
 193
 194   void InitializeDocWriteParserState(nsAHtml5TreeBuilderState* aState,
 195                                      int32_t aLine);
 196
 197   void DropStreamParser() {
 198     if (GetStreamParser()) {
 199       GetStreamParser()->DropTimer();
 200       mStreamListener->DropDelegate();
 201       mStreamListener = nullptr;
 202     }
 203   }
 204
 205   void StartTokenizer(bool aScriptingEnabled);
 206
 207   void ContinueAfterFailedCharsetSwitch();
 208
 209   nsHtml5StreamParser* GetStreamParser() {
 210     if (!mStreamListener) {
 211       return nullptr;
 212     }
 213     return mStreamListener->GetDelegate();
 214   }
 215
 216   void PermanentlyUndefineInsertionPoint() {
 217     mInsertionPointPermanentlyUndefined = true;
 218   }
 219
 220   /**
 221    * Parse until pending data is exhausted or a script blocks the parser
 222    */
 223   nsresult ParseUntilBlocked();
 224
 225   /**
 226    * Start our executor.  This is meant to be used from document.open() _only_
 227    * and does some work similar to what nsHtml5StreamParser::OnStartRequest does
 228    * for normal parses.
 229    */
 230   nsresult StartExecutor();
 231
 232  private:
 233   virtual ~nsHtml5Parser();
 234
 235   // State variables
 236
 237   /**
 238    * Whether the last character tokenized was a carriage return (for CRLF)
 239    */
 240   bool mLastWasCR;
 241
 242   /**
 243    * Whether the last character tokenized was a carriage return (for CRLF)
 244    * when preparsing document.write.
 245    */
 246   bool mDocWriteSpeculativeLastWasCR;
 247
 248   /**
 249    * The parser is blocking on the load of an external script from a web
 250    * page, or any number of extension content scripts.
 251    */
 252   uint32_t mBlocked;
 253
 254   /**
 255    * Whether the document.write() speculator is already active.
 256    */
 257   bool mDocWriteSpeculatorActive;
 258
 259   /**
 260    * The number of IncrementScriptNestingLevel calls we've seen without a
 261    * matching DecrementScriptNestingLevel.
 262    */
 263   int32_t mScriptNestingLevel;
 264
 265   /**
 266    * True if document.close() has been called.
 267    */
 268   bool mDocumentClosed;
 269
 270   bool mInDocumentWrite;
 271
 272   /**
 273    * This is set when the tokenizer has seen EOF. The purpose is to
 274    * keep the insertion point undefined between the time the
 275    * parser has reached the point where it can't accept more input
 276    * and the time the document's mParser is set to nullptr.
 277    * Scripts can run during this time period due to an update
 278    * batch ending and due to various end-of-parse events firing.
 279    * (Setting mParser on the document to nullptr at the point
 280    * where this flag gets set to true would break things that for
 281    * legacy reasons assume that mParser on the document stays
 282    * non-null though the end-of-parse events.)
 283    */
 284   bool mInsertionPointPermanentlyUndefined;
 285
 286   // Portable parser objects
 287   /**
 288    * The first buffer in the pending UTF-16 buffer queue
 289    */
 290   RefPtr<nsHtml5OwningUTF16Buffer> mFirstBuffer;
 291
 292   /**
 293    * The last buffer in the pending UTF-16 buffer queue. Always points
 294    * to a sentinel object with nullptr as its parser key.
 295    */
 296   nsHtml5OwningUTF16Buffer* mLastBuffer;  // weak ref;
 297
 298   /**
 299    * The tree operation executor
 300    */
 301   RefPtr<nsHtml5TreeOpExecutor> mExecutor;
 302
 303   /**
 304    * The HTML5 tree builder
 305    */
 306   const mozilla::UniquePtr<nsHtml5TreeBuilder> mTreeBuilder;
 307
 308   /**
 309    * The HTML5 tokenizer
 310    */
 311   const mozilla::UniquePtr<nsHtml5Tokenizer> mTokenizer;
 312
 313   /**
 314    * Another HTML5 tree builder for preloading document.written content.
 315    */
 316   mozilla::UniquePtr<nsHtml5TreeBuilder> mDocWriteSpeculativeTreeBuilder;
 317
 318   /**
 319    * Another HTML5 tokenizer for preloading document.written content.
 320    */
 321   mozilla::UniquePtr<nsHtml5Tokenizer> mDocWriteSpeculativeTokenizer;
 322
 323   /**
 324    * The stream listener holding the stream parser.
 325    */
 326   RefPtr<nsHtml5StreamListener> mStreamListener;
 327
 328   /**
 329    *
 330    */
 331   int32_t mRootContextLineNumber;
 332
 333   /**
 334    * Whether it's OK to transfer parsing back to the stream parser
 335    */
 336   bool mReturnToStreamParserPermitted;
 337
 338   /**
 339    * The scoped atom table
 340    */
 341   nsHtml5AtomTable mAtomTable;
 342 };
 343 #endif