Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/C/Firefox/parser/html/ (Browser von der Mozilla Stiftung Version 136.0.1^©) Datei vom 10.2.2025 mit Größe 8 kB

Quellcode-Bibliothek nsHtml5TreeOpExecutor.h Sprache: C

/* 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 "nsTHashSet.h"
#include "nsHashKeys.h"
#include "mozilla/LinkedList.h"
#include "nsHtml5DocumentBuilder.h"
#include "nsCharsetSource.h"

class nsHtml5Parser;
class nsHtml5StreamParser;
class nsIContent;
namespace mozilla {
namespace dom {
class Document;
}
}  // namespace mozilla

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

public:
  NS_DECL_ISUPPORTS_INHERITED

private:
#ifdef DEBUG
  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.
   */
  nsTHashSet<nsCString> mPreloadedURLs;

  nsCOMPtr<nsIURI> mSpeculationBaseURI;

  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;

  /**
   * Whether this executor has already complained about the tree being too
   * deep.
   */
  bool mAlreadyComplainedAboutDeepTree;

public:
  nsHtml5TreeOpExecutor();

protected:
  virtual ~nsHtml5TreeOpExecutor();

public:
  // nsIContentSink

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

  NS_IMETHOD WillBuildModel(nsDTDMode /* unused */) override {
    return WillBuildModel();
  }
  nsresult WillBuildModel();

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

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

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

  virtual nsIContentSink* AsExecutor() override { return this; }

  virtual void InitialTranslationCompleted() 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 CommitToInternalEncoding();

  [[nodiscard]] bool TakeOpsFromStage();

  void MaybeSuspend();

  void Start();

  void SetDocumentCharsetAndSource(NotNull<const Encoding*> aEncoding,
                                   nsCharsetSource aCharsetSource);

  void UpdateCharsetSource(nsCharsetSource aCharsetSource);

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

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

  void ComplainAboutBogusProtocolCharset(mozilla::dom::Document* aDoc,
                                         bool aUnrecognized);

  void MaybeComplainAboutDeepTree(uint32_t aLineNumber);

  bool HasStarted() { return mStarted; }

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

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

  void RunScript(nsIContent* aScriptElement, bool aMayDocumentWriteOrBlock);

  /**
   * Flush the operations from the tree operations from the argument
   * queue unconditionally. (This is for the main thread case.)
   */
  [[nodiscard]] virtual bool 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& aMedia, const nsAString& aNonce,
                     const nsAString& aFetchPriority,
                     const nsAString& aIntegrity,
                     ReferrerPolicy aReferrerPolicy, bool aScriptFromHead,
                     bool aAsync, bool aDefer, bool aLinkPreload);

  void PreloadStyle(const nsAString& aURL, const nsAString& aCharset,
                    const nsAString& aCrossOrigin, const nsAString& aMedia,
                    const nsAString& aReferrerPolicy, const nsAString& aNonce,
                    const nsAString& aIntegrity, bool aLinkPreload,
                    const nsAString& aFetchPriority);

  void PreloadImage(const nsAString& aURL, const nsAString& aCrossOrigin,
                    const nsAString& aMedia, const nsAString& aSrcset,
                    const nsAString& aSizes,
                    const nsAString& aImageReferrerPolicy, bool aLinkPreload,
                    const nsAString& aFetchPriority);

  void PreloadOpenPicture();

  void PreloadEndPicture();

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

  void PreloadFont(const nsAString& aURL, const nsAString& aCrossOrigin,
                   const nsAString& aMedia, const nsAString& aReferrerPolicy,
                   const nsAString& aFetchPriority);

  void PreloadFetch(const nsAString& aURL, const nsAString& aCrossOrigin,
                    const nsAString& aMedia, const nsAString& aReferrerPolicy,
                    const nsAString& aFetchPriority);

  void SetSpeculationBase(const nsAString& aURL);

  void UpdateReferrerInfoFromMeta(const nsAString& aMetaReferrer);

  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 above, plus also checks that the media attribute applies.
   */
  already_AddRefed<nsIURI> ConvertIfNotPreloadedYetAndMediaApplies(
      const nsAString& aURL, const nsAString& aMedia);

  /** Returns whether the given media attribute applies to mDocument */
  bool MediaApplies(const nsAString& aMedia);

  /**
   * 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);

  ReferrerPolicy GetPreloadReferrerPolicy(const nsAString& aReferrerPolicy);

  ReferrerPolicy GetPreloadReferrerPolicy(ReferrerPolicy aReferrerPolicy);
};

#endif  // nsHtml5TreeOpExecutor_h

quality100%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.14Bemerkung: (vorverarbeitet) ¤

*Bot Zugriff

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.