#pragma once
#include "Timer.h"
#include <memory>
#include <wtf/FastMalloc.h>
#include <wtf/HashSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class CSSStyleSheet;
class Document;
class Element;
class Node;
class ProcessingInstruction;
class StyleResolver;
class StyleSheet;
class StyleSheetContents;
class StyleSheetList;
class ShadowRoot;
class TreeScope;
namespace Style {
enum class ScopeOrdinal : int {
ContainingHost = -1, Element = 0, FirstSlot = 1, Shadow = std::numeric_limits<int>::max(), };
class Scope {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit Scope(Document&);
explicit Scope(ShadowRoot&);
~Scope();
const Vector<RefPtr<CSSStyleSheet>>& activeStyleSheets() const { return m_activeStyleSheets; }
const Vector<RefPtr<StyleSheet>>& styleSheetsForStyleSheetList();
const Vector<RefPtr<CSSStyleSheet>> activeStyleSheetsForInspector();
void addStyleSheetCandidateNode(Node&, bool createdByParser);
void removeStyleSheetCandidateNode(Node&);
String preferredStylesheetSetName() const { return m_preferredStylesheetSetName; }
void setPreferredStylesheetSetName(const String&);
void addPendingSheet(const Element&);
void removePendingSheet(const Element&);
void addPendingSheet(const ProcessingInstruction&);
void removePendingSheet(const ProcessingInstruction&);
bool hasPendingSheets() const;
bool hasPendingSheetsBeforeBody() const;
bool hasPendingSheetsInBody() const;
bool hasPendingSheet(const Element&) const;
bool hasPendingSheetInBody(const Element&) const;
bool hasPendingSheet(const ProcessingInstruction&) const;
bool usesStyleBasedEditability() { return m_usesStyleBasedEditability; }
bool activeStyleSheetsContains(const CSSStyleSheet*) const;
void evaluateMediaQueriesForViewportChange();
void evaluateMediaQueriesForAccessibilitySettingsChange();
void didChangeActiveStyleSheetCandidates();
void didChangeStyleSheetContents();
WEBCORE_EXPORT void didChangeStyleSheetEnvironment();
bool hasPendingUpdate() const { return m_pendingUpdate || m_hasDescendantWithPendingUpdate; }
void flushPendingUpdate();
#if ENABLE(XSLT)
Vector<Ref<ProcessingInstruction>> collectXSLTransforms();
#endif
StyleResolver& resolver();
StyleResolver* resolverIfExists();
void clearResolver();
void releaseMemory();
const Document& document() const { return m_document; }
static Scope& forNode(Node&);
static Scope* forOrdinal(Element&, ScopeOrdinal);
private:
bool shouldUseSharedUserAgentShadowTreeStyleResolver() const;
void didRemovePendingStylesheet();
enum class UpdateType { ActiveSet, ContentsOrInterpretation };
void updateActiveStyleSheets(UpdateType);
void scheduleUpdate(UpdateType);
template <typename TestFunction> void evaluateMediaQueries(TestFunction&&);
WEBCORE_EXPORT void flushPendingSelfUpdate();
WEBCORE_EXPORT void flushPendingDescendantUpdates();
void collectActiveStyleSheets(Vector<RefPtr<StyleSheet>>&);
enum StyleResolverUpdateType {
Reconstruct,
Reset,
Additive
};
StyleResolverUpdateType analyzeStyleSheetChange(const Vector<RefPtr<CSSStyleSheet>>& newStylesheets, bool& requiresFullStyleRecalc);
void updateStyleResolver(Vector<RefPtr<CSSStyleSheet>>&, StyleResolverUpdateType);
void pendingUpdateTimerFired();
void clearPendingUpdate();
Document& m_document;
ShadowRoot* m_shadowRoot { nullptr };
std::unique_ptr<StyleResolver> m_resolver;
Vector<RefPtr<StyleSheet>> m_styleSheetsForStyleSheetList;
Vector<RefPtr<CSSStyleSheet>> m_activeStyleSheets;
Timer m_pendingUpdateTimer;
mutable std::unique_ptr<HashSet<const CSSStyleSheet*>> m_weakCopyOfActiveStyleSheetListForFastLookup;
HashSet<const ProcessingInstruction*> m_processingInstructionsWithPendingSheets;
HashSet<const Element*> m_elementsInHeadWithPendingSheets;
HashSet<const Element*> m_elementsInBodyWithPendingSheets;
std::optional<UpdateType> m_pendingUpdate;
bool m_hasDescendantWithPendingUpdate { false };
ListHashSet<Node*> m_styleSheetCandidateNodes;
String m_preferredStylesheetSetName;
bool m_usesStyleBasedEditability { false };
bool m_isUpdatingStyleResolver { false };
};
inline bool Scope::hasPendingSheets() const
{
return hasPendingSheetsBeforeBody() || !m_elementsInBodyWithPendingSheets.isEmpty();
}
inline bool Scope::hasPendingSheetsBeforeBody() const
{
return !m_elementsInHeadWithPendingSheets.isEmpty() || !m_processingInstructionsWithPendingSheets.isEmpty();
}
inline bool Scope::hasPendingSheetsInBody() const
{
return !m_elementsInBodyWithPendingSheets.isEmpty();
}
inline void Scope::flushPendingUpdate()
{
if (m_hasDescendantWithPendingUpdate)
flushPendingDescendantUpdates();
if (m_pendingUpdate)
flushPendingSelfUpdate();
}
inline ScopeOrdinal& operator++(ScopeOrdinal& ordinal)
{
ASSERT(ordinal < ScopeOrdinal::Shadow);
return ordinal = static_cast<ScopeOrdinal>(static_cast<int>(ordinal) + 1);
}
}
}