gecko-dev/parser/html/nsHtml5TreeOpExecutor.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsHtml5TreeOpExecutor_h
#define nsHtml5TreeOpExecutor_h

#include "nsAtom.h"
#include "nsTraceRefcnt.h"
#include "nsHtml5TreeOperation.h"
#include "nsHtml5SpeculativeLoad.h"
#include "nsTArray.h"
#include "nsContentSink.h"
#include "nsNodeInfoManager.h"
#include "nsHtml5DocumentMode.h"
#include "nsIScriptElement.h"
#include "nsIParser.h"
#include "nsAHtml5TreeOpSink.h"
#include "nsHtml5TreeOpStage.h"
#include "nsIURI.h"
#include "nsTHashtable.h"
#include "nsHashKeys.h"
#include "mozilla/LinkedList.h"
#include "nsHtml5DocumentBuilder.h"
#include "mozilla/net/ReferrerPolicy.h"

class nsHtml5Parser;
class nsHtml5StreamParser;
class nsIContent;
class nsIDocument;

class nsHtml5TreeOpExecutor final
  : public nsHtml5DocumentBuilder
  , public nsIContentSink
  , public nsAHtml5TreeOpSink
  , public mozilla::LinkedListElement<nsHtml5TreeOpExecutor>
{
  friend class nsHtml5FlushLoopGuard;
  typedef mozilla::net::ReferrerPolicy ReferrerPolicy;
  using Encoding = mozilla::Encoding;
  template<typename T>
  using NotNull = mozilla::NotNull<T>;

public:
  NS_DECL_ISUPPORTS_INHERITED

private:
#ifdef DEBUG_NS_HTML5_TREE_OP_EXECUTOR_FLUSH
  static uint32_t sAppendBatchMaxSize;
  static uint32_t sAppendBatchSlotsExamined;
  static uint32_t sAppendBatchExaminations;
  static uint32_t sLongestTimeOffTheEventLoop;
  static uint32_t sTimesFlushLoopInterrupted;
#endif

  /**
   * Whether EOF needs to be suppressed
   */
  bool mSuppressEOF;

  bool mReadingFromStage;
  nsTArray<nsHtml5TreeOperation> mOpQueue;
  nsHtml5StreamParser* mStreamParser;

  /**
   * URLs already preloaded/preloading.
   */
  nsTHashtable<nsCStringHashKey> mPreloadedURLs;

  nsCOMPtr<nsIURI> mSpeculationBaseURI;

  /**
   * Speculative referrer policy
   */
  ReferrerPolicy mSpeculationReferrerPolicy;

  nsCOMPtr<nsIURI> mViewSourceBaseURI;

  /**
   * Whether the parser has started
   */
  bool mStarted;

  nsHtml5TreeOpStage mStage;

  bool mRunFlushLoopOnStack;

  bool mCallContinueInterruptedParsingIfEnabled;

  /**
   * Whether this executor has already complained about matters related
   * to character encoding declarations.
   */
  bool mAlreadyComplainedAboutCharset;

public:
  nsHtml5TreeOpExecutor();

protected:
  virtual ~nsHtml5TreeOpExecutor();

public:
  // nsIContentSink

  /**
   * Unimplemented. For interface compat only.
   */
  NS_IMETHOD WillParse() override;

  /**
   *
   */
  NS_IMETHOD WillBuildModel(nsDTDMode aDTDMode) override;

  /**
   * Emits EOF.
   */
  NS_IMETHOD DidBuildModel(bool aTerminated) override;

  /**
   * Forwards to nsContentSink
   */
  NS_IMETHOD WillInterrupt() override;

  /**
   * Unimplemented. For interface compat only.
   */
  NS_IMETHOD WillResume() override;

  /**
   * Sets the parser.
   */
  NS_IMETHOD SetParser(nsParserBase* aParser) override;

  /**
   * No-op for backwards compat.
   */
  virtual void FlushPendingNotifications(mozilla::FlushType aType) override;

  /**
   * Don't call. For interface compat only.
   */
  virtual void SetDocumentCharset(NotNull<const Encoding*> aEncoding) override
  {
    MOZ_ASSERT_UNREACHABLE("No one should call this.");
  }

  /**
   * Returns the document.
   */
  virtual nsISupports* GetTarget() override;

  virtual void ContinueInterruptedParsingAsync() override;

  bool IsScriptExecuting() override { return IsScriptExecutingImpl(); }

  // Not from interface

  void SetStreamParser(nsHtml5StreamParser* aStreamParser)
  {
    mStreamParser = aStreamParser;
  }

  void InitializeDocWriteParserState(nsAHtml5TreeBuilderState* aState,
                                     int32_t aLine);

  bool IsScriptEnabled();

  virtual nsresult MarkAsBroken(nsresult aReason) override;

  void StartLayout(bool* aInterrupted);

  void PauseDocUpdate(bool* aInterrupted);

  void FlushSpeculativeLoads();

  void RunFlushLoop();

  nsresult FlushDocumentWrite();

  void MaybeSuspend();

  void Start();

  void NeedsCharsetSwitchTo(NotNull<const Encoding*> aEncoding,
                            int32_t aSource,
                            uint32_t aLineNumber);

  void MaybeComplainAboutCharset(const char* aMsgId,
                                 bool aError,
                                 uint32_t aLineNumber);

  void ComplainAboutBogusProtocolCharset(nsIDocument* aDoc);

  bool HasStarted() { return mStarted; }

  bool IsFlushing() { return mFlushState >= eInFlush; }

#ifdef DEBUG
  bool IsInFlushLoop() { return mRunFlushLoopOnStack; }
#endif

  void RunScript(nsIContent* aScriptElement);

  /**
   * Flush the operations from the tree operations from the argument
   * queue unconditionally. (This is for the main thread case.)
   */
  virtual void MoveOpsFrom(nsTArray<nsHtml5TreeOperation>& aOpQueue) override;

  void ClearOpQueue();

  void RemoveFromStartOfOpQueue(size_t aNumberOfOpsToRemove);

  inline size_t OpQueueLength() { return mOpQueue.Length(); }

  nsHtml5TreeOpStage* GetStage() { return &mStage; }

  void StartReadingFromStage() { mReadingFromStage = true; }

  void StreamEnded();

#ifdef DEBUG
  void AssertStageEmpty() { mStage.AssertEmpty(); }
#endif

  nsIURI* GetViewSourceBaseURI();

  void PreloadScript(const nsAString& aURL,
                     const nsAString& aCharset,
                     const nsAString& aType,
                     const nsAString& aCrossOrigin,
                     const nsAString& aIntegrity,
                     bool aScriptFromHead,
                     bool aAsync,
                     bool aDefer,
                     bool aNoModule);

  void PreloadStyle(const nsAString& aURL,
                    const nsAString& aCharset,
                    const nsAString& aCrossOrigin,
                    const nsAString& aReferrerPolicy,
                    const nsAString& aIntegrity);

  void PreloadImage(const nsAString& aURL,
                    const nsAString& aCrossOrigin,
                    const nsAString& aSrcset,
                    const nsAString& aSizes,
                    const nsAString& aImageReferrerPolicy);

  void PreloadOpenPicture();

  void PreloadEndPicture();

  void PreloadPictureSource(const nsAString& aSrcset,
                            const nsAString& aSizes,
                            const nsAString& aType,
                            const nsAString& aMedia);

  void SetSpeculationBase(const nsAString& aURL);

  void SetSpeculationReferrerPolicy(ReferrerPolicy aReferrerPolicy);
  void SetSpeculationReferrerPolicy(const nsAString& aReferrerPolicy);

  void AddSpeculationCSP(const nsAString& aCSP);

  void AddBase(const nsAString& aURL);

private:
  nsHtml5Parser* GetParser();

  bool IsExternalViewSource();

  /**
   * Get a nsIURI for an nsString if the URL hasn't been preloaded yet.
   */
  already_AddRefed<nsIURI> ConvertIfNotPreloadedYet(const nsAString& aURL);

  /**
   * The base URI we would use for current preload operations
   */
  nsIURI* BaseURIForPreload();

  /**
   * Returns true if we haven't preloaded this URI yet, and adds it to the
   * list of preloaded URIs
   */
  bool ShouldPreloadURI(nsIURI* aURI);
};

#endif // nsHtml5TreeOpExecutor_h